Mark ChangeLog
[official-gcc.git] / libcpp / files.c
blobecf9d6c4651a598aa8b385800e12ace34301a114
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
14 later version.
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/>. */
25 #include "config.h"
26 #include "system.h"
27 #include "cpplib.h"
28 #include "internal.h"
29 #include "mkdeps.h"
30 #include "obstack.h"
31 #include "hashtab.h"
32 #include "md5.h"
33 #include <dirent.h>
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. */
37 #ifdef VMS
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)
40 #else
41 # define STAT_SIZE_RELIABLE(ST) true
42 #endif
44 #ifdef __DJGPP__
45 #include <io.h>
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)
49 #else
50 # define set_stdin_to_binary_mode() /* Nothing */
51 #endif
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. */
56 struct _cpp_file
58 /* Filename as given to #include or command line switch. */
59 const char *name;
61 /* The full path used to find the file. */
62 const char *path;
64 /* The full path of the pch file. */
65 const char *pchname;
67 /* The file's path with the basename stripped. NULL if it hasn't
68 been calculated yet. */
69 const char *dir_name;
71 /* Chain through all files. */
72 struct _cpp_file *next_file;
74 /* The contents of NAME after calling read_file(). */
75 const uchar *buffer;
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
86 header. */
87 cpp_dir *dir;
89 /* As filled in by stat(2) for the file. */
90 struct stat st;
92 /* File descriptor. Invalid if -1, otherwise open. */
93 int fd;
95 /* Zero if this file was successfully opened and stat()-ed,
96 otherwise errno obtained from failure. */
97 int err_no;
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. */
103 bool once_only;
105 /* If read() failed before. */
106 bool dont_read;
108 /* If this file is the main file. */
109 bool main_file;
111 /* If BUFFER above contains the true contents of the file. */
112 bool buffer_valid;
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
119 from FILE->name.
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
135 in file lookups.
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;
145 cpp_dir *start_dir;
146 source_location location;
147 union
149 _cpp_file *file;
150 cpp_dir *dir;
151 } u;
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
158 one of these. */
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,
171 bool *invalid_pch);
172 static bool find_file_in_dir (cpp_reader *pfile, _cpp_file *file,
173 bool *invalid_pch);
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
201 as <stdin>, open it.
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
206 successful.
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
218 ourselves. */
219 static bool
220 open_file (_cpp_file *file)
222 if (file->path[0] == '\0')
224 file->fd = 0;
225 set_stdin_to_binary_mode ();
227 else
228 file->fd = open (file->path, O_RDONLY | O_NOCTTY | O_BINARY, 0666);
230 if (file->fd != -1)
232 if (fstat (file->fd, &file->st) == 0)
234 if (!S_ISDIR (file->st.st_mode))
236 file->err_no = 0;
237 return true;
240 /* Ignore a directory and continue the search. The file we're
241 looking for may be elsewhere in the search path. */
242 errno = ENOENT;
245 close (file->fd);
246 file->fd = -1;
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
255 case too. */
256 if (stat (file->path, &file->st) == 0
257 && S_ISDIR (file->st.st_mode))
258 errno = ENOENT;
259 else
260 /* The call to stat may have reset errno. */
261 errno = EACCES;
263 #endif
264 else if (errno == ENOTDIR)
265 errno = ENOENT;
267 file->err_no = errno;
269 return false;
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. */
277 static bool
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;
282 size_t len, flen;
283 char *pchname;
284 struct stat st;
285 bool valid = false;
287 /* No PCH on <stdin> or if not requested. */
288 if (file->name[0] == '\0' || !pfile->cb.valid_pch)
289 return false;
291 /* If the file is not included as first include from either the toplevel
292 file or the command-line it is not a valid use of PCH. */
293 if (pfile->all_files
294 && pfile->all_files->next_file)
295 return false;
297 flen = strlen (path);
298 len = flen + sizeof (extension);
299 pchname = XNEWVEC (char, len);
300 memcpy (pchname, path, flen);
301 memcpy (pchname + flen, extension, sizeof (extension));
303 if (stat (pchname, &st) == 0)
305 DIR *pchdir;
306 struct dirent *d;
307 size_t dlen, plen = len;
309 if (!S_ISDIR (st.st_mode))
310 valid = validate_pch (pfile, file, pchname);
311 else if ((pchdir = opendir (pchname)) != NULL)
313 pchname[plen - 1] = '/';
314 while ((d = readdir (pchdir)) != NULL)
316 dlen = strlen (d->d_name) + 1;
317 if ((strcmp (d->d_name, ".") == 0)
318 || (strcmp (d->d_name, "..") == 0))
319 continue;
320 if (dlen + plen > len)
322 len += dlen + 64;
323 pchname = XRESIZEVEC (char, pchname, len);
325 memcpy (pchname + plen, d->d_name, dlen);
326 valid = validate_pch (pfile, file, pchname);
327 if (valid)
328 break;
330 closedir (pchdir);
332 if (!valid)
333 *invalid_pch = true;
336 if (valid)
337 file->pchname = pchname;
338 else
339 free (pchname);
341 return valid;
344 /* Try to open the path FILE->name appended to FILE->dir. This is
345 where remap and PCH intercept the file lookup process. Return true
346 if the file was found, whether or not the open was successful.
347 Set *INVALID_PCH to true if a PCH file is found but wasn't valid. */
349 static bool
350 find_file_in_dir (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
352 char *path;
354 if (CPP_OPTION (pfile, remap) && (path = remap_filename (pfile, file)))
356 else
357 if (file->dir->construct)
358 path = file->dir->construct (file->name, file->dir);
359 else
360 path = append_file_to_dir (file->name, file->dir);
362 if (path)
364 hashval_t hv = htab_hash_string (path);
365 char *copy;
366 void **pp;
368 if (htab_find_with_hash (pfile->nonexistent_file_hash, path, hv) != NULL)
370 file->err_no = ENOENT;
371 return false;
374 file->path = path;
375 if (pch_open_file (pfile, file, invalid_pch))
376 return true;
378 if (open_file (file))
379 return true;
381 if (file->err_no != ENOENT)
383 open_file_failed (pfile, file, 0);
384 return true;
387 /* We copy the path name onto an obstack partly so that we don't
388 leak the memory, but mostly so that we don't fragment the
389 heap. */
390 copy = (char *) obstack_copy0 (&pfile->nonexistent_file_ob, path,
391 strlen (path));
392 free (path);
393 pp = htab_find_slot_with_hash (pfile->nonexistent_file_hash,
394 copy, hv, INSERT);
395 *pp = copy;
397 file->path = file->name;
399 else
401 file->err_no = ENOENT;
402 file->path = NULL;
405 return false;
408 /* Return tue iff the missing_header callback found the given HEADER. */
409 static bool
410 search_path_exhausted (cpp_reader *pfile, const char *header, _cpp_file *file)
412 missing_header_cb func = pfile->cb.missing_header;
414 /* When the regular search path doesn't work, try context dependent
415 headers search paths. */
416 if (func
417 && file->dir == NULL)
419 if ((file->path = func (pfile, header, &file->dir)) != NULL)
421 if (open_file (file))
422 return true;
423 free ((void *)file->path);
425 file->path = file->name;
428 return false;
431 bool
432 _cpp_find_failed (_cpp_file *file)
434 return file->err_no != 0;
437 /* Given a filename FNAME search for such a file in the include path
438 starting from START_DIR. If FNAME is the empty string it is
439 interpreted as STDIN if START_DIR is PFILE->no_search_path.
441 If the file is not found in the file cache fall back to the O/S and
442 add the result to our cache.
444 If the file was not found in the filesystem, or there was an error
445 opening it, then ERR_NO is nonzero and FD is -1. If the file was
446 found, then ERR_NO is zero and FD could be -1 or an open file
447 descriptor. FD can be -1 if the file was found in the cache and
448 had previously been closed. To open it again pass the return value
449 to open_file().
451 _cpp_file *
452 _cpp_find_file (cpp_reader *pfile, const char *fname, cpp_dir *start_dir, bool fake, int angle_brackets)
454 struct file_hash_entry *entry, **hash_slot;
455 _cpp_file *file;
456 bool invalid_pch = false;
457 bool saw_bracket_include = false;
458 bool saw_quote_include = false;
459 struct cpp_dir *found_in_cache = NULL;
461 /* Ensure we get no confusion between cached files and directories. */
462 if (start_dir == NULL)
463 cpp_error (pfile, CPP_DL_ICE, "NULL directory in find_file");
465 hash_slot = (struct file_hash_entry **)
466 htab_find_slot_with_hash (pfile->file_hash, fname,
467 htab_hash_string (fname),
468 INSERT);
470 /* First check the cache before we resort to memory allocation. */
471 entry = search_cache (*hash_slot, start_dir);
472 if (entry)
473 return entry->u.file;
475 file = make_cpp_file (pfile, start_dir, fname);
477 /* Try each path in the include chain. */
478 for (; !fake ;)
480 if (find_file_in_dir (pfile, file, &invalid_pch))
481 break;
483 file->dir = file->dir->next;
484 if (file->dir == NULL)
486 if (search_path_exhausted (pfile, fname, file))
488 /* Although this file must not go in the cache, because
489 the file found might depend on things (like the current file)
490 that aren't represented in the cache, it still has to go in
491 the list of all files so that #import works. */
492 file->next_file = pfile->all_files;
493 pfile->all_files = file;
494 return file;
497 if (invalid_pch)
499 cpp_error (pfile, CPP_DL_ERROR,
500 "one or more PCH files were found, but they were invalid");
501 if (!cpp_get_options (pfile)->warn_invalid_pch)
502 cpp_error (pfile, CPP_DL_ERROR,
503 "use -Winvalid-pch for more information");
505 open_file_failed (pfile, file, angle_brackets);
506 break;
509 /* Only check the cache for the starting location (done above)
510 and the quote and bracket chain heads because there are no
511 other possible starting points for searches. */
512 if (file->dir == pfile->bracket_include)
513 saw_bracket_include = true;
514 else if (file->dir == pfile->quote_include)
515 saw_quote_include = true;
516 else
517 continue;
519 entry = search_cache (*hash_slot, file->dir);
520 if (entry)
522 found_in_cache = file->dir;
523 break;
527 if (entry)
529 /* Cache for START_DIR too, sharing the _cpp_file structure. */
530 free ((char *) file->name);
531 free (file);
532 file = entry->u.file;
534 else
536 /* This is a new file; put it in the list. */
537 file->next_file = pfile->all_files;
538 pfile->all_files = file;
541 /* Store this new result in the hash table. */
542 entry = new_file_hash_entry (pfile);
543 entry->next = *hash_slot;
544 entry->start_dir = start_dir;
545 entry->location = pfile->line_table->highest_location;
546 entry->u.file = file;
547 *hash_slot = entry;
549 /* If we passed the quote or bracket chain heads, cache them also.
550 This speeds up processing if there are lots of -I options. */
551 if (saw_bracket_include
552 && pfile->bracket_include != start_dir
553 && found_in_cache != pfile->bracket_include)
555 entry = new_file_hash_entry (pfile);
556 entry->next = *hash_slot;
557 entry->start_dir = pfile->bracket_include;
558 entry->location = pfile->line_table->highest_location;
559 entry->u.file = file;
560 *hash_slot = entry;
562 if (saw_quote_include
563 && pfile->quote_include != start_dir
564 && found_in_cache != pfile->quote_include)
566 entry = new_file_hash_entry (pfile);
567 entry->next = *hash_slot;
568 entry->start_dir = pfile->quote_include;
569 entry->location = pfile->line_table->highest_location;
570 entry->u.file = file;
571 *hash_slot = entry;
574 return file;
577 /* Read a file into FILE->buffer, returning true on success.
579 If FILE->fd is something weird, like a block device, we don't want
580 to read it at all. Don't even try to figure out what something is,
581 except for plain files and block devices, since there is no
582 reliable portable way of doing this.
584 FIXME: Flush file cache and try again if we run out of memory. */
585 static bool
586 read_file_guts (cpp_reader *pfile, _cpp_file *file)
588 ssize_t size, total, count;
589 uchar *buf;
590 bool regular;
592 if (S_ISBLK (file->st.st_mode))
594 cpp_error (pfile, CPP_DL_ERROR, "%s is a block device", file->path);
595 return false;
598 regular = S_ISREG (file->st.st_mode);
599 if (regular)
601 /* off_t might have a wider range than ssize_t - in other words,
602 the max size of a file might be bigger than the address
603 space. We can't handle a file that large. (Anyone with
604 a single source file bigger than 2GB needs to rethink
605 their coding style.) Some systems (e.g. AIX 4.1) define
606 SSIZE_MAX to be much smaller than the actual range of the
607 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
608 does not bite us. */
609 if (file->st.st_size > INTTYPE_MAXIMUM (ssize_t))
611 cpp_error (pfile, CPP_DL_ERROR, "%s is too large", file->path);
612 return false;
615 size = file->st.st_size;
617 else
618 /* 8 kilobytes is a sensible starting size. It ought to be bigger
619 than the kernel pipe buffer, and it's definitely bigger than
620 the majority of C source files. */
621 size = 8 * 1024;
623 buf = XNEWVEC (uchar, size + 1);
624 total = 0;
625 while ((count = read (file->fd, buf + total, size - total)) > 0)
627 total += count;
629 if (total == size)
631 if (regular)
632 break;
633 size *= 2;
634 buf = XRESIZEVEC (uchar, buf, size + 1);
638 if (count < 0)
640 cpp_errno (pfile, CPP_DL_ERROR, file->path);
641 return false;
644 if (regular && total != size && STAT_SIZE_RELIABLE (file->st))
645 cpp_error (pfile, CPP_DL_WARNING,
646 "%s is shorter than expected", file->path);
648 file->buffer = _cpp_convert_input (pfile,
649 CPP_OPTION (pfile, input_charset),
650 buf, size, total,
651 &file->buffer_start,
652 &file->st.st_size);
653 file->buffer_valid = true;
655 return true;
658 /* Convenience wrapper around read_file_guts that opens the file if
659 necessary and closes the file descriptor after reading. FILE must
660 have been passed through find_file() at some stage. */
661 static bool
662 read_file (cpp_reader *pfile, _cpp_file *file)
664 /* If we already have its contents in memory, succeed immediately. */
665 if (file->buffer_valid)
666 return true;
668 /* If an earlier read failed for some reason don't try again. */
669 if (file->dont_read || file->err_no)
670 return false;
672 if (file->fd == -1 && !open_file (file))
674 open_file_failed (pfile, file, 0);
675 return false;
678 file->dont_read = !read_file_guts (pfile, file);
679 close (file->fd);
680 file->fd = -1;
682 return !file->dont_read;
685 /* Returns TRUE if FILE's contents have been successfully placed in
686 FILE->buffer and the file should be stacked, otherwise false. */
687 static bool
688 should_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
690 _cpp_file *f;
692 /* Skip once-only files. */
693 if (file->once_only)
694 return false;
696 /* We must mark the file once-only if #import now, before header
697 guard checks. Otherwise, undefining the header guard might
698 cause the file to be re-stacked. */
699 if (import)
701 _cpp_mark_file_once_only (pfile, file);
703 /* Don't stack files that have been stacked before. */
704 if (file->stack_count)
705 return false;
708 /* Skip if the file had a header guard and the macro is defined.
709 PCH relies on this appearing before the PCH handler below. */
710 if (file->cmacro && file->cmacro->type == NT_MACRO)
711 return false;
713 /* Handle PCH files immediately; don't stack them. */
714 if (file->pchname)
716 pfile->cb.read_pch (pfile, file->pchname, file->fd, file->path);
717 file->fd = -1;
718 free ((void *) file->pchname);
719 file->pchname = NULL;
720 return false;
723 if (!read_file (pfile, file))
724 return false;
726 /* Check the file against the PCH file. This is done before
727 checking against files we've already seen, since it may save on
728 I/O. */
729 if (check_file_against_entries (pfile, file, import))
731 /* If this isn't a #import, but yet we can't include the file,
732 that means that it was #import-ed in the PCH file,
733 so we can never include it again. */
734 if (! import)
735 _cpp_mark_file_once_only (pfile, file);
736 return false;
739 /* Now we've read the file's contents, we can stack it if there
740 are no once-only files. */
741 if (!pfile->seen_once_only)
742 return true;
744 /* We may have read the file under a different name. Look
745 for likely candidates and compare file contents to be sure. */
746 for (f = pfile->all_files; f; f = f->next_file)
748 if (f == file)
749 continue;
751 if ((import || f->once_only)
752 && f->err_no == 0
753 && f->st.st_mtime == file->st.st_mtime
754 && f->st.st_size == file->st.st_size)
756 _cpp_file *ref_file;
757 bool same_file_p = false;
759 if (f->buffer && !f->buffer_valid)
761 /* We already have a buffer but it is not valid, because
762 the file is still stacked. Make a new one. */
763 ref_file = make_cpp_file (pfile, f->dir, f->name);
764 ref_file->path = f->path;
766 else
767 /* The file is not stacked anymore. We can reuse it. */
768 ref_file = f;
770 same_file_p = read_file (pfile, ref_file)
771 /* Size might have changed in read_file(). */
772 && ref_file->st.st_size == file->st.st_size
773 && !memcmp (ref_file->buffer,
774 file->buffer,
775 file->st.st_size);
777 if (f->buffer && !f->buffer_valid)
779 ref_file->path = 0;
780 destroy_cpp_file (ref_file);
783 if (same_file_p)
784 break;
788 return f == NULL;
791 /* Place the file referenced by FILE into a new buffer on the buffer
792 stack if possible. IMPORT is true if this stacking attempt is
793 because of a #import directive. Returns true if a buffer is
794 stacked. */
795 bool
796 _cpp_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
798 cpp_buffer *buffer;
799 int sysp;
801 if (!should_stack_file (pfile, file, import))
802 return false;
804 if (pfile->buffer == NULL || file->dir == NULL)
805 sysp = 0;
806 else
807 sysp = MAX (pfile->buffer->sysp, file->dir->sysp);
809 /* Add the file to the dependencies on its first inclusion. */
810 if (CPP_OPTION (pfile, deps.style) > !!sysp && !file->stack_count)
812 if (!file->main_file || !CPP_OPTION (pfile, deps.ignore_main_file))
813 deps_add_dep (pfile->deps, file->path);
816 /* Clear buffer_valid since _cpp_clean_line messes it up. */
817 file->buffer_valid = false;
818 file->stack_count++;
820 /* Stack the buffer. */
821 buffer = cpp_push_buffer (pfile, file->buffer, file->st.st_size,
822 CPP_OPTION (pfile, preprocessed)
823 && !CPP_OPTION (pfile, directives_only));
824 buffer->file = file;
825 buffer->sysp = sysp;
827 /* Initialize controlling macro state. */
828 pfile->mi_valid = true;
829 pfile->mi_cmacro = 0;
831 /* Generate the call back. */
832 _cpp_do_file_change (pfile, LC_ENTER, file->path, 1, sysp);
834 return true;
837 /* Mark FILE to be included once only. */
838 void
839 _cpp_mark_file_once_only (cpp_reader *pfile, _cpp_file *file)
841 pfile->seen_once_only = true;
842 file->once_only = true;
845 /* Return the directory from which searching for FNAME should start,
846 considering the directive TYPE and ANGLE_BRACKETS. If there is
847 nothing left in the path, returns NULL. */
848 static struct cpp_dir *
849 search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets,
850 enum include_type type)
852 cpp_dir *dir;
853 _cpp_file *file;
855 if (IS_ABSOLUTE_PATH (fname))
856 return &pfile->no_search_path;
858 /* pfile->buffer is NULL when processing an -include command-line flag. */
859 file = pfile->buffer == NULL ? pfile->main_file : pfile->buffer->file;
861 /* For #include_next, skip in the search path past the dir in which
862 the current file was found, but if it was found via an absolute
863 path use the normal search logic. */
864 if (type == IT_INCLUDE_NEXT && file->dir
865 && file->dir != &pfile->no_search_path)
866 dir = file->dir->next;
867 else if (angle_brackets)
868 dir = pfile->bracket_include;
869 else if (type == IT_CMDLINE)
870 /* -include and -imacros use the #include "" chain with the
871 preprocessor's cwd prepended. */
872 return make_cpp_dir (pfile, "./", false);
873 else if (pfile->quote_ignores_source_dir)
874 dir = pfile->quote_include;
875 else
876 return make_cpp_dir (pfile, dir_name_of_file (file),
877 pfile->buffer ? pfile->buffer->sysp : 0);
879 if (dir == NULL)
880 cpp_error (pfile, CPP_DL_ERROR,
881 "no include path in which to search for %s", fname);
883 return dir;
886 /* Strip the basename from the file's path. It ends with a slash if
887 of nonzero length. Note that this procedure also works for
888 <stdin>, which is represented by the empty string. */
889 static const char *
890 dir_name_of_file (_cpp_file *file)
892 if (!file->dir_name)
894 size_t len = lbasename (file->path) - file->path;
895 char *dir_name = XNEWVEC (char, len + 1);
897 memcpy (dir_name, file->path, len);
898 dir_name[len] = '\0';
899 file->dir_name = dir_name;
902 return file->dir_name;
905 /* Handles #include-family directives (distinguished by TYPE),
906 including HEADER, and the command line -imacros and -include.
907 Returns true if a buffer was stacked. */
908 bool
909 _cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets,
910 enum include_type type)
912 struct cpp_dir *dir;
913 _cpp_file *file;
915 dir = search_path_head (pfile, fname, angle_brackets, type);
916 if (!dir)
917 return false;
919 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets);
921 /* Compensate for the increment in linemap_add that occurs in
922 _cpp_stack_file. In the case of a normal #include, we're
923 currently at the start of the line *following* the #include. A
924 separate source_location for this location makes no sense (until
925 we do the LC_LEAVE), and complicates LAST_SOURCE_LINE_LOCATION.
926 This does not apply if we found a PCH file (in which case
927 linemap_add is not called) or we were included from the
928 command-line. */
929 if (file->pchname == NULL && file->err_no == 0 && type != IT_CMDLINE)
930 pfile->line_table->highest_location--;
932 return _cpp_stack_file (pfile, file, type == IT_IMPORT);
935 /* Could not open FILE. The complication is dependency output. */
936 static void
937 open_file_failed (cpp_reader *pfile, _cpp_file *file, int angle_brackets)
939 int sysp = pfile->line_table->highest_line > 1 && pfile->buffer ? pfile->buffer->sysp : 0;
940 bool print_dep = CPP_OPTION (pfile, deps.style) > (angle_brackets || !!sysp);
942 errno = file->err_no;
943 if (print_dep && CPP_OPTION (pfile, deps.missing_files) && errno == ENOENT)
945 deps_add_dep (pfile->deps, file->name);
946 /* If the preprocessor output (other than dependency information) is
947 being used, we must also flag an error. */
948 if (CPP_OPTION (pfile, deps.need_preprocessor_output))
949 cpp_errno (pfile, CPP_DL_FATAL, file->path);
951 else
953 /* If we are not outputting dependencies, or if we are and dependencies
954 were requested for this file, or if preprocessor output is needed
955 in addition to dependency information, this is an error.
957 Otherwise (outputting dependencies but not for this file, and not
958 using the preprocessor output), we can still produce correct output
959 so it's only a warning. */
960 if (CPP_OPTION (pfile, deps.style) == DEPS_NONE
961 || print_dep
962 || CPP_OPTION (pfile, deps.need_preprocessor_output))
963 cpp_errno (pfile, CPP_DL_FATAL, file->path);
964 else
965 cpp_errno (pfile, CPP_DL_WARNING, file->path);
969 /* Search in the chain beginning at HEAD for a file whose search path
970 started at START_DIR != NULL. */
971 static struct file_hash_entry *
972 search_cache (struct file_hash_entry *head, const cpp_dir *start_dir)
974 while (head && head->start_dir != start_dir)
975 head = head->next;
977 return head;
980 /* Allocate a new _cpp_file structure. */
981 static _cpp_file *
982 make_cpp_file (cpp_reader *pfile, cpp_dir *dir, const char *fname)
984 _cpp_file *file;
986 file = XCNEW (_cpp_file);
987 file->main_file = !pfile->buffer;
988 file->fd = -1;
989 file->dir = dir;
990 file->name = xstrdup (fname);
992 return file;
995 /* Release a _cpp_file structure. */
996 static void
997 destroy_cpp_file (_cpp_file *file)
999 if (file->buffer_start)
1000 free ((void *) file->buffer_start);
1001 free ((void *) file->name);
1002 free (file);
1005 /* Release all the files allocated by this reader. */
1006 static void
1007 destroy_all_cpp_files (cpp_reader *pfile)
1009 _cpp_file *iter = pfile->all_files;
1010 while (iter)
1012 _cpp_file *next = iter->next_file;
1013 destroy_cpp_file (iter);
1014 iter = next;
1018 /* A hash of directory names. The directory names are the path names
1019 of files which contain a #include "", the included file name is
1020 appended to this directories.
1022 To avoid duplicate entries we follow the convention that all
1023 non-empty directory names should end in a '/'. DIR_NAME must be
1024 stored in permanently allocated memory. */
1025 static cpp_dir *
1026 make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
1028 struct file_hash_entry *entry, **hash_slot;
1029 cpp_dir *dir;
1031 hash_slot = (struct file_hash_entry **)
1032 htab_find_slot_with_hash (pfile->dir_hash, dir_name,
1033 htab_hash_string (dir_name),
1034 INSERT);
1036 /* Have we already hashed this directory? */
1037 for (entry = *hash_slot; entry; entry = entry->next)
1038 if (entry->start_dir == NULL)
1039 return entry->u.dir;
1041 dir = XCNEW (cpp_dir);
1042 dir->next = pfile->quote_include;
1043 dir->name = (char *) dir_name;
1044 dir->len = strlen (dir_name);
1045 dir->sysp = sysp;
1046 dir->construct = 0;
1048 /* Store this new result in the hash table. */
1049 entry = new_file_hash_entry (pfile);
1050 entry->next = *hash_slot;
1051 entry->start_dir = NULL;
1052 entry->location = pfile->line_table->highest_location;
1053 entry->u.dir = dir;
1054 *hash_slot = entry;
1056 return dir;
1059 /* Create a new block of memory for file hash entries. */
1060 static void
1061 allocate_file_hash_entries (cpp_reader *pfile)
1063 struct file_hash_entry_pool *pool = XNEW (struct file_hash_entry_pool);
1064 pool->file_hash_entries_used = 0;
1065 pool->next = pfile->file_hash_entries;
1066 pfile->file_hash_entries = pool;
1069 /* Return a new file hash entry. */
1070 static struct file_hash_entry *
1071 new_file_hash_entry (cpp_reader *pfile)
1073 unsigned int idx;
1074 if (pfile->file_hash_entries->file_hash_entries_used == FILE_HASH_POOL_SIZE)
1075 allocate_file_hash_entries (pfile);
1077 idx = pfile->file_hash_entries->file_hash_entries_used++;
1078 return &pfile->file_hash_entries->pool[idx];
1081 /* Free the file hash entry pools. */
1082 static void
1083 free_file_hash_entries (cpp_reader *pfile)
1085 struct file_hash_entry_pool *iter = pfile->file_hash_entries;
1086 while (iter)
1088 struct file_hash_entry_pool *next = iter->next;
1089 free (iter);
1090 iter = next;
1094 /* Returns TRUE if a file FNAME has ever been successfully opened.
1095 This routine is not intended to correctly handle filenames aliased
1096 by links or redundant . or .. traversals etc. */
1097 bool
1098 cpp_included (cpp_reader *pfile, const char *fname)
1100 struct file_hash_entry *entry;
1102 entry = (struct file_hash_entry *)
1103 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1105 while (entry && (entry->start_dir == NULL || entry->u.file->err_no))
1106 entry = entry->next;
1108 return entry != NULL;
1111 /* Returns TRUE if a file FNAME has ever been successfully opened
1112 before LOCATION. This routine is not intended to correctly handle
1113 filenames aliased by links or redundant . or .. traversals etc. */
1114 bool
1115 cpp_included_before (cpp_reader *pfile, const char *fname,
1116 source_location location)
1118 struct file_hash_entry *entry;
1120 entry = (struct file_hash_entry *)
1121 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
1123 while (entry && (entry->start_dir == NULL || entry->u.file->err_no
1124 || entry->location > location))
1125 entry = entry->next;
1127 return entry != NULL;
1130 /* Calculate the hash value of a file hash entry P. */
1132 static hashval_t
1133 file_hash_hash (const void *p)
1135 struct file_hash_entry *entry = (struct file_hash_entry *) p;
1136 const char *hname;
1137 if (entry->start_dir)
1138 hname = entry->u.file->name;
1139 else
1140 hname = entry->u.dir->name;
1142 return htab_hash_string (hname);
1145 /* Compare a string Q against a file hash entry P. */
1146 static int
1147 file_hash_eq (const void *p, const void *q)
1149 struct file_hash_entry *entry = (struct file_hash_entry *) p;
1150 const char *fname = (const char *) q;
1151 const char *hname;
1153 if (entry->start_dir)
1154 hname = entry->u.file->name;
1155 else
1156 hname = entry->u.dir->name;
1158 return strcmp (hname, fname) == 0;
1161 /* Compare entries in the nonexistent file hash table. These are just
1162 strings. */
1163 static int
1164 nonexistent_file_hash_eq (const void *p, const void *q)
1166 return strcmp ((const char *) p, (const char *) q) == 0;
1169 /* Initialize everything in this source file. */
1170 void
1171 _cpp_init_files (cpp_reader *pfile)
1173 pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1174 NULL, xcalloc, free);
1175 pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1176 NULL, xcalloc, free);
1177 allocate_file_hash_entries (pfile);
1178 pfile->nonexistent_file_hash = htab_create_alloc (127, htab_hash_string,
1179 nonexistent_file_hash_eq,
1180 NULL, xcalloc, free);
1181 _obstack_begin (&pfile->nonexistent_file_ob, 0, 0,
1182 (void *(*) (long)) xmalloc,
1183 (void (*) (void *)) free);
1186 /* Finalize everything in this source file. */
1187 void
1188 _cpp_cleanup_files (cpp_reader *pfile)
1190 htab_delete (pfile->file_hash);
1191 htab_delete (pfile->dir_hash);
1192 htab_delete (pfile->nonexistent_file_hash);
1193 obstack_free (&pfile->nonexistent_file_ob, 0);
1194 free_file_hash_entries (pfile);
1195 destroy_all_cpp_files (pfile);
1198 /* Make the parser forget about files it has seen. This can be useful
1199 for resetting the parser to start another run. */
1200 void
1201 cpp_clear_file_cache (cpp_reader *pfile)
1203 _cpp_cleanup_files (pfile);
1204 pfile->file_hash_entries = NULL;
1205 pfile->all_files = NULL;
1206 _cpp_init_files (pfile);
1209 /* Enter a file name in the hash for the sake of cpp_included. */
1210 void
1211 _cpp_fake_include (cpp_reader *pfile, const char *fname)
1213 _cpp_find_file (pfile, fname, pfile->buffer->file->dir, true, 0);
1216 /* Not everyone who wants to set system-header-ness on a buffer can
1217 see the details of a buffer. This is an exported interface because
1218 fix-header needs it. */
1219 void
1220 cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
1222 int flags = 0;
1223 const struct line_maps *line_table = pfile->line_table;
1224 const struct line_map *map = &line_table->maps[line_table->used-1];
1226 /* 1 = system header, 2 = system header to be treated as C. */
1227 if (syshdr)
1228 flags = 1 + (externc != 0);
1229 pfile->buffer->sysp = flags;
1230 _cpp_do_file_change (pfile, LC_RENAME, map->to_file,
1231 SOURCE_LINE (map, pfile->line_table->highest_line), flags);
1234 /* Allow the client to change the current file. Used by the front end
1235 to achieve pseudo-file names like <built-in>.
1236 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
1237 void
1238 cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
1239 const char *new_name)
1241 _cpp_do_file_change (pfile, reason, new_name, 1, 0);
1244 struct report_missing_guard_data
1246 const char **paths;
1247 size_t count;
1250 /* Callback function for htab_traverse. */
1251 static int
1252 report_missing_guard (void **slot, void *d)
1254 struct file_hash_entry *entry = (struct file_hash_entry *) *slot;
1255 struct report_missing_guard_data *data
1256 = (struct report_missing_guard_data *) d;
1258 /* Skip directories. */
1259 if (entry->start_dir != NULL)
1261 _cpp_file *file = entry->u.file;
1263 /* We don't want MI guard advice for the main file. */
1264 if (file->cmacro == NULL && file->stack_count == 1 && !file->main_file)
1266 if (data->paths == NULL)
1268 data->paths = XCNEWVEC (const char *, data->count);
1269 data->count = 0;
1272 data->paths[data->count++] = file->path;
1276 /* Keep traversing the hash table. */
1277 return 1;
1280 /* Comparison function for qsort. */
1281 static int
1282 report_missing_guard_cmp (const void *p1, const void *p2)
1284 return strcmp (*(const char *const *) p1, *(const char *const *) p2);
1287 /* Report on all files that might benefit from a multiple include guard.
1288 Triggered by -H. */
1289 void
1290 _cpp_report_missing_guards (cpp_reader *pfile)
1292 struct report_missing_guard_data data;
1294 data.paths = NULL;
1295 data.count = htab_elements (pfile->file_hash);
1296 htab_traverse (pfile->file_hash, report_missing_guard, &data);
1298 if (data.paths != NULL)
1300 size_t i;
1302 /* Sort the paths to avoid outputting them in hash table
1303 order. */
1304 qsort (data.paths, data.count, sizeof (const char *),
1305 report_missing_guard_cmp);
1306 fputs (_("Multiple include guards may be useful for:\n"),
1307 stderr);
1308 for (i = 0; i < data.count; i++)
1310 fputs (data.paths[i], stderr);
1311 putc ('\n', stderr);
1313 free (data.paths);
1317 /* Locate HEADER, and determine whether it is newer than the current
1318 file. If it cannot be located or dated, return -1, if it is
1319 newer, return 1, otherwise 0. */
1321 _cpp_compare_file_date (cpp_reader *pfile, const char *fname,
1322 int angle_brackets)
1324 _cpp_file *file;
1325 struct cpp_dir *dir;
1327 dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
1328 if (!dir)
1329 return -1;
1331 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets);
1332 if (file->err_no)
1333 return -1;
1335 if (file->fd != -1)
1337 close (file->fd);
1338 file->fd = -1;
1341 return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
1344 /* Pushes the given file onto the buffer stack. Returns nonzero if
1345 successful. */
1346 bool
1347 cpp_push_include (cpp_reader *pfile, const char *fname)
1349 return _cpp_stack_include (pfile, fname, false, IT_CMDLINE);
1352 /* Do appropriate cleanup when a file INC's buffer is popped off the
1353 input stack. */
1354 void
1355 _cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file)
1357 /* Record the inclusion-preventing macro, which could be NULL
1358 meaning no controlling macro. */
1359 if (pfile->mi_valid && file->cmacro == NULL)
1360 file->cmacro = pfile->mi_cmacro;
1362 /* Invalidate control macros in the #including file. */
1363 pfile->mi_valid = false;
1365 if (file->buffer_start)
1367 free ((void *) file->buffer_start);
1368 file->buffer_start = NULL;
1369 file->buffer = NULL;
1370 file->buffer_valid = false;
1374 /* Inteface to file statistics record in _cpp_file structure. */
1375 struct stat *
1376 _cpp_get_file_stat (_cpp_file *file)
1378 return &file->st;
1381 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1382 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1383 directory of the including file.
1385 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1386 void
1387 cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
1388 int quote_ignores_source_dir)
1390 pfile->quote_include = quote;
1391 pfile->bracket_include = quote;
1392 pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1394 for (; quote; quote = quote->next)
1396 quote->name_map = NULL;
1397 quote->len = strlen (quote->name);
1398 if (quote == bracket)
1399 pfile->bracket_include = bracket;
1403 /* Append the file name to the directory to create the path, but don't
1404 turn / into // or // into ///; // may be a namespace escape. */
1405 static char *
1406 append_file_to_dir (const char *fname, cpp_dir *dir)
1408 size_t dlen, flen;
1409 char *path;
1411 dlen = dir->len;
1412 flen = strlen (fname);
1413 path = XNEWVEC (char, dlen + 1 + flen + 1);
1414 memcpy (path, dir->name, dlen);
1415 if (dlen && path[dlen - 1] != '/')
1416 path[dlen++] = '/';
1417 memcpy (&path[dlen], fname, flen + 1);
1419 return path;
1422 /* Read a space delimited string of unlimited length from a stdio
1423 file F. */
1424 static char *
1425 read_filename_string (int ch, FILE *f)
1427 char *alloc, *set;
1428 int len;
1430 len = 20;
1431 set = alloc = XNEWVEC (char, len + 1);
1432 if (! is_space (ch))
1434 *set++ = ch;
1435 while ((ch = getc (f)) != EOF && ! is_space (ch))
1437 if (set - alloc == len)
1439 len *= 2;
1440 alloc = XRESIZEVEC (char, alloc, len + 1);
1441 set = alloc + len / 2;
1443 *set++ = ch;
1446 *set = '\0';
1447 ungetc (ch, f);
1448 return alloc;
1451 /* Read the file name map file for DIR. */
1452 static void
1453 read_name_map (cpp_dir *dir)
1455 static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1456 char *name;
1457 FILE *f;
1458 size_t len, count = 0, room = 9;
1460 len = dir->len;
1461 name = (char *) alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
1462 memcpy (name, dir->name, len);
1463 if (len && name[len - 1] != '/')
1464 name[len++] = '/';
1465 strcpy (name + len, FILE_NAME_MAP_FILE);
1466 f = fopen (name, "r");
1468 dir->name_map = XNEWVEC (const char *, room);
1470 /* Silently return NULL if we cannot open. */
1471 if (f)
1473 int ch;
1475 while ((ch = getc (f)) != EOF)
1477 char *to;
1479 if (is_space (ch))
1480 continue;
1482 if (count + 2 > room)
1484 room += 8;
1485 dir->name_map = XRESIZEVEC (const char *, dir->name_map, room);
1488 dir->name_map[count] = read_filename_string (ch, f);
1489 while ((ch = getc (f)) != EOF && is_hspace (ch))
1492 to = read_filename_string (ch, f);
1493 if (IS_ABSOLUTE_PATH (to))
1494 dir->name_map[count + 1] = to;
1495 else
1497 dir->name_map[count + 1] = append_file_to_dir (to, dir);
1498 free (to);
1501 count += 2;
1502 while ((ch = getc (f)) != '\n')
1503 if (ch == EOF)
1504 break;
1507 fclose (f);
1510 /* Terminate the list of maps. */
1511 dir->name_map[count] = NULL;
1514 /* Remap a FILE's name based on the file_name_map, if any, for
1515 FILE->dir. If the file name has any directory separators,
1516 recursively check those directories too. */
1517 static char *
1518 remap_filename (cpp_reader *pfile, _cpp_file *file)
1520 const char *fname, *p;
1521 char *new_dir;
1522 cpp_dir *dir;
1523 size_t index, len;
1525 dir = file->dir;
1526 fname = file->name;
1528 for (;;)
1530 if (!dir->name_map)
1531 read_name_map (dir);
1533 for (index = 0; dir->name_map[index]; index += 2)
1534 if (!strcmp (dir->name_map[index], fname))
1535 return xstrdup (dir->name_map[index + 1]);
1537 p = strchr (fname, '/');
1538 if (!p || p == fname)
1539 return NULL;
1541 len = dir->len + (p - fname + 1);
1542 new_dir = XNEWVEC (char, len + 1);
1543 memcpy (new_dir, dir->name, dir->len);
1544 memcpy (new_dir + dir->len, fname, p - fname + 1);
1545 new_dir[len] = '\0';
1547 dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1548 fname = p + 1;
1552 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1553 static bool
1554 validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1556 const char *saved_path = file->path;
1557 bool valid = false;
1559 file->path = pchname;
1560 if (open_file (file))
1562 valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1564 if (!valid)
1566 close (file->fd);
1567 file->fd = -1;
1570 if (CPP_OPTION (pfile, print_include_names))
1572 unsigned int i;
1573 for (i = 1; i < pfile->line_table->depth; i++)
1574 putc ('.', stderr);
1575 fprintf (stderr, "%c %s\n",
1576 valid ? '!' : 'x', pchname);
1580 file->path = saved_path;
1581 return valid;
1584 /* Get the path associated with the _cpp_file F. The path includes
1585 the base name from the include directive and the directory it was
1586 found in via the search path. */
1588 const char *
1589 cpp_get_path (struct _cpp_file *f)
1591 return f->path;
1594 /* Get the directory associated with the _cpp_file F. */
1596 cpp_dir *
1597 cpp_get_dir (struct _cpp_file *f)
1599 return f->dir;
1602 /* Get the cpp_buffer currently associated with the cpp_reader
1603 PFILE. */
1605 cpp_buffer *
1606 cpp_get_buffer (cpp_reader *pfile)
1608 return pfile->buffer;
1611 /* Get the _cpp_file associated with the cpp_buffer B. */
1613 _cpp_file *
1614 cpp_get_file (cpp_buffer *b)
1616 return b->file;
1619 /* Get the previous cpp_buffer given a cpp_buffer B. The previous
1620 buffer is the buffer that included the given buffer. */
1622 cpp_buffer *
1623 cpp_get_prev (cpp_buffer *b)
1625 return b->prev;
1628 /* This data structure holds the list of header files that were seen
1629 while the PCH was being built. The 'entries' field is kept sorted
1630 in memcmp() order; yes, this means that on little-endian systems,
1631 it's sorted initially by the least-significant byte of 'size', but
1632 that's OK. The code does rely on having entries with the same size
1633 next to each other. */
1635 struct pchf_entry {
1636 /* The size of this file. This is used to save running a MD5 checksum
1637 if the sizes don't match. */
1638 off_t size;
1639 /* The MD5 checksum of this file. */
1640 unsigned char sum[16];
1641 /* Is this file to be included only once? */
1642 bool once_only;
1645 struct pchf_data {
1646 /* Number of pchf_entry structures. */
1647 size_t count;
1649 /* Are there any values with once_only set?
1650 This is used as an optimisation, it means we don't have to search
1651 the structure if we're processing a regular #include. */
1652 bool have_once_only;
1654 struct pchf_entry entries[1];
1657 static struct pchf_data *pchf;
1659 /* A qsort ordering function for pchf_entry structures. */
1661 static int
1662 pchf_save_compare (const void *e1, const void *e2)
1664 return memcmp (e1, e2, sizeof (struct pchf_entry));
1667 /* Create and write to F a pchf_data structure. */
1669 bool
1670 _cpp_save_file_entries (cpp_reader *pfile, FILE *fp)
1672 size_t count = 0;
1673 struct pchf_data *result;
1674 size_t result_size;
1675 _cpp_file *f;
1677 for (f = pfile->all_files; f; f = f->next_file)
1678 ++count;
1680 result_size = (sizeof (struct pchf_data)
1681 + sizeof (struct pchf_entry) * (count - 1));
1682 result = XCNEWVAR (struct pchf_data, result_size);
1684 result->count = 0;
1685 result->have_once_only = false;
1687 for (f = pfile->all_files; f; f = f->next_file)
1689 size_t count;
1691 /* This should probably never happen, since if a read error occurred
1692 the PCH file shouldn't be written... */
1693 if (f->dont_read || f->err_no)
1694 continue;
1696 if (f->stack_count == 0)
1697 continue;
1699 count = result->count++;
1701 result->entries[count].once_only = f->once_only;
1702 /* |= is avoided in the next line because of an HP C compiler bug */
1703 result->have_once_only = result->have_once_only | f->once_only;
1704 if (f->buffer_valid)
1705 md5_buffer ((const char *)f->buffer,
1706 f->st.st_size, result->entries[count].sum);
1707 else
1709 FILE *ff;
1710 int oldfd = f->fd;
1712 if (!open_file (f))
1714 open_file_failed (pfile, f, 0);
1715 return false;
1717 ff = fdopen (f->fd, "rb");
1718 md5_stream (ff, result->entries[count].sum);
1719 fclose (ff);
1720 f->fd = oldfd;
1722 result->entries[count].size = f->st.st_size;
1725 result_size = (sizeof (struct pchf_data)
1726 + sizeof (struct pchf_entry) * (result->count - 1));
1728 qsort (result->entries, result->count, sizeof (struct pchf_entry),
1729 pchf_save_compare);
1731 return fwrite (result, result_size, 1, fp) == 1;
1734 /* Read the pchf_data structure from F. */
1736 bool
1737 _cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f)
1739 struct pchf_data d;
1741 if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f)
1742 != 1)
1743 return false;
1745 pchf = XNEWVAR (struct pchf_data, sizeof (struct pchf_data)
1746 + sizeof (struct pchf_entry) * (d.count - 1));
1747 memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry));
1748 if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f)
1749 != d.count)
1750 return false;
1751 return true;
1754 /* The parameters for pchf_compare. */
1756 struct pchf_compare_data
1758 /* The size of the file we're looking for. */
1759 off_t size;
1761 /* The MD5 checksum of the file, if it's been computed. */
1762 unsigned char sum[16];
1764 /* Is SUM valid? */
1765 bool sum_computed;
1767 /* Do we need to worry about entries that don't have ONCE_ONLY set? */
1768 bool check_included;
1770 /* The file that we're searching for. */
1771 _cpp_file *f;
1774 /* bsearch comparison function; look for D_P in E_P. */
1776 static int
1777 pchf_compare (const void *d_p, const void *e_p)
1779 const struct pchf_entry *e = (const struct pchf_entry *)e_p;
1780 struct pchf_compare_data *d = (struct pchf_compare_data *)d_p;
1781 int result;
1783 result = memcmp (&d->size, &e->size, sizeof (off_t));
1784 if (result != 0)
1785 return result;
1787 if (! d->sum_computed)
1789 _cpp_file *const f = d->f;
1791 md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum);
1792 d->sum_computed = true;
1795 result = memcmp (d->sum, e->sum, 16);
1796 if (result != 0)
1797 return result;
1799 if (d->check_included || e->once_only)
1800 return 0;
1801 else
1802 return 1;
1805 /* Check that F is not in a list read from a PCH file (if any).
1806 Assumes that f->buffer_valid is true. Return TRUE if the file
1807 should not be read. */
1809 static bool
1810 check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED,
1811 _cpp_file *f,
1812 bool check_included)
1814 struct pchf_compare_data d;
1816 if (pchf == NULL
1817 || (! check_included && ! pchf->have_once_only))
1818 return false;
1820 d.size = f->st.st_size;
1821 d.sum_computed = false;
1822 d.f = f;
1823 d.check_included = check_included;
1824 return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
1825 pchf_compare) != NULL;