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, 2008, 2009
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 3, 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; see the file COPYING3. If not see
23 <http://www.gnu.org/licenses/>. */
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 /* Pointer to the real start of BUFFER. read_file() might increment
78 BUFFER; when freeing, this this pointer must be used instead. */
79 const uchar *buffer_start;
81 /* The macro, if any, preventing re-inclusion. */
82 const cpp_hashnode *cmacro;
84 /* The directory in the search path where FILE was found. Used for
85 #include_next and determining whether a header is a system
89 /* As filled in by stat(2) for the file. */
92 /* File descriptor. Invalid if -1, otherwise open. */
95 /* Zero if this file was successfully opened and stat()-ed,
96 otherwise errno obtained from failure. */
99 /* Number of times the file has been stacked for preprocessing. */
100 unsigned short stack_count;
102 /* If opened with #import or contains #pragma once. */
105 /* If read() failed before. */
108 /* If this file is the main file. */
111 /* If BUFFER above contains the true contents of the file. */
115 /* A singly-linked list for all searches for a given file name, with
116 its head pointed to by a slot in FILE_HASH. The file name is what
117 appeared between the quotes in a #include directive; it can be
118 determined implicitly from the hash table location or explicitly
121 FILE is a structure containing details about the file that was
122 found with that search, or details of how the search failed.
124 START_DIR is the starting location of the search in the include
125 chain. The current directories for "" includes are also hashed in
126 the hash table and therefore unique. Files that are looked up
127 without using a search path, such as absolute filenames and file
128 names from the command line share a special starting directory so
129 they don't cause cache hits with normal include-chain lookups.
131 If START_DIR is NULL then the entry is for a directory, not a file,
132 and the directory is in DIR. Since the starting point in a file
133 lookup chain is never NULL, this means that simple pointer
134 comparisons against START_DIR can be made to determine cache hits
137 If a cache lookup fails because of e.g. an extra "./" in the path,
138 then nothing will break. It is just less efficient as CPP will
139 have to do more work re-preprocessing the file, and/or comparing
140 its contents against earlier once-only files.
142 struct file_hash_entry
144 struct file_hash_entry *next;
146 source_location location;
154 /* Number of entries to put in a file_hash_entry pool. */
155 #define FILE_HASH_POOL_SIZE 127
157 /* A file hash entry pool. We allocate file_hash_entry object from
159 struct file_hash_entry_pool
161 /* Number of entries used from this pool. */
162 unsigned int file_hash_entries_used;
163 /* Next pool in the chain; used when freeing. */
164 struct file_hash_entry_pool *next;
165 /* The memory pool. */
166 struct file_hash_entry pool[FILE_HASH_POOL_SIZE];
169 static bool open_file (_cpp_file *file);
170 static bool pch_open_file (cpp_reader *pfile, _cpp_file *file,
172 static bool find_file_in_dir (cpp_reader *pfile, _cpp_file *file,
174 static bool read_file_guts (cpp_reader *pfile, _cpp_file *file);
175 static bool read_file (cpp_reader *pfile, _cpp_file *file);
176 static bool should_stack_file (cpp_reader *, _cpp_file *file, bool import);
177 static struct cpp_dir *search_path_head (cpp_reader *, const char *fname,
178 int angle_brackets, enum include_type);
179 static const char *dir_name_of_file (_cpp_file *file);
180 static void open_file_failed (cpp_reader *pfile, _cpp_file *file, int);
181 static struct file_hash_entry *search_cache (struct file_hash_entry *head,
182 const cpp_dir *start_dir);
183 static _cpp_file *make_cpp_file (cpp_reader *, cpp_dir *, const char *fname);
184 static void destroy_cpp_file (_cpp_file *);
185 static cpp_dir *make_cpp_dir (cpp_reader *, const char *dir_name, int sysp);
186 static void allocate_file_hash_entries (cpp_reader *pfile);
187 static struct file_hash_entry *new_file_hash_entry (cpp_reader *pfile);
188 static int report_missing_guard (void **slot, void *b);
189 static hashval_t file_hash_hash (const void *p);
190 static int file_hash_eq (const void *p, const void *q);
191 static char *read_filename_string (int ch, FILE *f);
192 static void read_name_map (cpp_dir *dir);
193 static char *remap_filename (cpp_reader *pfile, _cpp_file *file);
194 static char *append_file_to_dir (const char *fname, cpp_dir *dir);
195 static bool validate_pch (cpp_reader *, _cpp_file *file, const char *pchname);
196 static int pchf_save_compare (const void *e1, const void *e2);
197 static int pchf_compare (const void *d_p, const void *e_p);
198 static bool check_file_against_entries (cpp_reader *, _cpp_file *, bool);
200 /* Given a filename in FILE->PATH, with the empty string interpreted
203 On success FILE contains an open file descriptor and stat
204 information for the file. On failure the file descriptor is -1 and
205 the appropriate errno is also stored in FILE. Returns TRUE iff
208 We used to open files in nonblocking mode, but that caused more
209 problems than it solved. Do take care not to acquire a controlling
210 terminal by mistake (this can't happen on sane systems, but
211 paranoia is a virtue).
213 Use the three-argument form of open even though we aren't
214 specifying O_CREAT, to defend against broken system headers.
216 O_BINARY tells some runtime libraries (notably DJGPP) not to do
217 newline translation; we can handle DOS line breaks just fine
220 open_file (_cpp_file *file)
222 if (file->path[0] == '\0')
225 set_stdin_to_binary_mode ();
228 file->fd = open (file->path, O_RDONLY | O_NOCTTY | O_BINARY, 0666);
232 if (fstat (file->fd, &file->st) == 0)
234 if (!S_ISDIR (file->st.st_mode))
240 /* Ignore a directory and continue the search. The file we're
241 looking for may be elsewhere in the search path. */
248 #if defined(_WIN32) && !defined(__CYGWIN__)
249 else if (errno == EACCES)
251 /* On most UNIX systems, open succeeds on a directory. Above,
252 we check if we have opened a directory and if so, set errno
253 to ENOENT. However, on Windows, opening a directory
254 fails with EACCES. We want to return ENOENT in that
256 if (stat (file->path, &file->st) == 0
257 && S_ISDIR (file->st.st_mode))
260 /* The call to stat may have reset errno. */
264 else if (errno == ENOTDIR)
267 file->err_no = errno;
272 /* Temporary PCH intercept of opening a file. Try to find a PCH file
273 based on FILE->name and FILE->dir, and test those found for
274 validity using PFILE->cb.valid_pch. Return true iff a valid file is
275 found. Set *INVALID_PCH if a PCH file is found but wasn't valid. */
278 pch_open_file (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
280 static const char extension[] = ".gch";
281 const char *path = file->path;
287 /* No PCH on <stdin> or if not requested. */
288 if (file->name[0] == '\0' || !pfile->cb.valid_pch)
291 flen = strlen (path);
292 len = flen + sizeof (extension);
293 pchname = XNEWVEC (char, len);
294 memcpy (pchname, path, flen);
295 memcpy (pchname + flen, extension, sizeof (extension));
297 if (stat (pchname, &st) == 0)
301 size_t dlen, plen = len;
303 if (!S_ISDIR (st.st_mode))
304 valid = validate_pch (pfile, file, pchname);
305 else if ((pchdir = opendir (pchname)) != NULL)
307 pchname[plen - 1] = '/';
308 while ((d = readdir (pchdir)) != NULL)
310 dlen = strlen (d->d_name) + 1;
311 if ((strcmp (d->d_name, ".") == 0)
312 || (strcmp (d->d_name, "..") == 0))
314 if (dlen + plen > len)
317 pchname = XRESIZEVEC (char, pchname, len);
319 memcpy (pchname + plen, d->d_name, dlen);
320 valid = validate_pch (pfile, file, pchname);
331 file->pchname = pchname;
338 /* Try to open the path FILE->name appended to FILE->dir. This is
339 where remap and PCH intercept the file lookup process. Return true
340 if the file was found, whether or not the open was successful.
341 Set *INVALID_PCH to true if a PCH file is found but wasn't valid. */
344 find_file_in_dir (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
348 if (CPP_OPTION (pfile, remap) && (path = remap_filename (pfile, file)))
351 if (file->dir->construct)
352 path = file->dir->construct (file->name, file->dir);
354 path = append_file_to_dir (file->name, file->dir);
358 hashval_t hv = htab_hash_string (path);
362 if (htab_find_with_hash (pfile->nonexistent_file_hash, path, hv) != NULL)
364 file->err_no = ENOENT;
369 if (pch_open_file (pfile, file, invalid_pch))
372 if (open_file (file))
375 if (file->err_no != ENOENT)
377 open_file_failed (pfile, file, 0);
381 /* We copy the path name onto an obstack partly so that we don't
382 leak the memory, but mostly so that we don't fragment the
384 copy = (char *) obstack_copy0 (&pfile->nonexistent_file_ob, path,
387 pp = htab_find_slot_with_hash (pfile->nonexistent_file_hash,
391 file->path = file->name;
395 file->err_no = ENOENT;
402 /* Return tue iff the missing_header callback found the given HEADER. */
404 search_path_exhausted (cpp_reader *pfile, const char *header, _cpp_file *file)
406 missing_header_cb func = pfile->cb.missing_header;
408 /* When the regular search path doesn't work, try context dependent
409 headers search paths. */
411 && file->dir == NULL)
413 if ((file->path = func (pfile, header, &file->dir)) != NULL)
415 if (open_file (file))
417 free ((void *)file->path);
419 file->path = file->name;
426 _cpp_find_failed (_cpp_file *file)
428 return file->err_no != 0;
431 /* Given a filename FNAME search for such a file in the include path
432 starting from START_DIR. If FNAME is the empty string it is
433 interpreted as STDIN if START_DIR is PFILE->no_search_path.
435 If the file is not found in the file cache fall back to the O/S and
436 add the result to our cache.
438 If the file was not found in the filesystem, or there was an error
439 opening it, then ERR_NO is nonzero and FD is -1. If the file was
440 found, then ERR_NO is zero and FD could be -1 or an open file
441 descriptor. FD can be -1 if the file was found in the cache and
442 had previously been closed. To open it again pass the return value
446 _cpp_find_file (cpp_reader *pfile, const char *fname, cpp_dir *start_dir, bool fake, int angle_brackets)
448 struct file_hash_entry *entry, **hash_slot;
450 bool invalid_pch = false;
451 bool saw_bracket_include = false;
452 bool saw_quote_include = false;
453 struct cpp_dir *found_in_cache = NULL;
455 /* Ensure we get no confusion between cached files and directories. */
456 if (start_dir == NULL)
457 cpp_error (pfile, CPP_DL_ICE, "NULL directory in find_file");
459 hash_slot = (struct file_hash_entry **)
460 htab_find_slot_with_hash (pfile->file_hash, fname,
461 htab_hash_string (fname),
464 /* First check the cache before we resort to memory allocation. */
465 entry = search_cache (*hash_slot, start_dir);
467 return entry->u.file;
469 file = make_cpp_file (pfile, start_dir, fname);
471 /* Try each path in the include chain. */
474 if (find_file_in_dir (pfile, file, &invalid_pch))
477 file->dir = file->dir->next;
478 if (file->dir == NULL)
480 if (search_path_exhausted (pfile, fname, file))
482 /* Although this file must not go in the cache, because
483 the file found might depend on things (like the current file)
484 that aren't represented in the cache, it still has to go in
485 the list of all files so that #import works. */
486 file->next_file = pfile->all_files;
487 pfile->all_files = file;
493 cpp_error (pfile, CPP_DL_ERROR,
494 "one or more PCH files were found, but they were invalid");
495 if (!cpp_get_options (pfile)->warn_invalid_pch)
496 cpp_error (pfile, CPP_DL_ERROR,
497 "use -Winvalid-pch for more information");
499 open_file_failed (pfile, file, angle_brackets);
503 /* Only check the cache for the starting location (done above)
504 and the quote and bracket chain heads because there are no
505 other possible starting points for searches. */
506 if (file->dir == pfile->bracket_include)
507 saw_bracket_include = true;
508 else if (file->dir == pfile->quote_include)
509 saw_quote_include = true;
513 entry = search_cache (*hash_slot, file->dir);
516 found_in_cache = file->dir;
523 /* Cache for START_DIR too, sharing the _cpp_file structure. */
524 free ((char *) file->name);
526 file = entry->u.file;
530 /* This is a new file; put it in the list. */
531 file->next_file = pfile->all_files;
532 pfile->all_files = file;
535 /* Store this new result in the hash table. */
536 entry = new_file_hash_entry (pfile);
537 entry->next = *hash_slot;
538 entry->start_dir = start_dir;
539 entry->location = pfile->line_table->highest_location;
540 entry->u.file = file;
543 /* If we passed the quote or bracket chain heads, cache them also.
544 This speeds up processing if there are lots of -I options. */
545 if (saw_bracket_include
546 && pfile->bracket_include != start_dir
547 && found_in_cache != pfile->bracket_include)
549 entry = new_file_hash_entry (pfile);
550 entry->next = *hash_slot;
551 entry->start_dir = pfile->bracket_include;
552 entry->location = pfile->line_table->highest_location;
553 entry->u.file = file;
556 if (saw_quote_include
557 && pfile->quote_include != start_dir
558 && found_in_cache != pfile->quote_include)
560 entry = new_file_hash_entry (pfile);
561 entry->next = *hash_slot;
562 entry->start_dir = pfile->quote_include;
563 entry->location = pfile->line_table->highest_location;
564 entry->u.file = file;
571 /* Read a file into FILE->buffer, returning true on success.
573 If FILE->fd is something weird, like a block device, we don't want
574 to read it at all. Don't even try to figure out what something is,
575 except for plain files and block devices, since there is no
576 reliable portable way of doing this.
578 FIXME: Flush file cache and try again if we run out of memory. */
580 read_file_guts (cpp_reader *pfile, _cpp_file *file)
582 ssize_t size, total, count;
586 if (S_ISBLK (file->st.st_mode))
588 cpp_error (pfile, CPP_DL_ERROR, "%s is a block device", file->path);
592 regular = S_ISREG (file->st.st_mode);
595 /* off_t might have a wider range than ssize_t - in other words,
596 the max size of a file might be bigger than the address
597 space. We can't handle a file that large. (Anyone with
598 a single source file bigger than 2GB needs to rethink
599 their coding style.) Some systems (e.g. AIX 4.1) define
600 SSIZE_MAX to be much smaller than the actual range of the
601 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
603 if (file->st.st_size > INTTYPE_MAXIMUM (ssize_t))
605 cpp_error (pfile, CPP_DL_ERROR, "%s is too large", file->path);
609 size = file->st.st_size;
612 /* 8 kilobytes is a sensible starting size. It ought to be bigger
613 than the kernel pipe buffer, and it's definitely bigger than
614 the majority of C source files. */
617 buf = XNEWVEC (uchar, size + 1);
619 while ((count = read (file->fd, buf + total, size - total)) > 0)
628 buf = XRESIZEVEC (uchar, buf, size + 1);
634 cpp_errno (pfile, CPP_DL_ERROR, file->path);
638 if (regular && total != size && STAT_SIZE_RELIABLE (file->st))
639 cpp_error (pfile, CPP_DL_WARNING,
640 "%s is shorter than expected", file->path);
642 file->buffer = _cpp_convert_input (pfile,
643 CPP_OPTION (pfile, input_charset),
647 file->buffer_valid = true;
652 /* Convenience wrapper around read_file_guts that opens the file if
653 necessary and closes the file descriptor after reading. FILE must
654 have been passed through find_file() at some stage. */
656 read_file (cpp_reader *pfile, _cpp_file *file)
658 /* If we already have its contents in memory, succeed immediately. */
659 if (file->buffer_valid)
662 /* If an earlier read failed for some reason don't try again. */
663 if (file->dont_read || file->err_no)
666 if (file->fd == -1 && !open_file (file))
668 open_file_failed (pfile, file, 0);
672 file->dont_read = !read_file_guts (pfile, file);
676 return !file->dont_read;
679 /* Returns TRUE if FILE's contents have been successfully placed in
680 FILE->buffer and the file should be stacked, otherwise false. */
682 should_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
686 /* Skip once-only files. */
690 /* We must mark the file once-only if #import now, before header
691 guard checks. Otherwise, undefining the header guard might
692 cause the file to be re-stacked. */
695 _cpp_mark_file_once_only (pfile, file);
697 /* Don't stack files that have been stacked before. */
698 if (file->stack_count)
702 /* Skip if the file had a header guard and the macro is defined.
703 PCH relies on this appearing before the PCH handler below. */
704 if (file->cmacro && file->cmacro->type == NT_MACRO)
707 /* Handle PCH files immediately; don't stack them. */
710 pfile->cb.read_pch (pfile, file->pchname, file->fd, file->path);
712 free ((void *) file->pchname);
713 file->pchname = NULL;
717 if (!read_file (pfile, file))
720 /* Check the file against the PCH file. This is done before
721 checking against files we've already seen, since it may save on
723 if (check_file_against_entries (pfile, file, import))
725 /* If this isn't a #import, but yet we can't include the file,
726 that means that it was #import-ed in the PCH file,
727 so we can never include it again. */
729 _cpp_mark_file_once_only (pfile, file);
733 /* Now we've read the file's contents, we can stack it if there
734 are no once-only files. */
735 if (!pfile->seen_once_only)
738 /* We may have read the file under a different name. Look
739 for likely candidates and compare file contents to be sure. */
740 for (f = pfile->all_files; f; f = f->next_file)
745 if ((import || f->once_only)
747 && f->st.st_mtime == file->st.st_mtime
748 && f->st.st_size == file->st.st_size)
751 bool same_file_p = false;
753 if (f->buffer && !f->buffer_valid)
755 /* We already have a buffer but it is not valid, because
756 the file is still stacked. Make a new one. */
757 ref_file = make_cpp_file (pfile, f->dir, f->name);
758 ref_file->path = f->path;
761 /* The file is not stacked anymore. We can reuse it. */
764 same_file_p = read_file (pfile, ref_file)
765 /* Size might have changed in read_file(). */
766 && ref_file->st.st_size == file->st.st_size
767 && !memcmp (ref_file->buffer,
771 if (f->buffer && !f->buffer_valid)
774 destroy_cpp_file (ref_file);
785 /* Place the file referenced by FILE into a new buffer on the buffer
786 stack if possible. IMPORT is true if this stacking attempt is
787 because of a #import directive. Returns true if a buffer is
790 _cpp_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
795 if (!should_stack_file (pfile, file, import))
798 if (pfile->buffer == NULL || file->dir == NULL)
801 sysp = MAX (pfile->buffer->sysp, file->dir->sysp);
803 /* Add the file to the dependencies on its first inclusion. */
804 if (CPP_OPTION (pfile, deps.style) > !!sysp && !file->stack_count)
806 if (!file->main_file || !CPP_OPTION (pfile, deps.ignore_main_file))
807 deps_add_dep (pfile->deps, file->path);
810 /* Clear buffer_valid since _cpp_clean_line messes it up. */
811 file->buffer_valid = false;
814 /* Stack the buffer. */
815 buffer = cpp_push_buffer (pfile, file->buffer, file->st.st_size,
816 CPP_OPTION (pfile, preprocessed)
817 && !CPP_OPTION (pfile, directives_only));
821 /* Initialize controlling macro state. */
822 pfile->mi_valid = true;
823 pfile->mi_cmacro = 0;
825 /* Generate the call back. */
826 _cpp_do_file_change (pfile, LC_ENTER, file->path, 1, sysp);
831 /* Mark FILE to be included once only. */
833 _cpp_mark_file_once_only (cpp_reader *pfile, _cpp_file *file)
835 pfile->seen_once_only = true;
836 file->once_only = true;
839 /* Return the directory from which searching for FNAME should start,
840 considering the directive TYPE and ANGLE_BRACKETS. If there is
841 nothing left in the path, returns NULL. */
842 static struct cpp_dir *
843 search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets,
844 enum include_type type)
849 if (IS_ABSOLUTE_PATH (fname))
850 return &pfile->no_search_path;
852 /* pfile->buffer is NULL when processing an -include command-line flag. */
853 file = pfile->buffer == NULL ? pfile->main_file : pfile->buffer->file;
855 /* For #include_next, skip in the search path past the dir in which
856 the current file was found, but if it was found via an absolute
857 path use the normal search logic. */
858 if (type == IT_INCLUDE_NEXT && file->dir
859 && file->dir != &pfile->no_search_path)
860 dir = file->dir->next;
861 else if (angle_brackets)
862 dir = pfile->bracket_include;
863 else if (type == IT_CMDLINE)
864 /* -include and -imacros use the #include "" chain with the
865 preprocessor's cwd prepended. */
866 return make_cpp_dir (pfile, "./", false);
867 else if (pfile->quote_ignores_source_dir)
868 dir = pfile->quote_include;
870 return make_cpp_dir (pfile, dir_name_of_file (file),
871 pfile->buffer ? pfile->buffer->sysp : 0);
874 cpp_error (pfile, CPP_DL_ERROR,
875 "no include path in which to search for %s", fname);
880 /* Strip the basename from the file's path. It ends with a slash if
881 of nonzero length. Note that this procedure also works for
882 <stdin>, which is represented by the empty string. */
884 dir_name_of_file (_cpp_file *file)
888 size_t len = lbasename (file->path) - file->path;
889 char *dir_name = XNEWVEC (char, len + 1);
891 memcpy (dir_name, file->path, len);
892 dir_name[len] = '\0';
893 file->dir_name = dir_name;
896 return file->dir_name;
899 /* Handles #include-family directives (distinguished by TYPE),
900 including HEADER, and the command line -imacros and -include.
901 Returns true if a buffer was stacked. */
903 _cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets,
904 enum include_type type)
909 dir = search_path_head (pfile, fname, angle_brackets, type);
913 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets);
915 /* Compensate for the increment in linemap_add that occurs in
916 _cpp_stack_file. In the case of a normal #include, we're
917 currently at the start of the line *following* the #include. A
918 separate source_location for this location makes no sense (until
919 we do the LC_LEAVE), and complicates LAST_SOURCE_LINE_LOCATION.
920 This does not apply if we found a PCH file (in which case
921 linemap_add is not called) or we were included from the
923 if (file->pchname == NULL && file->err_no == 0 && type != IT_CMDLINE)
924 pfile->line_table->highest_location--;
926 return _cpp_stack_file (pfile, file, type == IT_IMPORT);
929 /* Could not open FILE. The complication is dependency output. */
931 open_file_failed (cpp_reader *pfile, _cpp_file *file, int angle_brackets)
933 int sysp = pfile->line_table->highest_line > 1 && pfile->buffer ? pfile->buffer->sysp : 0;
934 bool print_dep = CPP_OPTION (pfile, deps.style) > (angle_brackets || !!sysp);
936 errno = file->err_no;
937 if (print_dep && CPP_OPTION (pfile, deps.missing_files) && errno == ENOENT)
939 deps_add_dep (pfile->deps, file->name);
940 /* If the preprocessor output (other than dependency information) is
941 being used, we must also flag an error. */
942 if (CPP_OPTION (pfile, deps.need_preprocessor_output))
943 cpp_errno (pfile, CPP_DL_FATAL, file->path);
947 /* If we are not outputting dependencies, or if we are and dependencies
948 were requested for this file, or if preprocessor output is needed
949 in addition to dependency information, this is an error.
951 Otherwise (outputting dependencies but not for this file, and not
952 using the preprocessor output), we can still produce correct output
953 so it's only a warning. */
954 if (CPP_OPTION (pfile, deps.style) == DEPS_NONE
956 || CPP_OPTION (pfile, deps.need_preprocessor_output))
957 cpp_errno (pfile, CPP_DL_FATAL, file->path);
959 cpp_errno (pfile, CPP_DL_WARNING, file->path);
963 /* Search in the chain beginning at HEAD for a file whose search path
964 started at START_DIR != NULL. */
965 static struct file_hash_entry *
966 search_cache (struct file_hash_entry *head, const cpp_dir *start_dir)
968 while (head && head->start_dir != start_dir)
974 /* Allocate a new _cpp_file structure. */
976 make_cpp_file (cpp_reader *pfile, cpp_dir *dir, const char *fname)
980 file = XCNEW (_cpp_file);
981 file->main_file = !pfile->buffer;
984 file->name = xstrdup (fname);
989 /* Release a _cpp_file structure. */
991 destroy_cpp_file (_cpp_file *file)
993 if (file->buffer_start)
994 free ((void *) file->buffer_start);
995 free ((void *) file->name);
999 /* Release all the files allocated by this reader. */
1001 destroy_all_cpp_files (cpp_reader *pfile)
1003 _cpp_file *iter = pfile->all_files;
1006 _cpp_file *next = iter->next_file;
1007 destroy_cpp_file (iter);
1012 /* A hash of directory names. The directory names are the path names
1013 of files which contain a #include "", the included file name is
1014 appended to this directories.
1016 To avoid duplicate entries we follow the convention that all
1017 non-empty directory names should end in a '/'. DIR_NAME must be
1018 stored in permanently allocated memory. */
1020 make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
1022 struct file_hash_entry *entry, **hash_slot;
1025 hash_slot = (struct file_hash_entry **)
1026 htab_find_slot_with_hash (pfile->dir_hash, dir_name,
1027 htab_hash_string (dir_name),
1030 /* Have we already hashed this directory? */
1031 for (entry = *hash_slot; entry; entry = entry->next)
1032 if (entry->start_dir == NULL)
1033 return entry->u.dir;
1035 dir = XCNEW (cpp_dir);
1036 dir->next = pfile->quote_include;
1037 dir->name = (char *) dir_name;
1038 dir->len = strlen (dir_name);
1042 /* Store this new result in the hash table. */
1043 entry = new_file_hash_entry (pfile);
1044 entry->next = *hash_slot;
1045 entry->start_dir = NULL;
1046 entry->location = pfile->line_table->highest_location;
1053 /* Create a new block of memory for file hash entries. */
1055 allocate_file_hash_entries (cpp_reader *pfile)
1057 struct file_hash_entry_pool *pool = XNEW (struct file_hash_entry_pool);
1058 pool->file_hash_entries_used = 0;
1059 pool->next = pfile->file_hash_entries;
1060 pfile->file_hash_entries = pool;
1063 /* Return a new file hash entry. */
1064 static struct file_hash_entry *
1065 new_file_hash_entry (cpp_reader *pfile)
1068 if (pfile->file_hash_entries->file_hash_entries_used == FILE_HASH_POOL_SIZE)
1069 allocate_file_hash_entries (pfile);
1071 idx = pfile->file_hash_entries->file_hash_entries_used++;
1072 return &pfile->file_hash_entries->pool[idx];
1075 /* Free the file hash entry pools. */
1077 free_file_hash_entries (cpp_reader *pfile)
1079 struct file_hash_entry_pool *iter = pfile->file_hash_entries;
1082 struct file_hash_entry_pool *next = iter->next;
1088 /* Returns TRUE if a file FNAME has ever been successfully opened.
1089 This routine is not intended to correctly handle filenames aliased
1090 by links or redundant . or .. traversals etc. */
1092 cpp_included (cpp_reader *pfile, const char *fname)
1094 struct file_hash_entry *entry;
1096 entry = (struct file_hash_entry *)
1097 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1099 while (entry && (entry->start_dir == NULL || entry->u.file->err_no))
1100 entry = entry->next;
1102 return entry != NULL;
1105 /* Returns TRUE if a file FNAME has ever been successfully opened
1106 before LOCATION. This routine is not intended to correctly handle
1107 filenames aliased by links or redundant . or .. traversals etc. */
1109 cpp_included_before (cpp_reader *pfile, const char *fname,
1110 source_location location)
1112 struct file_hash_entry *entry;
1114 entry = (struct file_hash_entry *)
1115 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1117 while (entry && (entry->start_dir == NULL || entry->u.file->err_no
1118 || entry->location > location))
1119 entry = entry->next;
1121 return entry != NULL;
1124 /* Calculate the hash value of a file hash entry P. */
1127 file_hash_hash (const void *p)
1129 struct file_hash_entry *entry = (struct file_hash_entry *) p;
1131 if (entry->start_dir)
1132 hname = entry->u.file->name;
1134 hname = entry->u.dir->name;
1136 return htab_hash_string (hname);
1139 /* Compare a string Q against a file hash entry P. */
1141 file_hash_eq (const void *p, const void *q)
1143 struct file_hash_entry *entry = (struct file_hash_entry *) p;
1144 const char *fname = (const char *) q;
1147 if (entry->start_dir)
1148 hname = entry->u.file->name;
1150 hname = entry->u.dir->name;
1152 return strcmp (hname, fname) == 0;
1155 /* Compare entries in the nonexistent file hash table. These are just
1158 nonexistent_file_hash_eq (const void *p, const void *q)
1160 return strcmp ((const char *) p, (const char *) q) == 0;
1163 /* Initialize everything in this source file. */
1165 _cpp_init_files (cpp_reader *pfile)
1167 pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1168 NULL, xcalloc, free);
1169 pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1170 NULL, xcalloc, free);
1171 allocate_file_hash_entries (pfile);
1172 pfile->nonexistent_file_hash = htab_create_alloc (127, htab_hash_string,
1173 nonexistent_file_hash_eq,
1174 NULL, xcalloc, free);
1175 _obstack_begin (&pfile->nonexistent_file_ob, 0, 0,
1176 (void *(*) (long)) xmalloc,
1177 (void (*) (void *)) free);
1180 /* Finalize everything in this source file. */
1182 _cpp_cleanup_files (cpp_reader *pfile)
1184 htab_delete (pfile->file_hash);
1185 htab_delete (pfile->dir_hash);
1186 htab_delete (pfile->nonexistent_file_hash);
1187 obstack_free (&pfile->nonexistent_file_ob, 0);
1188 free_file_hash_entries (pfile);
1189 destroy_all_cpp_files (pfile);
1192 /* Make the parser forget about files it has seen. This can be useful
1193 for resetting the parser to start another run. */
1195 cpp_clear_file_cache (cpp_reader *pfile)
1197 _cpp_cleanup_files (pfile);
1198 pfile->file_hash_entries = NULL;
1199 pfile->all_files = NULL;
1200 _cpp_init_files (pfile);
1203 /* Enter a file name in the hash for the sake of cpp_included. */
1205 _cpp_fake_include (cpp_reader *pfile, const char *fname)
1207 _cpp_find_file (pfile, fname, pfile->buffer->file->dir, true, 0);
1210 /* Not everyone who wants to set system-header-ness on a buffer can
1211 see the details of a buffer. This is an exported interface because
1212 fix-header needs it. */
1214 cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
1217 const struct line_maps *line_table = pfile->line_table;
1218 const struct line_map *map = &line_table->maps[line_table->used-1];
1220 /* 1 = system header, 2 = system header to be treated as C. */
1222 flags = 1 + (externc != 0);
1223 pfile->buffer->sysp = flags;
1224 _cpp_do_file_change (pfile, LC_RENAME, map->to_file,
1225 SOURCE_LINE (map, pfile->line_table->highest_line), flags);
1228 /* Allow the client to change the current file. Used by the front end
1229 to achieve pseudo-file names like <built-in>.
1230 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
1232 cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
1233 const char *new_name)
1235 _cpp_do_file_change (pfile, reason, new_name, 1, 0);
1238 struct report_missing_guard_data
1244 /* Callback function for htab_traverse. */
1246 report_missing_guard (void **slot, void *d)
1248 struct file_hash_entry *entry = (struct file_hash_entry *) *slot;
1249 struct report_missing_guard_data *data
1250 = (struct report_missing_guard_data *) d;
1252 /* Skip directories. */
1253 if (entry->start_dir != NULL)
1255 _cpp_file *file = entry->u.file;
1257 /* We don't want MI guard advice for the main file. */
1258 if (file->cmacro == NULL && file->stack_count == 1 && !file->main_file)
1260 if (data->paths == NULL)
1262 data->paths = XCNEWVEC (const char *, data->count);
1266 data->paths[data->count++] = file->path;
1270 /* Keep traversing the hash table. */
1274 /* Comparison function for qsort. */
1276 report_missing_guard_cmp (const void *p1, const void *p2)
1278 return strcmp (*(const char *const *) p1, *(const char *const *) p2);
1281 /* Report on all files that might benefit from a multiple include guard.
1284 _cpp_report_missing_guards (cpp_reader *pfile)
1286 struct report_missing_guard_data data;
1289 data.count = htab_elements (pfile->file_hash);
1290 htab_traverse (pfile->file_hash, report_missing_guard, &data);
1292 if (data.paths != NULL)
1296 /* Sort the paths to avoid outputting them in hash table
1298 qsort (data.paths, data.count, sizeof (const char *),
1299 report_missing_guard_cmp);
1300 fputs (_("Multiple include guards may be useful for:\n"),
1302 for (i = 0; i < data.count; i++)
1304 fputs (data.paths[i], stderr);
1305 putc ('\n', stderr);
1311 /* Locate HEADER, and determine whether it is newer than the current
1312 file. If it cannot be located or dated, return -1, if it is
1313 newer, return 1, otherwise 0. */
1315 _cpp_compare_file_date (cpp_reader *pfile, const char *fname,
1319 struct cpp_dir *dir;
1321 dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
1325 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets);
1335 return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
1338 /* Pushes the given file onto the buffer stack. Returns nonzero if
1341 cpp_push_include (cpp_reader *pfile, const char *fname)
1343 return _cpp_stack_include (pfile, fname, false, IT_CMDLINE);
1346 /* Do appropriate cleanup when a file INC's buffer is popped off the
1349 _cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file)
1351 /* Record the inclusion-preventing macro, which could be NULL
1352 meaning no controlling macro. */
1353 if (pfile->mi_valid && file->cmacro == NULL)
1354 file->cmacro = pfile->mi_cmacro;
1356 /* Invalidate control macros in the #including file. */
1357 pfile->mi_valid = false;
1359 if (file->buffer_start)
1361 free ((void *) file->buffer_start);
1362 file->buffer_start = NULL;
1363 file->buffer = NULL;
1364 file->buffer_valid = false;
1368 /* Inteface to file statistics record in _cpp_file structure. */
1370 _cpp_get_file_stat (_cpp_file *file)
1375 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1376 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1377 directory of the including file.
1379 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1381 cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
1382 int quote_ignores_source_dir)
1384 pfile->quote_include = quote;
1385 pfile->bracket_include = quote;
1386 pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1388 for (; quote; quote = quote->next)
1390 quote->name_map = NULL;
1391 quote->len = strlen (quote->name);
1392 if (quote == bracket)
1393 pfile->bracket_include = bracket;
1397 /* Append the file name to the directory to create the path, but don't
1398 turn / into // or // into ///; // may be a namespace escape. */
1400 append_file_to_dir (const char *fname, cpp_dir *dir)
1406 flen = strlen (fname);
1407 path = XNEWVEC (char, dlen + 1 + flen + 1);
1408 memcpy (path, dir->name, dlen);
1409 if (dlen && path[dlen - 1] != '/')
1411 memcpy (&path[dlen], fname, flen + 1);
1416 /* Read a space delimited string of unlimited length from a stdio
1419 read_filename_string (int ch, FILE *f)
1425 set = alloc = XNEWVEC (char, len + 1);
1426 if (! is_space (ch))
1429 while ((ch = getc (f)) != EOF && ! is_space (ch))
1431 if (set - alloc == len)
1434 alloc = XRESIZEVEC (char, alloc, len + 1);
1435 set = alloc + len / 2;
1445 /* Read the file name map file for DIR. */
1447 read_name_map (cpp_dir *dir)
1449 static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1452 size_t len, count = 0, room = 9;
1455 name = (char *) alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
1456 memcpy (name, dir->name, len);
1457 if (len && name[len - 1] != '/')
1459 strcpy (name + len, FILE_NAME_MAP_FILE);
1460 f = fopen (name, "r");
1462 dir->name_map = XNEWVEC (const char *, room);
1464 /* Silently return NULL if we cannot open. */
1469 while ((ch = getc (f)) != EOF)
1476 if (count + 2 > room)
1479 dir->name_map = XRESIZEVEC (const char *, dir->name_map, room);
1482 dir->name_map[count] = read_filename_string (ch, f);
1483 while ((ch = getc (f)) != EOF && is_hspace (ch))
1486 to = read_filename_string (ch, f);
1487 if (IS_ABSOLUTE_PATH (to))
1488 dir->name_map[count + 1] = to;
1491 dir->name_map[count + 1] = append_file_to_dir (to, dir);
1496 while ((ch = getc (f)) != '\n')
1504 /* Terminate the list of maps. */
1505 dir->name_map[count] = NULL;
1508 /* Remap a FILE's name based on the file_name_map, if any, for
1509 FILE->dir. If the file name has any directory separators,
1510 recursively check those directories too. */
1512 remap_filename (cpp_reader *pfile, _cpp_file *file)
1514 const char *fname, *p;
1525 read_name_map (dir);
1527 for (index = 0; dir->name_map[index]; index += 2)
1528 if (!strcmp (dir->name_map[index], fname))
1529 return xstrdup (dir->name_map[index + 1]);
1531 p = strchr (fname, '/');
1532 if (!p || p == fname)
1535 len = dir->len + (p - fname + 1);
1536 new_dir = XNEWVEC (char, len + 1);
1537 memcpy (new_dir, dir->name, dir->len);
1538 memcpy (new_dir + dir->len, fname, p - fname + 1);
1539 new_dir[len] = '\0';
1541 dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1546 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1548 validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1550 const char *saved_path = file->path;
1553 file->path = pchname;
1554 if (open_file (file))
1556 valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1564 if (CPP_OPTION (pfile, print_include_names))
1567 for (i = 1; i < pfile->line_table->depth; i++)
1569 fprintf (stderr, "%c %s\n",
1570 valid ? '!' : 'x', pchname);
1574 file->path = saved_path;
1578 /* Get the path associated with the _cpp_file F. The path includes
1579 the base name from the include directive and the directory it was
1580 found in via the search path. */
1583 cpp_get_path (struct _cpp_file *f)
1588 /* Get the directory associated with the _cpp_file F. */
1591 cpp_get_dir (struct _cpp_file *f)
1596 /* Get the cpp_buffer currently associated with the cpp_reader
1600 cpp_get_buffer (cpp_reader *pfile)
1602 return pfile->buffer;
1605 /* Get the _cpp_file associated with the cpp_buffer B. */
1608 cpp_get_file (cpp_buffer *b)
1613 /* Get the previous cpp_buffer given a cpp_buffer B. The previous
1614 buffer is the buffer that included the given buffer. */
1617 cpp_get_prev (cpp_buffer *b)
1622 /* This data structure holds the list of header files that were seen
1623 while the PCH was being built. The 'entries' field is kept sorted
1624 in memcmp() order; yes, this means that on little-endian systems,
1625 it's sorted initially by the least-significant byte of 'size', but
1626 that's OK. The code does rely on having entries with the same size
1627 next to each other. */
1630 /* The size of this file. This is used to save running a MD5 checksum
1631 if the sizes don't match. */
1633 /* The MD5 checksum of this file. */
1634 unsigned char sum[16];
1635 /* Is this file to be included only once? */
1640 /* Number of pchf_entry structures. */
1643 /* Are there any values with once_only set?
1644 This is used as an optimisation, it means we don't have to search
1645 the structure if we're processing a regular #include. */
1646 bool have_once_only;
1648 struct pchf_entry entries[1];
1651 static struct pchf_data *pchf;
1653 /* A qsort ordering function for pchf_entry structures. */
1656 pchf_save_compare (const void *e1, const void *e2)
1658 return memcmp (e1, e2, sizeof (struct pchf_entry));
1661 /* Create and write to F a pchf_data structure. */
1664 _cpp_save_file_entries (cpp_reader *pfile, FILE *fp)
1667 struct pchf_data *result;
1671 for (f = pfile->all_files; f; f = f->next_file)
1674 result_size = (sizeof (struct pchf_data)
1675 + sizeof (struct pchf_entry) * (count - 1));
1676 result = XCNEWVAR (struct pchf_data, result_size);
1679 result->have_once_only = false;
1681 for (f = pfile->all_files; f; f = f->next_file)
1685 /* This should probably never happen, since if a read error occurred
1686 the PCH file shouldn't be written... */
1687 if (f->dont_read || f->err_no)
1690 if (f->stack_count == 0)
1693 count = result->count++;
1695 result->entries[count].once_only = f->once_only;
1696 /* |= is avoided in the next line because of an HP C compiler bug */
1697 result->have_once_only = result->have_once_only | f->once_only;
1698 if (f->buffer_valid)
1699 md5_buffer ((const char *)f->buffer,
1700 f->st.st_size, result->entries[count].sum);
1708 open_file_failed (pfile, f, 0);
1711 ff = fdopen (f->fd, "rb");
1712 md5_stream (ff, result->entries[count].sum);
1716 result->entries[count].size = f->st.st_size;
1719 result_size = (sizeof (struct pchf_data)
1720 + sizeof (struct pchf_entry) * (result->count - 1));
1722 qsort (result->entries, result->count, sizeof (struct pchf_entry),
1725 return fwrite (result, result_size, 1, fp) == 1;
1728 /* Read the pchf_data structure from F. */
1731 _cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f)
1735 if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f)
1739 pchf = XNEWVAR (struct pchf_data, sizeof (struct pchf_data)
1740 + sizeof (struct pchf_entry) * (d.count - 1));
1741 memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry));
1742 if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f)
1748 /* The parameters for pchf_compare. */
1750 struct pchf_compare_data
1752 /* The size of the file we're looking for. */
1755 /* The MD5 checksum of the file, if it's been computed. */
1756 unsigned char sum[16];
1761 /* Do we need to worry about entries that don't have ONCE_ONLY set? */
1762 bool check_included;
1764 /* The file that we're searching for. */
1768 /* bsearch comparison function; look for D_P in E_P. */
1771 pchf_compare (const void *d_p, const void *e_p)
1773 const struct pchf_entry *e = (const struct pchf_entry *)e_p;
1774 struct pchf_compare_data *d = (struct pchf_compare_data *)d_p;
1777 result = memcmp (&d->size, &e->size, sizeof (off_t));
1781 if (! d->sum_computed)
1783 _cpp_file *const f = d->f;
1785 md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum);
1786 d->sum_computed = true;
1789 result = memcmp (d->sum, e->sum, 16);
1793 if (d->check_included || e->once_only)
1799 /* Check that F is not in a list read from a PCH file (if any).
1800 Assumes that f->buffer_valid is true. Return TRUE if the file
1801 should not be read. */
1804 check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED,
1806 bool check_included)
1808 struct pchf_compare_data d;
1811 || (! check_included && ! pchf->have_once_only))
1814 d.size = f->st.st_size;
1815 d.sum_computed = false;
1817 d.check_included = check_included;
1818 return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
1819 pchf_compare) != NULL;