1 /* Part of CPP library. File handling.
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
4 Free Software Foundation, Inc.
5 Written by Per Bothner, 1994.
6 Based on CCCP program by Paul Rubin, June 1986
7 Adapted to ANSI C, Richard Stallman, Jan 1987
8 Split out of cpplib.c, Zack Weinberg, Oct 1998
9 Reimplemented, Neil Booth, Jul 2003
11 This program is free software; you can redistribute it and/or modify it
12 under the terms of the GNU General Public License as published by the
13 Free Software Foundation; either version 2, or (at your option) any
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
35 /* Variable length record files on VMS will have a stat size that includes
36 record control characters that won't be included in the read size. */
38 # define FAB_C_VAR 2 /* variable length records (see Starlet fabdef.h) */
39 # define STAT_SIZE_RELIABLE(ST) ((ST).st_fab_rfm != FAB_C_VAR)
41 # define STAT_SIZE_RELIABLE(ST) true
46 /* For DJGPP redirected input is opened in text mode. */
47 # define set_stdin_to_binary_mode() \
48 if (! isatty (0)) setmode (0, O_BINARY)
50 # define set_stdin_to_binary_mode() /* Nothing */
53 /* This structure represents a file searched for by CPP, whether it
54 exists or not. An instance may be pointed to by more than one
55 file_hash_entry; at present no reference count is kept. */
58 /* Filename as given to #include or command line switch. */
61 /* The full path used to find the file. */
64 /* The full path of the pch file. */
67 /* The file's path with the basename stripped. NULL if it hasn't
68 been calculated yet. */
71 /* Chain through all files. */
72 struct _cpp_file *next_file;
74 /* The contents of NAME after calling read_file(). */
77 /* The macro, if any, preventing re-inclusion. */
78 const cpp_hashnode *cmacro;
80 /* The directory in the search path where FILE was found. Used for
81 #include_next and determining whether a header is a system
85 /* As filled in by stat(2) for the file. */
88 /* File descriptor. Invalid if -1, otherwise open. */
91 /* Zero if this file was successfully opened and stat()-ed,
92 otherwise errno obtained from failure. */
95 /* Number of times the file has been stacked for preprocessing. */
96 unsigned short stack_count;
98 /* If opened with #import or contains #pragma once. */
101 /* If read() failed before. */
104 /* If this file is the main file. */
107 /* If BUFFER above contains the true contents of the file. */
110 /* File is a PCH (on return from find_include_file). */
114 /* A singly-linked list for all searches for a given file name, with
115 its head pointed to by a slot in FILE_HASH. The file name is what
116 appeared between the quotes in a #include directive; it can be
117 determined implicitly from the hash table location or explicitly
120 FILE is a structure containing details about the file that was
121 found with that search, or details of how the search failed.
123 START_DIR is the starting location of the search in the include
124 chain. The current directories for "" includes are also hashed in
125 the hash table and therefore unique. Files that are looked up
126 without using a search path, such as absolute filenames and file
127 names from the command line share a special starting directory so
128 they don't cause cache hits with normal include-chain lookups.
130 If START_DIR is NULL then the entry is for a directory, not a file,
131 and the directory is in DIR. Since the starting point in a file
132 lookup chain is never NULL, this means that simple pointer
133 comparisons against START_DIR can be made to determine cache hits
136 If a cache lookup fails because of e.g. an extra "./" in the path,
137 then nothing will break. It is just less efficient as CPP will
138 have to do more work re-preprocessing the file, and/or comparing
139 its contents against earlier once-only files.
141 struct file_hash_entry
143 struct file_hash_entry *next;
152 static bool open_file (_cpp_file *file);
153 static bool pch_open_file (cpp_reader *pfile, _cpp_file *file,
155 static bool find_file_in_dir (cpp_reader *pfile, _cpp_file *file,
157 static bool read_file_guts (cpp_reader *pfile, _cpp_file *file);
158 static bool read_file (cpp_reader *pfile, _cpp_file *file);
159 static bool should_stack_file (cpp_reader *, _cpp_file *file, bool import);
160 static struct cpp_dir *search_path_head (cpp_reader *, const char *fname,
161 int angle_brackets, enum include_type);
162 static const char *dir_name_of_file (_cpp_file *file);
163 static void open_file_failed (cpp_reader *pfile, _cpp_file *file, int);
164 static struct file_hash_entry *search_cache (struct file_hash_entry *head,
165 const cpp_dir *start_dir);
166 static _cpp_file *make_cpp_file (cpp_reader *, cpp_dir *, const char *fname);
167 static void destroy_cpp_file (_cpp_file *);
168 static cpp_dir *make_cpp_dir (cpp_reader *, const char *dir_name, int sysp);
169 static void allocate_file_hash_entries (cpp_reader *pfile);
170 static struct file_hash_entry *new_file_hash_entry (cpp_reader *pfile);
171 static int report_missing_guard (void **slot, void *b);
172 static hashval_t file_hash_hash (const void *p);
173 static int file_hash_eq (const void *p, const void *q);
174 static char *read_filename_string (int ch, FILE *f);
175 static void read_name_map (cpp_dir *dir);
176 static char *remap_filename (cpp_reader *pfile, _cpp_file *file);
177 static char *append_file_to_dir (const char *fname, cpp_dir *dir);
178 static bool validate_pch (cpp_reader *, _cpp_file *file, const char *pchname);
179 static int pchf_save_compare (const void *e1, const void *e2);
180 static int pchf_compare (const void *d_p, const void *e_p);
181 static bool check_file_against_entries (cpp_reader *, _cpp_file *, bool);
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 = XNEWVEC (char, 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 = XRESIZEVEC (char, pchname, len);
286 memcpy (pchname + plen, d->d_name, dlen);
287 valid = validate_pch (pfile, file, pchname);
300 file->pchname = pchname;
307 /* Try to open the path FILE->name appended to FILE->dir. This is
308 where remap and PCH intercept the file lookup process. Return true
309 if the file was found, whether or not the open was successful.
310 Set *INVALID_PCH to true if a PCH file is found but wasn't valid. */
313 find_file_in_dir (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
317 if (CPP_OPTION (pfile, remap) && (path = remap_filename (pfile, file)))
320 if (file->dir->construct)
321 path = file->dir->construct (file->name, file->dir);
323 path = append_file_to_dir (file->name, file->dir);
327 hashval_t hv = htab_hash_string (path);
331 if (htab_find_with_hash (pfile->nonexistent_file_hash, path, hv) != NULL)
333 file->err_no = ENOENT;
338 if (pch_open_file (pfile, file, invalid_pch))
341 if (open_file (file))
344 if (file->err_no != ENOENT)
346 open_file_failed (pfile, file, 0);
350 /* We copy the path name onto an obstack partly so that we don't
351 leak the memory, but mostly so that we don't fragment the
353 copy = obstack_copy0 (&pfile->nonexistent_file_ob, path,
356 pp = htab_find_slot_with_hash (pfile->nonexistent_file_hash,
360 file->path = file->name;
364 file->err_no = ENOENT;
371 /* Return tue iff the missing_header callback found the given HEADER. */
373 search_path_exhausted (cpp_reader *pfile, const char *header, _cpp_file *file)
375 missing_header_cb func = pfile->cb.missing_header;
377 /* When the regular search path doesn't work, try context dependent
378 headers search paths. */
380 && file->dir == NULL)
382 if ((file->path = func (pfile, header, &file->dir)) != NULL)
384 if (open_file (file))
386 free ((void *)file->path);
388 file->path = file->name;
395 _cpp_find_failed (_cpp_file *file)
397 return file->err_no != 0;
400 /* Given a filename FNAME search for such a file in the include path
401 starting from START_DIR. If FNAME is the empty string it is
402 interpreted as STDIN if START_DIR is PFILE->no_search_path.
404 If the file is not found in the file cache fall back to the O/S and
405 add the result to our cache.
407 If the file was not found in the filesystem, or there was an error
408 opening it, then ERR_NO is nonzero and FD is -1. If the file was
409 found, then ERR_NO is zero and FD could be -1 or an open file
410 descriptor. FD can be -1 if the file was found in the cache and
411 had previously been closed. To open it again pass the return value
415 _cpp_find_file (cpp_reader *pfile, const char *fname, cpp_dir *start_dir, bool fake, int angle_brackets)
417 struct file_hash_entry *entry, **hash_slot;
419 bool invalid_pch = false;
420 bool saw_bracket_include = false;
421 bool saw_quote_include = false;
422 struct cpp_dir *found_in_cache = NULL;
424 /* Ensure we get no confusion between cached files and directories. */
425 if (start_dir == NULL)
426 cpp_error (pfile, CPP_DL_ICE, "NULL directory in find_file");
428 hash_slot = (struct file_hash_entry **)
429 htab_find_slot_with_hash (pfile->file_hash, fname,
430 htab_hash_string (fname),
433 /* First check the cache before we resort to memory allocation. */
434 entry = search_cache (*hash_slot, start_dir);
436 return entry->u.file;
438 file = make_cpp_file (pfile, start_dir, fname);
440 /* Try each path in the include chain. */
443 if (find_file_in_dir (pfile, file, &invalid_pch))
446 file->dir = file->dir->next;
447 if (file->dir == NULL)
449 if (search_path_exhausted (pfile, fname, file))
451 /* Although this file must not go in the cache, because
452 the file found might depend on things (like the current file)
453 that aren't represented in the cache, it still has to go in
454 the list of all files so that #import works. */
455 file->next_file = pfile->all_files;
456 pfile->all_files = file;
460 open_file_failed (pfile, file, angle_brackets);
463 cpp_error (pfile, CPP_DL_ERROR,
464 "one or more PCH files were found, but they were invalid");
465 if (!cpp_get_options (pfile)->warn_invalid_pch)
466 cpp_error (pfile, CPP_DL_ERROR,
467 "use -Winvalid-pch for more information");
472 /* Only check the cache for the starting location (done above)
473 and the quote and bracket chain heads because there are no
474 other possible starting points for searches. */
475 if (file->dir == pfile->bracket_include)
476 saw_bracket_include = true;
477 else if (file->dir == pfile->quote_include)
478 saw_quote_include = true;
482 entry = search_cache (*hash_slot, file->dir);
485 found_in_cache = file->dir;
492 /* Cache for START_DIR too, sharing the _cpp_file structure. */
493 free ((char *) file->name);
495 file = entry->u.file;
499 /* This is a new file; put it in the list. */
500 file->next_file = pfile->all_files;
501 pfile->all_files = file;
504 /* Store this new result in the hash table. */
505 entry = new_file_hash_entry (pfile);
506 entry->next = *hash_slot;
507 entry->start_dir = start_dir;
508 entry->u.file = file;
511 /* If we passed the quote or bracket chain heads, cache them also.
512 This speeds up processing if there are lots of -I options. */
513 if (saw_bracket_include
514 && pfile->bracket_include != start_dir
515 && found_in_cache != pfile->bracket_include)
517 entry = new_file_hash_entry (pfile);
518 entry->next = *hash_slot;
519 entry->start_dir = pfile->bracket_include;
520 entry->u.file = file;
523 if (saw_quote_include
524 && pfile->quote_include != start_dir
525 && found_in_cache != pfile->quote_include)
527 entry = new_file_hash_entry (pfile);
528 entry->next = *hash_slot;
529 entry->start_dir = pfile->quote_include;
530 entry->u.file = file;
537 /* Read a file into FILE->buffer, returning true on success.
539 If FILE->fd is something weird, like a block device, we don't want
540 to read it at all. Don't even try to figure out what something is,
541 except for plain files and block devices, since there is no
542 reliable portable way of doing this.
544 FIXME: Flush file cache and try again if we run out of memory. */
546 read_file_guts (cpp_reader *pfile, _cpp_file *file)
548 ssize_t size, total, count;
552 if (S_ISBLK (file->st.st_mode))
554 cpp_error (pfile, CPP_DL_ERROR, "%s is a block device", file->path);
558 regular = S_ISREG (file->st.st_mode);
561 /* off_t might have a wider range than ssize_t - in other words,
562 the max size of a file might be bigger than the address
563 space. We can't handle a file that large. (Anyone with
564 a single source file bigger than 2GB needs to rethink
565 their coding style.) Some systems (e.g. AIX 4.1) define
566 SSIZE_MAX to be much smaller than the actual range of the
567 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
569 if (file->st.st_size > INTTYPE_MAXIMUM (ssize_t))
571 cpp_error (pfile, CPP_DL_ERROR, "%s is too large", file->path);
575 size = file->st.st_size;
578 /* 8 kilobytes is a sensible starting size. It ought to be bigger
579 than the kernel pipe buffer, and it's definitely bigger than
580 the majority of C source files. */
583 buf = XNEWVEC (uchar, size + 1);
585 while ((count = read (file->fd, buf + total, size - total)) > 0)
594 buf = XRESIZEVEC (uchar, buf, size + 1);
600 cpp_errno (pfile, CPP_DL_ERROR, file->path);
604 if (regular && total != size && STAT_SIZE_RELIABLE (file->st))
605 cpp_error (pfile, CPP_DL_WARNING,
606 "%s is shorter than expected", file->path);
608 file->buffer = _cpp_convert_input (pfile, CPP_OPTION (pfile, input_charset),
609 buf, size, total, &file->st.st_size);
610 file->buffer_valid = true;
615 /* Convenience wrapper around read_file_guts that opens the file if
616 necessary and closes the file descriptor after reading. FILE must
617 have been passed through find_file() at some stage. */
619 read_file (cpp_reader *pfile, _cpp_file *file)
621 /* If we already have its contents in memory, succeed immediately. */
622 if (file->buffer_valid)
625 /* If an earlier read failed for some reason don't try again. */
626 if (file->dont_read || file->err_no)
629 if (file->fd == -1 && !open_file (file))
631 open_file_failed (pfile, file, 0);
635 file->dont_read = !read_file_guts (pfile, file);
639 return !file->dont_read;
642 /* Returns TRUE if FILE's contents have been successfully placed in
643 FILE->buffer and the file should be stacked, otherwise false. */
645 should_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
649 /* Skip once-only files. */
653 /* We must mark the file once-only if #import now, before header
654 guard checks. Otherwise, undefining the header guard might
655 cause the file to be re-stacked. */
658 _cpp_mark_file_once_only (pfile, file);
660 /* Don't stack files that have been stacked before. */
661 if (file->stack_count)
665 /* Skip if the file had a header guard and the macro is defined.
666 PCH relies on this appearing before the PCH handler below. */
667 if (file->cmacro && file->cmacro->type == NT_MACRO)
670 /* Handle PCH files immediately; don't stack them. */
673 pfile->cb.read_pch (pfile, file->pchname, file->fd, file->path);
679 if (!read_file (pfile, file))
682 /* Check the file against the PCH file. This is done before
683 checking against files we've already seen, since it may save on
685 if (check_file_against_entries (pfile, file, import))
687 /* If this isn't a #import, but yet we can't include the file,
688 that means that it was #import-ed in the PCH file,
689 so we can never include it again. */
691 _cpp_mark_file_once_only (pfile, file);
695 /* Now we've read the file's contents, we can stack it if there
696 are no once-only files. */
697 if (!pfile->seen_once_only)
700 /* We may have read the file under a different name. Look
701 for likely candidates and compare file contents to be sure. */
702 for (f = pfile->all_files; f; f = f->next_file)
707 if ((import || f->once_only)
709 && f->st.st_mtime == file->st.st_mtime
710 && f->st.st_size == file->st.st_size)
713 bool same_file_p = false;
715 if (f->buffer && !f->buffer_valid)
717 /* We already have a buffer but it is not valid, because
718 the file is still stacked. Make a new one. */
719 ref_file = make_cpp_file (pfile, f->dir, f->name);
720 ref_file->path = f->path;
723 /* The file is not stacked anymore. We can reuse it. */
726 same_file_p = read_file (pfile, ref_file)
727 /* Size might have changed in read_file(). */
728 && ref_file->st.st_size == file->st.st_size
729 && !memcmp (ref_file->buffer,
733 if (f->buffer && !f->buffer_valid)
736 destroy_cpp_file (ref_file);
747 /* Place the file referenced by FILE into a new buffer on the buffer
748 stack if possible. IMPORT is true if this stacking attempt is
749 because of a #import directive. Returns true if a buffer is
752 _cpp_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
757 if (!should_stack_file (pfile, file, import))
760 if (pfile->buffer == NULL || file->dir == NULL)
763 sysp = MAX (pfile->buffer->sysp, file->dir->sysp);
765 /* Add the file to the dependencies on its first inclusion. */
766 if (CPP_OPTION (pfile, deps.style) > !!sysp && !file->stack_count)
768 if (!file->main_file || !CPP_OPTION (pfile, deps.ignore_main_file))
769 deps_add_dep (pfile->deps, file->path);
772 /* Clear buffer_valid since _cpp_clean_line messes it up. */
773 file->buffer_valid = false;
776 /* Stack the buffer. */
777 buffer = cpp_push_buffer (pfile, file->buffer, file->st.st_size,
778 CPP_OPTION (pfile, preprocessed)
779 && !CPP_OPTION (pfile, directives_only));
783 /* Initialize controlling macro state. */
784 pfile->mi_valid = true;
785 pfile->mi_cmacro = 0;
787 /* Generate the call back. */
788 _cpp_do_file_change (pfile, LC_ENTER, file->path, 1, sysp);
793 /* Mark FILE to be included once only. */
795 _cpp_mark_file_once_only (cpp_reader *pfile, _cpp_file *file)
797 pfile->seen_once_only = true;
798 file->once_only = true;
801 /* Return the directory from which searching for FNAME should start,
802 considering the directive TYPE and ANGLE_BRACKETS. If there is
803 nothing left in the path, returns NULL. */
804 static struct cpp_dir *
805 search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets,
806 enum include_type type)
811 if (IS_ABSOLUTE_PATH (fname))
812 return &pfile->no_search_path;
814 /* pfile->buffer is NULL when processing an -include command-line flag. */
815 file = pfile->buffer == NULL ? pfile->main_file : pfile->buffer->file;
817 /* For #include_next, skip in the search path past the dir in which
818 the current file was found, but if it was found via an absolute
819 path use the normal search logic. */
820 if (type == IT_INCLUDE_NEXT && file->dir)
821 dir = file->dir->next;
822 else if (angle_brackets)
823 dir = pfile->bracket_include;
824 else if (type == IT_CMDLINE)
825 /* -include and -imacros use the #include "" chain with the
826 preprocessor's cwd prepended. */
827 return make_cpp_dir (pfile, "./", false);
828 else if (pfile->quote_ignores_source_dir)
829 dir = pfile->quote_include;
831 return make_cpp_dir (pfile, dir_name_of_file (file),
832 pfile->buffer ? pfile->buffer->sysp : 0);
835 cpp_error (pfile, CPP_DL_ERROR,
836 "no include path in which to search for %s", fname);
841 /* Strip the basename from the file's path. It ends with a slash if
842 of nonzero length. Note that this procedure also works for
843 <stdin>, which is represented by the empty string. */
845 dir_name_of_file (_cpp_file *file)
849 size_t len = lbasename (file->path) - file->path;
850 char *dir_name = XNEWVEC (char, len + 1);
852 memcpy (dir_name, file->path, len);
853 dir_name[len] = '\0';
854 file->dir_name = dir_name;
857 return file->dir_name;
860 /* Handles #include-family directives (distinguished by TYPE),
861 including HEADER, and the command line -imacros and -include.
862 Returns true if a buffer was stacked. */
864 _cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets,
865 enum include_type type)
870 dir = search_path_head (pfile, fname, angle_brackets, type);
874 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets);
876 /* Compensate for the increment in linemap_add. In the case of a
877 normal #include, we're currently at the start of the line
878 *following* the #include. A separate source_location for this
879 location makes no sense (until we do the LC_LEAVE), and
880 complicates LAST_SOURCE_LINE_LOCATION. This does not apply if we
881 found a PCH file (in which case linemap_add is not called) or we
882 were included from the command-line. */
883 if (! file->pch && file->err_no == 0 && type != IT_CMDLINE)
884 pfile->line_table->highest_location--;
886 return _cpp_stack_file (pfile, file, type == IT_IMPORT);
889 /* Could not open FILE. The complication is dependency output. */
891 open_file_failed (cpp_reader *pfile, _cpp_file *file, int angle_brackets)
893 int sysp = pfile->line_table->highest_line > 1 && pfile->buffer ? pfile->buffer->sysp : 0;
894 bool print_dep = CPP_OPTION (pfile, deps.style) > (angle_brackets || !!sysp);
896 errno = file->err_no;
897 if (print_dep && CPP_OPTION (pfile, deps.missing_files) && errno == ENOENT)
898 deps_add_dep (pfile->deps, file->name);
901 /* If we are outputting dependencies but not for this file then
902 don't error because we can still produce correct output. */
903 if (CPP_OPTION (pfile, deps.style) && ! print_dep)
904 cpp_errno (pfile, CPP_DL_WARNING, file->path);
906 cpp_errno (pfile, CPP_DL_ERROR, file->path);
910 /* Search in the chain beginning at HEAD for a file whose search path
911 started at START_DIR != NULL. */
912 static struct file_hash_entry *
913 search_cache (struct file_hash_entry *head, const cpp_dir *start_dir)
915 while (head && head->start_dir != start_dir)
921 /* Allocate a new _cpp_file structure. */
923 make_cpp_file (cpp_reader *pfile, cpp_dir *dir, const char *fname)
927 file = XCNEW (_cpp_file);
928 file->main_file = !pfile->buffer;
931 file->name = xstrdup (fname);
936 /* Release a _cpp_file structure. */
938 destroy_cpp_file (_cpp_file *file)
941 free ((void *) file->buffer);
942 free ((void *) file->name);
946 /* A hash of directory names. The directory names are the path names
947 of files which contain a #include "", the included file name is
948 appended to this directories.
950 To avoid duplicate entries we follow the convention that all
951 non-empty directory names should end in a '/'. DIR_NAME must be
952 stored in permanently allocated memory. */
954 make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
956 struct file_hash_entry *entry, **hash_slot;
959 hash_slot = (struct file_hash_entry **)
960 htab_find_slot_with_hash (pfile->dir_hash, dir_name,
961 htab_hash_string (dir_name),
964 /* Have we already hashed this directory? */
965 for (entry = *hash_slot; entry; entry = entry->next)
966 if (entry->start_dir == NULL)
969 dir = XCNEW (cpp_dir);
970 dir->next = pfile->quote_include;
971 dir->name = (char *) dir_name;
972 dir->len = strlen (dir_name);
976 /* Store this new result in the hash table. */
977 entry = new_file_hash_entry (pfile);
978 entry->next = *hash_slot;
979 entry->start_dir = NULL;
986 /* Create a new block of memory for file hash entries. */
988 allocate_file_hash_entries (cpp_reader *pfile)
990 pfile->file_hash_entries_used = 0;
991 pfile->file_hash_entries_allocated = 127;
992 pfile->file_hash_entries = XNEWVEC (struct file_hash_entry,
993 pfile->file_hash_entries_allocated);
996 /* Return a new file hash entry. */
997 static struct file_hash_entry *
998 new_file_hash_entry (cpp_reader *pfile)
1000 if (pfile->file_hash_entries_used == pfile->file_hash_entries_allocated)
1001 allocate_file_hash_entries (pfile);
1003 return &pfile->file_hash_entries[pfile->file_hash_entries_used++];
1006 /* Returns TRUE if a file FNAME has ever been successfully opened.
1007 This routine is not intended to correctly handle filenames aliased
1008 by links or redundant . or .. traversals etc. */
1010 cpp_included (cpp_reader *pfile, const char *fname)
1012 struct file_hash_entry *entry;
1014 entry = (struct file_hash_entry *)
1015 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1017 while (entry && (entry->start_dir == NULL || entry->u.file->err_no))
1018 entry = entry->next;
1020 return entry != NULL;
1023 /* Calculate the hash value of a file hash entry P. */
1026 file_hash_hash (const void *p)
1028 struct file_hash_entry *entry = (struct file_hash_entry *) p;
1030 if (entry->start_dir)
1031 hname = entry->u.file->name;
1033 hname = entry->u.dir->name;
1035 return htab_hash_string (hname);
1038 /* Compare a string Q against a file hash entry P. */
1040 file_hash_eq (const void *p, const void *q)
1042 struct file_hash_entry *entry = (struct file_hash_entry *) p;
1043 const char *fname = (const char *) q;
1046 if (entry->start_dir)
1047 hname = entry->u.file->name;
1049 hname = entry->u.dir->name;
1051 return strcmp (hname, fname) == 0;
1054 /* Compare entries in the nonexistent file hash table. These are just
1057 nonexistent_file_hash_eq (const void *p, const void *q)
1059 return strcmp (p, q) == 0;
1062 /* Initialize everything in this source file. */
1064 _cpp_init_files (cpp_reader *pfile)
1066 pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1067 NULL, xcalloc, free);
1068 pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1069 NULL, xcalloc, free);
1070 allocate_file_hash_entries (pfile);
1071 pfile->nonexistent_file_hash = htab_create_alloc (127, htab_hash_string,
1072 nonexistent_file_hash_eq,
1073 NULL, xcalloc, free);
1074 _obstack_begin (&pfile->nonexistent_file_ob, 0, 0,
1075 (void *(*) (long)) xmalloc,
1076 (void (*) (void *)) free);
1079 /* Finalize everything in this source file. */
1081 _cpp_cleanup_files (cpp_reader *pfile)
1083 htab_delete (pfile->file_hash);
1084 htab_delete (pfile->dir_hash);
1085 htab_delete (pfile->nonexistent_file_hash);
1086 obstack_free (&pfile->nonexistent_file_ob, 0);
1089 /* Enter a file name in the hash for the sake of cpp_included. */
1091 _cpp_fake_include (cpp_reader *pfile, const char *fname)
1093 _cpp_find_file (pfile, fname, pfile->buffer->file->dir, true, 0);
1096 /* Not everyone who wants to set system-header-ness on a buffer can
1097 see the details of a buffer. This is an exported interface because
1098 fix-header needs it. */
1100 cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
1103 const struct line_maps *line_table = pfile->line_table;
1104 const struct line_map *map = &line_table->maps[line_table->used-1];
1106 /* 1 = system header, 2 = system header to be treated as C. */
1108 flags = 1 + (externc != 0);
1109 pfile->buffer->sysp = flags;
1110 _cpp_do_file_change (pfile, LC_RENAME, map->to_file,
1111 SOURCE_LINE (map, pfile->line_table->highest_line), flags);
1114 /* Allow the client to change the current file. Used by the front end
1115 to achieve pseudo-file names like <built-in>.
1116 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
1118 cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
1119 const char *new_name)
1121 _cpp_do_file_change (pfile, reason, new_name, 1, 0);
1124 /* Callback function for htab_traverse. */
1126 report_missing_guard (void **slot, void *b)
1128 struct file_hash_entry *entry = (struct file_hash_entry *) *slot;
1129 int *bannerp = (int *) b;
1131 /* Skip directories. */
1132 if (entry->start_dir != NULL)
1134 _cpp_file *file = entry->u.file;
1136 /* We don't want MI guard advice for the main file. */
1137 if (file->cmacro == NULL && file->stack_count == 1 && !file->main_file)
1141 fputs (_("Multiple include guards may be useful for:\n"),
1146 fputs (entry->u.file->path, stderr);
1147 putc ('\n', stderr);
1154 /* Report on all files that might benefit from a multiple include guard.
1157 _cpp_report_missing_guards (cpp_reader *pfile)
1161 htab_traverse (pfile->file_hash, report_missing_guard, &banner);
1164 /* Locate HEADER, and determine whether it is newer than the current
1165 file. If it cannot be located or dated, return -1, if it is
1166 newer, return 1, otherwise 0. */
1168 _cpp_compare_file_date (cpp_reader *pfile, const char *fname,
1172 struct cpp_dir *dir;
1174 dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
1178 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets);
1188 return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
1191 /* Pushes the given file onto the buffer stack. Returns nonzero if
1194 cpp_push_include (cpp_reader *pfile, const char *fname)
1196 return _cpp_stack_include (pfile, fname, false, IT_CMDLINE);
1199 /* Do appropriate cleanup when a file INC's buffer is popped off the
1202 _cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file)
1204 /* Record the inclusion-preventing macro, which could be NULL
1205 meaning no controlling macro. */
1206 if (pfile->mi_valid && file->cmacro == NULL)
1207 file->cmacro = pfile->mi_cmacro;
1209 /* Invalidate control macros in the #including file. */
1210 pfile->mi_valid = false;
1214 free ((void *) file->buffer);
1215 file->buffer = NULL;
1216 file->buffer_valid = false;
1220 /* Inteface to file statistics record in _cpp_file structure. */
1222 _cpp_get_file_stat (_cpp_file *file)
1227 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1228 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1229 directory of the including file.
1231 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1233 cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
1234 int quote_ignores_source_dir)
1236 pfile->quote_include = quote;
1237 pfile->bracket_include = quote;
1238 pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1240 for (; quote; quote = quote->next)
1242 quote->name_map = NULL;
1243 quote->len = strlen (quote->name);
1244 if (quote == bracket)
1245 pfile->bracket_include = bracket;
1249 /* Append the file name to the directory to create the path, but don't
1250 turn / into // or // into ///; // may be a namespace escape. */
1252 append_file_to_dir (const char *fname, cpp_dir *dir)
1258 flen = strlen (fname);
1259 path = XNEWVEC (char, dlen + 1 + flen + 1);
1260 memcpy (path, dir->name, dlen);
1261 if (dlen && path[dlen - 1] != '/')
1263 memcpy (&path[dlen], fname, flen + 1);
1268 /* Read a space delimited string of unlimited length from a stdio
1271 read_filename_string (int ch, FILE *f)
1277 set = alloc = XNEWVEC (char, len + 1);
1278 if (! is_space (ch))
1281 while ((ch = getc (f)) != EOF && ! is_space (ch))
1283 if (set - alloc == len)
1286 alloc = XRESIZEVEC (char, alloc, len + 1);
1287 set = alloc + len / 2;
1297 /* Read the file name map file for DIR. */
1299 read_name_map (cpp_dir *dir)
1301 static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1304 size_t len, count = 0, room = 9;
1307 name = (char *) alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
1308 memcpy (name, dir->name, len);
1309 if (len && name[len - 1] != '/')
1311 strcpy (name + len, FILE_NAME_MAP_FILE);
1312 f = fopen (name, "r");
1314 dir->name_map = XNEWVEC (const char *, room);
1316 /* Silently return NULL if we cannot open. */
1321 while ((ch = getc (f)) != EOF)
1328 if (count + 2 > room)
1331 dir->name_map = XRESIZEVEC (const char *, dir->name_map, room);
1334 dir->name_map[count] = read_filename_string (ch, f);
1335 while ((ch = getc (f)) != EOF && is_hspace (ch))
1338 to = read_filename_string (ch, f);
1339 if (IS_ABSOLUTE_PATH (to))
1340 dir->name_map[count + 1] = to;
1343 dir->name_map[count + 1] = append_file_to_dir (to, dir);
1348 while ((ch = getc (f)) != '\n')
1356 /* Terminate the list of maps. */
1357 dir->name_map[count] = NULL;
1360 /* Remap a FILE's name based on the file_name_map, if any, for
1361 FILE->dir. If the file name has any directory separators,
1362 recursively check those directories too. */
1364 remap_filename (cpp_reader *pfile, _cpp_file *file)
1366 const char *fname, *p;
1377 read_name_map (dir);
1379 for (index = 0; dir->name_map[index]; index += 2)
1380 if (!strcmp (dir->name_map[index], fname))
1381 return xstrdup (dir->name_map[index + 1]);
1383 p = strchr (fname, '/');
1384 if (!p || p == fname)
1387 len = dir->len + (p - fname + 1);
1388 new_dir = XNEWVEC (char, len + 1);
1389 memcpy (new_dir, dir->name, dir->len);
1390 memcpy (new_dir + dir->len, fname, p - fname + 1);
1391 new_dir[len] = '\0';
1393 dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1398 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1400 validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1402 const char *saved_path = file->path;
1405 file->path = pchname;
1406 if (open_file (file))
1408 valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1416 if (CPP_OPTION (pfile, print_include_names))
1419 for (i = 1; i < pfile->line_table->depth; i++)
1421 fprintf (stderr, "%c %s\n",
1422 valid ? '!' : 'x', pchname);
1426 file->path = saved_path;
1430 /* Get the path associated with the _cpp_file F. The path includes
1431 the base name from the include directive and the directory it was
1432 found in via the search path. */
1435 cpp_get_path (struct _cpp_file *f)
1440 /* Get the directory associated with the _cpp_file F. */
1443 cpp_get_dir (struct _cpp_file *f)
1448 /* Get the cpp_buffer currently associated with the cpp_reader
1452 cpp_get_buffer (cpp_reader *pfile)
1454 return pfile->buffer;
1457 /* Get the _cpp_file associated with the cpp_buffer B. */
1460 cpp_get_file (cpp_buffer *b)
1465 /* Get the previous cpp_buffer given a cpp_buffer B. The previous
1466 buffer is the buffer that included the given buffer. */
1469 cpp_get_prev (cpp_buffer *b)
1474 /* This data structure holds the list of header files that were seen
1475 while the PCH was being built. The 'entries' field is kept sorted
1476 in memcmp() order; yes, this means that on little-endian systems,
1477 it's sorted initially by the least-significant byte of 'size', but
1478 that's OK. The code does rely on having entries with the same size
1479 next to each other. */
1482 /* The size of this file. This is used to save running a MD5 checksum
1483 if the sizes don't match. */
1485 /* The MD5 checksum of this file. */
1486 unsigned char sum[16];
1487 /* Is this file to be included only once? */
1492 /* Number of pchf_entry structures. */
1495 /* Are there any values with once_only set?
1496 This is used as an optimisation, it means we don't have to search
1497 the structure if we're processing a regular #include. */
1498 bool have_once_only;
1500 struct pchf_entry entries[1];
1503 static struct pchf_data *pchf;
1505 /* A qsort ordering function for pchf_entry structures. */
1508 pchf_save_compare (const void *e1, const void *e2)
1510 return memcmp (e1, e2, sizeof (struct pchf_entry));
1513 /* Create and write to F a pchf_data structure. */
1516 _cpp_save_file_entries (cpp_reader *pfile, FILE *fp)
1519 struct pchf_data *result;
1523 for (f = pfile->all_files; f; f = f->next_file)
1526 result_size = (sizeof (struct pchf_data)
1527 + sizeof (struct pchf_entry) * (count - 1));
1528 result = XCNEWVAR (struct pchf_data, result_size);
1531 result->have_once_only = false;
1533 for (f = pfile->all_files; f; f = f->next_file)
1537 /* This should probably never happen, since if a read error occurred
1538 the PCH file shouldn't be written... */
1539 if (f->dont_read || f->err_no)
1542 if (f->stack_count == 0)
1545 count = result->count++;
1547 result->entries[count].once_only = f->once_only;
1548 /* |= is avoided in the next line because of an HP C compiler bug */
1549 result->have_once_only = result->have_once_only | f->once_only;
1550 if (f->buffer_valid)
1551 md5_buffer ((const char *)f->buffer,
1552 f->st.st_size, result->entries[count].sum);
1560 open_file_failed (pfile, f, 0);
1563 ff = fdopen (f->fd, "rb");
1564 md5_stream (ff, result->entries[count].sum);
1568 result->entries[count].size = f->st.st_size;
1571 result_size = (sizeof (struct pchf_data)
1572 + sizeof (struct pchf_entry) * (result->count - 1));
1574 qsort (result->entries, result->count, sizeof (struct pchf_entry),
1577 return fwrite (result, result_size, 1, fp) == 1;
1580 /* Read the pchf_data structure from F. */
1583 _cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f)
1587 if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f)
1591 pchf = XNEWVAR (struct pchf_data, sizeof (struct pchf_data)
1592 + sizeof (struct pchf_entry) * (d.count - 1));
1593 memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry));
1594 if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f)
1600 /* The parameters for pchf_compare. */
1602 struct pchf_compare_data
1604 /* The size of the file we're looking for. */
1607 /* The MD5 checksum of the file, if it's been computed. */
1608 unsigned char sum[16];
1613 /* Do we need to worry about entries that don't have ONCE_ONLY set? */
1614 bool check_included;
1616 /* The file that we're searching for. */
1620 /* bsearch comparison function; look for D_P in E_P. */
1623 pchf_compare (const void *d_p, const void *e_p)
1625 const struct pchf_entry *e = (const struct pchf_entry *)e_p;
1626 struct pchf_compare_data *d = (struct pchf_compare_data *)d_p;
1629 result = memcmp (&d->size, &e->size, sizeof (off_t));
1633 if (! d->sum_computed)
1635 _cpp_file *const f = d->f;
1637 md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum);
1638 d->sum_computed = true;
1641 result = memcmp (d->sum, e->sum, 16);
1645 if (d->check_included || e->once_only)
1651 /* Check that F is not in a list read from a PCH file (if any).
1652 Assumes that f->buffer_valid is true. Return TRUE if the file
1653 should not be read. */
1656 check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED,
1658 bool check_included)
1660 struct pchf_compare_data d;
1663 || (! check_included && ! pchf->have_once_only))
1666 d.size = f->st.st_size;
1667 d.sum_computed = false;
1669 d.check_included = check_included;
1670 return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
1671 pchf_compare) != NULL;