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 */
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 void destroy_cpp_file (_cpp_file *);
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);
185 /* Given a filename in FILE->PATH, with the empty string interpreted
188 On success FILE contains an open file descriptor and stat
189 information for the file. On failure the file descriptor is -1 and
190 the appropriate errno is also stored in FILE. Returns TRUE iff
193 We used to open files in nonblocking mode, but that caused more
194 problems than it solved. Do take care not to acquire a controlling
195 terminal by mistake (this can't happen on sane systems, but
196 paranoia is a virtue).
198 Use the three-argument form of open even though we aren't
199 specifying O_CREAT, to defend against broken system headers.
201 O_BINARY tells some runtime libraries (notably DJGPP) not to do
202 newline translation; we can handle DOS line breaks just fine
205 open_file (_cpp_file *file)
207 if (file->path[0] == '\0')
210 set_stdin_to_binary_mode ();
213 file->fd = open (file->path, O_RDONLY | O_NOCTTY | O_BINARY, 0666);
217 if (fstat (file->fd, &file->st) == 0)
219 if (!S_ISDIR (file->st.st_mode))
225 /* Ignore a directory and continue the search. The file we're
226 looking for may be elsewhere in the search path. */
233 else if (errno == ENOTDIR)
236 file->err_no = errno;
241 /* Temporary PCH intercept of opening a file. Try to find a PCH file
242 based on FILE->name and FILE->dir, and test those found for
243 validity using PFILE->cb.valid_pch. Return true iff a valid file is
244 found. Set *INVALID_PCH if a PCH file is found but wasn't valid. */
247 pch_open_file (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
249 static const char extension[] = ".gch";
250 const char *path = file->path;
256 /* No PCH on <stdin> or if not requested. */
257 if (file->name[0] == '\0' || !pfile->cb.valid_pch)
260 flen = strlen (path);
261 len = flen + sizeof (extension);
262 pchname = xmalloc (len);
263 memcpy (pchname, path, flen);
264 memcpy (pchname + flen, extension, sizeof (extension));
266 if (stat (pchname, &st) == 0)
270 size_t dlen, plen = len;
272 if (!S_ISDIR (st.st_mode))
273 valid = validate_pch (pfile, file, pchname);
274 else if ((pchdir = opendir (pchname)) != NULL)
276 pchname[plen - 1] = '/';
277 while ((d = readdir (pchdir)) != NULL)
279 dlen = strlen (d->d_name) + 1;
280 if ((strcmp (d->d_name, ".") == 0)
281 || (strcmp (d->d_name, "..") == 0))
283 if (dlen + plen > len)
286 pchname = xrealloc (pchname, len);
288 memcpy (pchname + plen, d->d_name, dlen);
289 valid = validate_pch (pfile, file, pchname);
302 file->pchname = pchname;
309 /* Try to open the path FILE->name appended to FILE->dir. This is
310 where remap and PCH intercept the file lookup process. Return true
311 if the file was found, whether or not the open was successful.
312 Set *INVALID_PCH to true if a PCH file is found but wasn't valid. */
315 find_file_in_dir (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
319 if (CPP_OPTION (pfile, remap) && (path = remap_filename (pfile, file)))
322 path = append_file_to_dir (file->name, file->dir);
325 if (pch_open_file (pfile, file, invalid_pch))
328 if (open_file (file))
331 if (file->err_no != ENOENT)
333 open_file_failed (pfile, file);
338 file->path = file->name;
343 _cpp_find_failed (_cpp_file *file)
345 return file->err_no != 0;
348 /* Given a filename FNAME search for such a file in the include path
349 starting from START_DIR. If FNAME is the empty string it is
350 interpreted as STDIN if START_DIR is PFILE->no_seach_path.
352 If the file is not found in the file cache fall back to the O/S and
353 add the result to our cache.
355 If the file was not found in the filesystem, or there was an error
356 opening it, then ERR_NO is nonzero and FD is -1. If the file was
357 found, then ERR_NO is zero and FD could be -1 or an open file
358 descriptor. FD can be -1 if the file was found in the cache and
359 had previously been closed. To open it again pass the return value
363 _cpp_find_file (cpp_reader *pfile, const char *fname, cpp_dir *start_dir, bool fake)
365 struct file_hash_entry *entry, **hash_slot;
367 bool invalid_pch = false;
369 /* Ensure we get no confusion between cached files and directories. */
370 if (start_dir == NULL)
371 cpp_error (pfile, CPP_DL_ICE, "NULL directory in find_file");
373 hash_slot = (struct file_hash_entry **)
374 htab_find_slot_with_hash (pfile->file_hash, fname,
375 htab_hash_string (fname),
378 /* First check the cache before we resort to memory allocation. */
379 entry = search_cache (*hash_slot, start_dir);
381 return entry->u.file;
383 file = make_cpp_file (pfile, start_dir, fname);
385 /* Try each path in the include chain. */
388 if (find_file_in_dir (pfile, file, &invalid_pch))
391 file->dir = file->dir->next;
392 if (file->dir == NULL)
394 open_file_failed (pfile, file);
397 cpp_error (pfile, CPP_DL_ERROR,
398 "one or more PCH files were found, but they were invalid");
399 if (!cpp_get_options (pfile)->warn_invalid_pch)
400 cpp_error (pfile, CPP_DL_ERROR,
401 "use -Winvalid-pch for more information");
406 /* Only check the cache for the starting location (done above)
407 and the quote and bracket chain heads because there are no
408 other possible starting points for searches. */
409 if (file->dir != pfile->bracket_include
410 && file->dir != pfile->quote_include)
413 entry = search_cache (*hash_slot, file->dir);
420 /* Cache for START_DIR too, sharing the _cpp_file structure. */
421 free ((char *) file->name);
423 file = entry->u.file;
427 /* This is a new file; put it in the list. */
428 file->next_file = pfile->all_files;
429 pfile->all_files = file;
432 /* Store this new result in the hash table. */
433 entry = new_file_hash_entry (pfile);
434 entry->next = *hash_slot;
435 entry->start_dir = start_dir;
436 entry->u.file = file;
442 /* Read a file into FILE->buffer, returning true on success.
444 If FILE->fd is something weird, like a block device, we don't want
445 to read it at all. Don't even try to figure out what something is,
446 except for plain files and block devices, since there is no
447 reliable portable way of doing this.
449 FIXME: Flush file cache and try again if we run out of memory. */
451 read_file_guts (cpp_reader *pfile, _cpp_file *file)
453 ssize_t size, total, count;
457 if (S_ISBLK (file->st.st_mode))
459 cpp_error (pfile, CPP_DL_ERROR, "%s is a block device", file->path);
463 regular = S_ISREG (file->st.st_mode);
466 /* off_t might have a wider range than ssize_t - in other words,
467 the max size of a file might be bigger than the address
468 space. We can't handle a file that large. (Anyone with
469 a single source file bigger than 2GB needs to rethink
470 their coding style.) Some systems (e.g. AIX 4.1) define
471 SSIZE_MAX to be much smaller than the actual range of the
472 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
474 if (file->st.st_size > INTTYPE_MAXIMUM (ssize_t))
476 cpp_error (pfile, CPP_DL_ERROR, "%s is too large", file->path);
480 size = file->st.st_size;
483 /* 8 kilobytes is a sensible starting size. It ought to be bigger
484 than the kernel pipe buffer, and it's definitely bigger than
485 the majority of C source files. */
488 buf = xmalloc (size + 1);
490 while ((count = read (file->fd, buf + total, size - total)) > 0)
499 buf = xrealloc (buf, size + 1);
505 cpp_errno (pfile, CPP_DL_ERROR, file->path);
509 if (regular && total != size && STAT_SIZE_RELIABLE (file->st))
510 cpp_error (pfile, CPP_DL_WARNING,
511 "%s is shorter than expected", file->path);
513 file->buffer = _cpp_convert_input (pfile, CPP_OPTION (pfile, input_charset),
514 buf, size, total, &file->st.st_size);
515 file->buffer_valid = true;
520 /* Convenience wrapper around read_file_guts that opens the file if
521 necessary and closes the file descriptor after reading. FILE must
522 have been passed through find_file() at some stage. */
524 read_file (cpp_reader *pfile, _cpp_file *file)
526 /* If we already have its contents in memory, succeed immediately. */
527 if (file->buffer_valid)
530 /* If an earlier read failed for some reason don't try again. */
531 if (file->dont_read || file->err_no)
534 if (file->fd == -1 && !open_file (file))
536 open_file_failed (pfile, file);
540 file->dont_read = !read_file_guts (pfile, file);
544 return !file->dont_read;
547 /* Returns TRUE if FILE's contents have been successfully placed in
548 FILE->buffer and the file should be stacked, otherwise false. */
550 should_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
554 /* Skip once-only files. */
558 /* We must mark the file once-only if #import now, before header
559 guard checks. Otherwise, undefining the header guard might
560 cause the file to be re-stacked. */
563 _cpp_mark_file_once_only (pfile, file);
565 /* Don't stack files that have been stacked before. */
566 if (file->stack_count)
570 /* Skip if the file had a header guard and the macro is defined.
571 PCH relies on this appearing before the PCH handler below. */
572 if (file->cmacro && file->cmacro->type == NT_MACRO)
575 /* Handle PCH files immediately; don't stack them. */
576 if (include_pch_p (file))
578 pfile->cb.read_pch (pfile, file->path, file->fd, file->pchname);
584 if (!read_file (pfile, file))
587 /* Now we've read the file's contents, we can stack it if there
588 are no once-only files. */
589 if (!pfile->seen_once_only)
592 /* We may have read the file under a different name. Look
593 for likely candidates and compare file contents to be sure. */
594 for (f = pfile->all_files; f; f = f->next_file)
599 if ((import || f->once_only)
601 && f->st.st_mtime == file->st.st_mtime
602 && f->st.st_size == file->st.st_size)
605 bool same_file_p = false;
607 if (f->buffer && !f->buffer_valid)
609 /* We already have a buffer but it is not valid, because
610 the file is still stacked. Make a new one. */
611 ref_file = make_cpp_file (pfile, f->dir, f->name);
612 ref_file->path = f->path;
615 /* The file is not stacked anymore. We can reuse it. */
618 same_file_p = read_file (pfile, ref_file)
619 /* Size might have changed in read_file(). */
620 && ref_file->st.st_size == file->st.st_size
621 && !memcmp (ref_file->buffer,
625 if (f->buffer && !f->buffer_valid)
628 destroy_cpp_file (ref_file);
639 /* Place the file referenced by FILE into a new buffer on the buffer
640 stack if possible. IMPORT is true if this stacking attempt is
641 because of a #import directive. Returns true if a buffer is
644 _cpp_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
649 if (!should_stack_file (pfile, file, import))
652 sysp = MAX ((pfile->map ? pfile->map->sysp : 0),
653 (file->dir ? file->dir->sysp : 0));
655 /* Add the file to the dependencies on its first inclusion. */
656 if (CPP_OPTION (pfile, deps.style) > !!sysp && !file->stack_count)
658 if (!file->main_file || !CPP_OPTION (pfile, deps.ignore_main_file))
659 deps_add_dep (pfile->deps, file->path);
662 /* Clear buffer_valid since _cpp_clean_line messes it up. */
663 file->buffer_valid = false;
666 /* Stack the buffer. */
667 buffer = cpp_push_buffer (pfile, file->buffer, file->st.st_size,
668 CPP_OPTION (pfile, preprocessed));
671 /* Initialize controlling macro state. */
672 pfile->mi_valid = true;
673 pfile->mi_cmacro = 0;
675 /* Generate the call back. */
676 _cpp_do_file_change (pfile, LC_ENTER, file->path, 1, sysp);
681 /* Mark FILE to be included once only. */
683 _cpp_mark_file_once_only (cpp_reader *pfile, _cpp_file *file)
685 pfile->seen_once_only = true;
686 file->once_only = true;
689 /* Return the directory from which searching for FNAME should start,
690 considering the directive TYPE and ANGLE_BRACKETS. If there is
691 nothing left in the path, returns NULL. */
692 static struct cpp_dir *
693 search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets,
694 enum include_type type)
699 if (IS_ABSOLUTE_PATH (fname))
700 return &pfile->no_search_path;
702 /* pfile->buffer is NULL when processing an -include command-line flag. */
703 file = pfile->buffer == NULL ? pfile->main_file : pfile->buffer->file;
705 /* For #include_next, skip in the search path past the dir in which
706 the current file was found, but if it was found via an absolute
707 path use the normal search logic. */
708 if (type == IT_INCLUDE_NEXT && file->dir)
709 dir = file->dir->next;
710 else if (angle_brackets)
711 dir = pfile->bracket_include;
712 else if (type == IT_CMDLINE)
713 /* -include and -imacros use the #include "" chain with the
714 preprocessor's cwd prepended. */
715 return make_cpp_dir (pfile, "./", false);
716 else if (pfile->quote_ignores_source_dir)
717 dir = pfile->quote_include;
719 return make_cpp_dir (pfile, dir_name_of_file (file), pfile->map->sysp);
722 cpp_error (pfile, CPP_DL_ERROR,
723 "no include path in which to search for %s", fname);
728 /* Strip the basename from the file's path. It ends with a slash if
729 of nonzero length. Note that this procedure also works for
730 <stdin>, which is represented by the empty string. */
732 dir_name_of_file (_cpp_file *file)
736 size_t len = lbasename (file->path) - file->path;
737 char *dir_name = xmalloc (len + 1);
739 memcpy (dir_name, file->path, len);
740 dir_name[len] = '\0';
741 file->dir_name = dir_name;
744 return file->dir_name;
747 /* Handles #include-family directives (distinguished by TYPE),
748 including HEADER, and the command line -imacros and -include.
749 Returns true if a buffer was stacked. */
751 _cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets,
752 enum include_type type)
756 dir = search_path_head (pfile, fname, angle_brackets, type);
760 return _cpp_stack_file (pfile, _cpp_find_file (pfile, fname, dir, false),
764 /* Could not open FILE. The complication is dependency output. */
766 open_file_failed (cpp_reader *pfile, _cpp_file *file)
768 int sysp = pfile->map ? pfile->map->sysp: 0;
769 bool print_dep = CPP_OPTION (pfile, deps.style) > !!sysp;
771 errno = file->err_no;
772 if (print_dep && CPP_OPTION (pfile, deps.missing_files) && errno == ENOENT)
773 deps_add_dep (pfile->deps, file->name);
776 /* If we are outputting dependencies but not for this file then
777 don't error because we can still produce correct output. */
778 if (CPP_OPTION (pfile, deps.style) && ! print_dep)
779 cpp_errno (pfile, CPP_DL_WARNING, file->path);
781 cpp_errno (pfile, CPP_DL_ERROR, file->path);
785 /* Search in the chain beginning at HEAD for a file whose search path
786 started at START_DIR != NULL. */
787 static struct file_hash_entry *
788 search_cache (struct file_hash_entry *head, const cpp_dir *start_dir)
790 while (head && head->start_dir != start_dir)
796 /* Allocate a new _cpp_file structure. */
798 make_cpp_file (cpp_reader *pfile, cpp_dir *dir, const char *fname)
802 file = xcalloc (1, sizeof (_cpp_file));
803 file->main_file = !pfile->buffer;
806 file->name = xstrdup (fname);
811 /* Release a _cpp_file structure. */
813 destroy_cpp_file (_cpp_file *file)
816 free ((void *) file->buffer);
817 free ((void *) file->name);
821 /* A hash of directory names. The directory names are the path names
822 of files which contain a #include "", the included file name is
823 appended to this directories.
825 To avoid duplicate entries we follow the convention that all
826 non-empty directory names should end in a '/'. DIR_NAME must be
827 stored in permanently allocated memory. */
829 make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
831 struct file_hash_entry *entry, **hash_slot;
834 hash_slot = (struct file_hash_entry **)
835 htab_find_slot_with_hash (pfile->dir_hash, dir_name,
836 htab_hash_string (dir_name),
839 /* Have we already hashed this directory? */
840 for (entry = *hash_slot; entry; entry = entry->next)
841 if (entry->start_dir == NULL)
844 dir = xcalloc (1, sizeof (cpp_dir));
845 dir->next = pfile->quote_include;
846 dir->name = (char *) dir_name;
847 dir->len = strlen (dir_name);
850 /* Store this new result in the hash table. */
851 entry = new_file_hash_entry (pfile);
852 entry->next = *hash_slot;
853 entry->start_dir = NULL;
860 /* Create a new block of memory for file hash entries. */
862 allocate_file_hash_entries (cpp_reader *pfile)
864 pfile->file_hash_entries_used = 0;
865 pfile->file_hash_entries_allocated = 127;
866 pfile->file_hash_entries = xmalloc
867 (pfile->file_hash_entries_allocated * sizeof (struct file_hash_entry));
870 /* Return a new file hash entry. */
871 static struct file_hash_entry *
872 new_file_hash_entry (cpp_reader *pfile)
874 if (pfile->file_hash_entries_used == pfile->file_hash_entries_allocated)
875 allocate_file_hash_entries (pfile);
877 return &pfile->file_hash_entries[pfile->file_hash_entries_used++];
880 /* Returns TRUE if a file FNAME has ever been successfully opened.
881 This routine is not intended to correctly handle filenames aliased
882 by links or redundant . or .. traversals etc. */
884 cpp_included (cpp_reader *pfile, const char *fname)
886 struct file_hash_entry *entry;
888 entry = htab_find_with_hash (pfile->file_hash, fname,
889 htab_hash_string (fname));
891 while (entry && (entry->start_dir == NULL || entry->u.file->err_no))
894 return entry != NULL;
897 /* Calculate the hash value of a file hash entry P. */
900 file_hash_hash (const void *p)
902 struct file_hash_entry *entry = (struct file_hash_entry *) p;
904 if (entry->start_dir)
905 hname = entry->u.file->name;
907 hname = entry->u.dir->name;
909 return htab_hash_string (hname);
912 /* Compare a string Q against a file hash entry P. */
914 file_hash_eq (const void *p, const void *q)
916 struct file_hash_entry *entry = (struct file_hash_entry *) p;
917 const char *fname = (const char *) q;
920 if (entry->start_dir)
921 hname = entry->u.file->name;
923 hname = entry->u.dir->name;
925 return strcmp (hname, fname) == 0;
928 /* Initialize everything in this source file. */
930 _cpp_init_files (cpp_reader *pfile)
932 pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
933 NULL, xcalloc, free);
934 pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
935 NULL, xcalloc, free);
936 allocate_file_hash_entries (pfile);
939 /* Finalize everything in this source file. */
941 _cpp_cleanup_files (cpp_reader *pfile)
943 htab_delete (pfile->file_hash);
944 htab_delete (pfile->dir_hash);
947 /* Enter a file name in the hash for the sake of cpp_included. */
949 _cpp_fake_include (cpp_reader *pfile, const char *fname)
951 _cpp_find_file (pfile, fname, pfile->buffer->file->dir, true);
954 /* Not everyone who wants to set system-header-ness on a buffer can
955 see the details of a buffer. This is an exported interface because
956 fix-header needs it. */
958 cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
962 /* 1 = system header, 2 = system header to be treated as C. */
964 flags = 1 + (externc != 0);
965 _cpp_do_file_change (pfile, LC_RENAME, pfile->map->to_file,
966 SOURCE_LINE (pfile->map, pfile->line), flags);
969 /* Allow the client to change the current file. Used by the front end
970 to achieve pseudo-file names like <built-in>.
971 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
973 cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
974 const char *new_name)
976 _cpp_do_file_change (pfile, reason, new_name, 1, 0);
979 /* Callback function for htab_traverse. */
981 report_missing_guard (void **slot, void *b)
983 struct file_hash_entry *entry = (struct file_hash_entry *) *slot;
984 int *bannerp = (int *) b;
986 /* Skip directories. */
987 if (entry->start_dir != NULL)
989 _cpp_file *file = entry->u.file;
991 /* We don't want MI guard advice for the main file. */
992 if (file->cmacro == NULL && file->stack_count == 1 && !file->main_file)
996 fputs (_("Multiple include guards may be useful for:\n"),
1001 fputs (entry->u.file->path, stderr);
1002 putc ('\n', stderr);
1009 /* Report on all files that might benefit from a multiple include guard.
1012 _cpp_report_missing_guards (cpp_reader *pfile)
1016 htab_traverse (pfile->file_hash, report_missing_guard, &banner);
1019 /* Locate HEADER, and determine whether it is newer than the current
1020 file. If it cannot be located or dated, return -1, if it is
1021 newer, return 1, otherwise 0. */
1023 _cpp_compare_file_date (cpp_reader *pfile, const char *fname,
1027 struct cpp_dir *dir;
1029 dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
1033 file = _cpp_find_file (pfile, fname, dir, false);
1043 return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
1046 /* Pushes the given file onto the buffer stack. Returns nonzero if
1049 cpp_push_include (cpp_reader *pfile, const char *fname)
1051 /* Make the command line directive take up a line. */
1053 return _cpp_stack_include (pfile, fname, false, IT_CMDLINE);
1056 /* Do appropriate cleanup when a file INC's buffer is popped off the
1059 _cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file)
1061 /* Record the inclusion-preventing macro, which could be NULL
1062 meaning no controlling macro. */
1063 if (pfile->mi_valid && file->cmacro == NULL)
1064 file->cmacro = pfile->mi_cmacro;
1066 /* Invalidate control macros in the #including file. */
1067 pfile->mi_valid = false;
1071 free ((void *) file->buffer);
1072 file->buffer = NULL;
1076 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1077 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1078 directory of the including file.
1080 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1082 cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
1083 int quote_ignores_source_dir)
1085 pfile->quote_include = quote;
1086 pfile->bracket_include = quote;
1087 pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1089 for (; quote; quote = quote->next)
1091 quote->name_map = NULL;
1092 quote->len = strlen (quote->name);
1093 if (quote == bracket)
1094 pfile->bracket_include = bracket;
1098 /* Append the file name to the directory to create the path, but don't
1099 turn / into // or // into ///; // may be a namespace escape. */
1101 append_file_to_dir (const char *fname, cpp_dir *dir)
1107 flen = strlen (fname);
1108 path = xmalloc (dlen + 1 + flen + 1);
1109 memcpy (path, dir->name, dlen);
1110 if (dlen && path[dlen - 1] != '/')
1112 memcpy (&path[dlen], fname, flen + 1);
1117 /* Read a space delimited string of unlimited length from a stdio
1120 read_filename_string (int ch, FILE *f)
1126 set = alloc = xmalloc (len + 1);
1127 if (! is_space (ch))
1130 while ((ch = getc (f)) != EOF && ! is_space (ch))
1132 if (set - alloc == len)
1135 alloc = xrealloc (alloc, len + 1);
1136 set = alloc + len / 2;
1146 /* Read the file name map file for DIR. */
1148 read_name_map (cpp_dir *dir)
1150 static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1153 size_t len, count = 0, room = 9;
1156 name = alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
1157 memcpy (name, dir->name, len);
1158 if (len && name[len - 1] != '/')
1160 strcpy (name + len, FILE_NAME_MAP_FILE);
1161 f = fopen (name, "r");
1163 dir->name_map = xmalloc (room * sizeof (char *));
1165 /* Silently return NULL if we cannot open. */
1170 while ((ch = getc (f)) != EOF)
1177 if (count + 2 > room)
1180 dir->name_map = xrealloc (dir->name_map, room * sizeof (char *));
1183 dir->name_map[count] = read_filename_string (ch, f);
1184 while ((ch = getc (f)) != EOF && is_hspace (ch))
1187 to = read_filename_string (ch, f);
1188 if (IS_ABSOLUTE_PATH (to))
1189 dir->name_map[count + 1] = to;
1192 dir->name_map[count + 1] = append_file_to_dir (to, dir);
1197 while ((ch = getc (f)) != '\n')
1205 /* Terminate the list of maps. */
1206 dir->name_map[count] = NULL;
1209 /* Remap a FILE's name based on the file_name_map, if any, for
1210 FILE->dir. If the file name has any directory separators,
1211 recursively check those directories too. */
1213 remap_filename (cpp_reader *pfile, _cpp_file *file)
1215 const char *fname, *p;
1226 read_name_map (dir);
1228 for (index = 0; dir->name_map[index]; index += 2)
1229 if (!strcmp (dir->name_map[index], fname))
1230 return xstrdup (dir->name_map[index + 1]);
1232 p = strchr (fname, '/');
1233 if (!p || p == fname)
1236 len = dir->len + (p - fname + 1);
1237 new_dir = xmalloc (len + 1);
1238 memcpy (new_dir, dir->name, dir->len);
1239 memcpy (new_dir + dir->len, fname, p - fname + 1);
1240 new_dir[len] = '\0';
1242 dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1247 /* Return true if FILE is usable by PCH. */
1249 include_pch_p (_cpp_file *file)
1251 return file->pch & 1;
1254 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1256 validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1258 const char *saved_path = file->path;
1261 file->path = pchname;
1262 if (open_file (file))
1264 valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1272 if (CPP_OPTION (pfile, print_include_names))
1275 for (i = 1; i < pfile->line_maps.depth; i++)
1277 fprintf (stderr, "%c %s\n",
1278 valid ? '!' : 'x', pchname);
1282 file->path = saved_path;