Daily bump.
[official-gcc.git] / libcpp / files.c
blob833421805900c1bba0c77774c4787ab9b6a065f8
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 Free Software Foundation, Inc.
4 Written by Per Bothner, 1994.
5 Based on CCCP program by Paul Rubin, June 1986
6 Adapted to ANSI C, Richard Stallman, Jan 1987
7 Split out of cpplib.c, Zack Weinberg, Oct 1998
8 Reimplemented, Neil Booth, Jul 2003
10 This program is free software; you can redistribute it and/or modify it
11 under the terms of the GNU General Public License as published by the
12 Free Software Foundation; either version 2, or (at your option) any
13 later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
24 #include "config.h"
25 #include "system.h"
26 #include "cpplib.h"
27 #include "internal.h"
28 #include "mkdeps.h"
29 #include "hashtab.h"
30 #include "md5.h"
31 #include <dirent.h>
33 /* Variable length record files on VMS will have a stat size that includes
34 record control characters that won't be included in the read size. */
35 #ifdef VMS
36 # define FAB_C_VAR 2 /* variable length records (see Starlet fabdef.h) */
37 # define STAT_SIZE_RELIABLE(ST) ((ST).st_fab_rfm != FAB_C_VAR)
38 #else
39 # define STAT_SIZE_RELIABLE(ST) true
40 #endif
42 #ifdef __DJGPP__
43 #include <io.h>
44 /* For DJGPP redirected input is opened in text mode. */
45 # define set_stdin_to_binary_mode() \
46 if (! isatty (0)) setmode (0, O_BINARY)
47 #else
48 # define set_stdin_to_binary_mode() /* Nothing */
49 #endif
51 /* This structure represents a file searched for by CPP, whether it
52 exists or not. An instance may be pointed to by more than one
53 file_hash_entry; at present no reference count is kept. */
54 struct _cpp_file
56 /* Filename as given to #include or command line switch. */
57 const char *name;
59 /* The full path used to find the file. */
60 const char *path;
62 /* The full path of the pch file. */
63 const char *pchname;
65 /* The file's path with the basename stripped. NULL if it hasn't
66 been calculated yet. */
67 const char *dir_name;
69 /* Chain through all files. */
70 struct _cpp_file *next_file;
72 /* The contents of NAME after calling read_file(). */
73 const uchar *buffer;
75 /* The macro, if any, preventing re-inclusion. */
76 const cpp_hashnode *cmacro;
78 /* The directory in the search path where FILE was found. Used for
79 #include_next and determining whether a header is a system
80 header. */
81 cpp_dir *dir;
83 /* As filled in by stat(2) for the file. */
84 struct stat st;
86 /* File descriptor. Invalid if -1, otherwise open. */
87 int fd;
89 /* Zero if this file was successfully opened and stat()-ed,
90 otherwise errno obtained from failure. */
91 int err_no;
93 /* Number of times the file has been stacked for preprocessing. */
94 unsigned short stack_count;
96 /* If opened with #import or contains #pragma once. */
97 bool once_only;
99 /* If read() failed before. */
100 bool dont_read;
102 /* If this file is the main file. */
103 bool main_file;
105 /* If BUFFER above contains the true contents of the file. */
106 bool buffer_valid;
108 /* File is a PCH (on return from find_include_file). */
109 bool pch;
112 /* A singly-linked list for all searches for a given file name, with
113 its head pointed to by a slot in FILE_HASH. The file name is what
114 appeared between the quotes in a #include directive; it can be
115 determined implicitly from the hash table location or explicitly
116 from FILE->name.
118 FILE is a structure containing details about the file that was
119 found with that search, or details of how the search failed.
121 START_DIR is the starting location of the search in the include
122 chain. The current directories for "" includes are also hashed in
123 the hash table and therefore unique. Files that are looked up
124 without using a search path, such as absolute filenames and file
125 names from the command line share a special starting directory so
126 they don't cause cache hits with normal include-chain lookups.
128 If START_DIR is NULL then the entry is for a directory, not a file,
129 and the directory is in DIR. Since the starting point in a file
130 lookup chain is never NULL, this means that simple pointer
131 comparisons against START_DIR can be made to determine cache hits
132 in file lookups.
134 If a cache lookup fails because of e.g. an extra "./" in the path,
135 then nothing will break. It is just less efficient as CPP will
136 have to do more work re-preprocessing the file, and/or comparing
137 its contents against earlier once-only files.
139 struct file_hash_entry
141 struct file_hash_entry *next;
142 cpp_dir *start_dir;
143 union
145 _cpp_file *file;
146 cpp_dir *dir;
147 } u;
150 static bool open_file (_cpp_file *file);
151 static bool pch_open_file (cpp_reader *pfile, _cpp_file *file,
152 bool *invalid_pch);
153 static bool find_file_in_dir (cpp_reader *pfile, _cpp_file *file,
154 bool *invalid_pch);
155 static bool read_file_guts (cpp_reader *pfile, _cpp_file *file);
156 static bool read_file (cpp_reader *pfile, _cpp_file *file);
157 static bool should_stack_file (cpp_reader *, _cpp_file *file, bool import);
158 static struct cpp_dir *search_path_head (cpp_reader *, const char *fname,
159 int angle_brackets, enum include_type);
160 static const char *dir_name_of_file (_cpp_file *file);
161 static void open_file_failed (cpp_reader *pfile, _cpp_file *file, int);
162 static struct file_hash_entry *search_cache (struct file_hash_entry *head,
163 const cpp_dir *start_dir);
164 static _cpp_file *make_cpp_file (cpp_reader *, cpp_dir *, const char *fname);
165 static void destroy_cpp_file (_cpp_file *);
166 static cpp_dir *make_cpp_dir (cpp_reader *, const char *dir_name, int sysp);
167 static void allocate_file_hash_entries (cpp_reader *pfile);
168 static struct file_hash_entry *new_file_hash_entry (cpp_reader *pfile);
169 static int report_missing_guard (void **slot, void *b);
170 static hashval_t file_hash_hash (const void *p);
171 static int file_hash_eq (const void *p, const void *q);
172 static char *read_filename_string (int ch, FILE *f);
173 static void read_name_map (cpp_dir *dir);
174 static char *remap_filename (cpp_reader *pfile, _cpp_file *file);
175 static char *append_file_to_dir (const char *fname, cpp_dir *dir);
176 static bool validate_pch (cpp_reader *, _cpp_file *file, const char *pchname);
177 static int pchf_save_compare (const void *e1, const void *e2);
178 static int pchf_compare (const void *d_p, const void *e_p);
179 static bool check_file_against_entries (cpp_reader *, _cpp_file *, bool);
181 /* Given a filename in FILE->PATH, with the empty string interpreted
182 as <stdin>, open it.
184 On success FILE contains an open file descriptor and stat
185 information for the file. On failure the file descriptor is -1 and
186 the appropriate errno is also stored in FILE. Returns TRUE iff
187 successful.
189 We used to open files in nonblocking mode, but that caused more
190 problems than it solved. Do take care not to acquire a controlling
191 terminal by mistake (this can't happen on sane systems, but
192 paranoia is a virtue).
194 Use the three-argument form of open even though we aren't
195 specifying O_CREAT, to defend against broken system headers.
197 O_BINARY tells some runtime libraries (notably DJGPP) not to do
198 newline translation; we can handle DOS line breaks just fine
199 ourselves. */
200 static bool
201 open_file (_cpp_file *file)
203 if (file->path[0] == '\0')
205 file->fd = 0;
206 set_stdin_to_binary_mode ();
208 else
209 file->fd = open (file->path, O_RDONLY | O_NOCTTY | O_BINARY, 0666);
211 if (file->fd != -1)
213 if (fstat (file->fd, &file->st) == 0)
215 if (!S_ISDIR (file->st.st_mode))
217 file->err_no = 0;
218 return true;
221 /* Ignore a directory and continue the search. The file we're
222 looking for may be elsewhere in the search path. */
223 errno = ENOENT;
226 close (file->fd);
227 file->fd = -1;
229 else if (errno == ENOTDIR)
230 errno = ENOENT;
232 file->err_no = errno;
234 return false;
237 /* Temporary PCH intercept of opening a file. Try to find a PCH file
238 based on FILE->name and FILE->dir, and test those found for
239 validity using PFILE->cb.valid_pch. Return true iff a valid file is
240 found. Set *INVALID_PCH if a PCH file is found but wasn't valid. */
242 static bool
243 pch_open_file (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
245 static const char extension[] = ".gch";
246 const char *path = file->path;
247 size_t len, flen;
248 char *pchname;
249 struct stat st;
250 bool valid = false;
252 /* No PCH on <stdin> or if not requested. */
253 if (file->name[0] == '\0' || !pfile->cb.valid_pch)
254 return false;
256 flen = strlen (path);
257 len = flen + sizeof (extension);
258 pchname = XNEWVEC (char, len);
259 memcpy (pchname, path, flen);
260 memcpy (pchname + flen, extension, sizeof (extension));
262 if (stat (pchname, &st) == 0)
264 DIR *pchdir;
265 struct dirent *d;
266 size_t dlen, plen = len;
268 if (!S_ISDIR (st.st_mode))
269 valid = validate_pch (pfile, file, pchname);
270 else if ((pchdir = opendir (pchname)) != NULL)
272 pchname[plen - 1] = '/';
273 while ((d = readdir (pchdir)) != NULL)
275 dlen = strlen (d->d_name) + 1;
276 if ((strcmp (d->d_name, ".") == 0)
277 || (strcmp (d->d_name, "..") == 0))
278 continue;
279 if (dlen + plen > len)
281 len += dlen + 64;
282 pchname = XRESIZEVEC (char, pchname, len);
284 memcpy (pchname + plen, d->d_name, dlen);
285 valid = validate_pch (pfile, file, pchname);
286 if (valid)
287 break;
289 closedir (pchdir);
291 if (valid)
292 file->pch = true;
293 else
294 *invalid_pch = true;
297 if (valid)
298 file->pchname = pchname;
299 else
300 free (pchname);
302 return valid;
305 /* Try to open the path FILE->name appended to FILE->dir. This is
306 where remap and PCH intercept the file lookup process. Return true
307 if the file was found, whether or not the open was successful.
308 Set *INVALID_PCH to true if a PCH file is found but wasn't valid. */
310 static bool
311 find_file_in_dir (cpp_reader *pfile, _cpp_file *file, bool *invalid_pch)
313 char *path;
315 if (CPP_OPTION (pfile, remap) && (path = remap_filename (pfile, file)))
317 else
318 if (file->dir->construct)
319 path = file->dir->construct (file->name, file->dir);
320 else
321 path = append_file_to_dir (file->name, file->dir);
323 if (path)
325 file->path = path;
326 if (pch_open_file (pfile, file, invalid_pch))
327 return true;
329 if (open_file (file))
330 return true;
332 if (file->err_no != ENOENT)
334 open_file_failed (pfile, file, 0);
335 return true;
338 free (path);
339 file->path = file->name;
341 else
343 file->err_no = ENOENT;
344 file->path = NULL;
347 return false;
350 /* Return tue iff the missing_header callback found the given HEADER. */
351 static bool
352 search_path_exhausted (cpp_reader *pfile, const char *header, _cpp_file *file)
354 missing_header_cb func = pfile->cb.missing_header;
356 /* When the regular search path doesn't work, try context dependent
357 headers search paths. */
358 if (func
359 && file->dir == NULL)
361 if ((file->path = func (pfile, header, &file->dir)) != NULL)
363 if (open_file (file))
364 return true;
365 free ((void *)file->path);
367 file->path = file->name;
370 return false;
373 bool
374 _cpp_find_failed (_cpp_file *file)
376 return file->err_no != 0;
379 /* Given a filename FNAME search for such a file in the include path
380 starting from START_DIR. If FNAME is the empty string it is
381 interpreted as STDIN if START_DIR is PFILE->no_search_path.
383 If the file is not found in the file cache fall back to the O/S and
384 add the result to our cache.
386 If the file was not found in the filesystem, or there was an error
387 opening it, then ERR_NO is nonzero and FD is -1. If the file was
388 found, then ERR_NO is zero and FD could be -1 or an open file
389 descriptor. FD can be -1 if the file was found in the cache and
390 had previously been closed. To open it again pass the return value
391 to open_file().
393 _cpp_file *
394 _cpp_find_file (cpp_reader *pfile, const char *fname, cpp_dir *start_dir, bool fake, int angle_brackets)
396 struct file_hash_entry *entry, **hash_slot;
397 _cpp_file *file;
398 bool invalid_pch = false;
400 /* Ensure we get no confusion between cached files and directories. */
401 if (start_dir == NULL)
402 cpp_error (pfile, CPP_DL_ICE, "NULL directory in find_file");
404 hash_slot = (struct file_hash_entry **)
405 htab_find_slot_with_hash (pfile->file_hash, fname,
406 htab_hash_string (fname),
407 INSERT);
409 /* First check the cache before we resort to memory allocation. */
410 entry = search_cache (*hash_slot, start_dir);
411 if (entry)
412 return entry->u.file;
414 file = make_cpp_file (pfile, start_dir, fname);
416 /* Try each path in the include chain. */
417 for (; !fake ;)
419 if (find_file_in_dir (pfile, file, &invalid_pch))
420 break;
422 file->dir = file->dir->next;
423 if (file->dir == NULL)
425 if (search_path_exhausted (pfile, fname, file))
427 /* Although this file must not go in the cache, because
428 the file found might depend on things (like the current file)
429 that aren't represented in the cache, it still has to go in
430 the list of all files so that #import works. */
431 file->next_file = pfile->all_files;
432 pfile->all_files = file;
433 return file;
436 open_file_failed (pfile, file, angle_brackets);
437 if (invalid_pch)
439 cpp_error (pfile, CPP_DL_ERROR,
440 "one or more PCH files were found, but they were invalid");
441 if (!cpp_get_options (pfile)->warn_invalid_pch)
442 cpp_error (pfile, CPP_DL_ERROR,
443 "use -Winvalid-pch for more information");
445 break;
448 /* Only check the cache for the starting location (done above)
449 and the quote and bracket chain heads because there are no
450 other possible starting points for searches. */
451 if (file->dir != pfile->bracket_include
452 && file->dir != pfile->quote_include)
453 continue;
455 entry = search_cache (*hash_slot, file->dir);
456 if (entry)
457 break;
460 if (entry)
462 /* Cache for START_DIR too, sharing the _cpp_file structure. */
463 free ((char *) file->name);
464 free (file);
465 file = entry->u.file;
467 else
469 /* This is a new file; put it in the list. */
470 file->next_file = pfile->all_files;
471 pfile->all_files = file;
474 /* Store this new result in the hash table. */
475 entry = new_file_hash_entry (pfile);
476 entry->next = *hash_slot;
477 entry->start_dir = start_dir;
478 entry->u.file = file;
479 *hash_slot = entry;
481 return file;
484 /* Read a file into FILE->buffer, returning true on success.
486 If FILE->fd is something weird, like a block device, we don't want
487 to read it at all. Don't even try to figure out what something is,
488 except for plain files and block devices, since there is no
489 reliable portable way of doing this.
491 FIXME: Flush file cache and try again if we run out of memory. */
492 static bool
493 read_file_guts (cpp_reader *pfile, _cpp_file *file)
495 ssize_t size, total, count;
496 uchar *buf;
497 bool regular;
499 if (S_ISBLK (file->st.st_mode))
501 cpp_error (pfile, CPP_DL_ERROR, "%s is a block device", file->path);
502 return false;
505 regular = S_ISREG (file->st.st_mode);
506 if (regular)
508 /* off_t might have a wider range than ssize_t - in other words,
509 the max size of a file might be bigger than the address
510 space. We can't handle a file that large. (Anyone with
511 a single source file bigger than 2GB needs to rethink
512 their coding style.) Some systems (e.g. AIX 4.1) define
513 SSIZE_MAX to be much smaller than the actual range of the
514 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
515 does not bite us. */
516 if (file->st.st_size > INTTYPE_MAXIMUM (ssize_t))
518 cpp_error (pfile, CPP_DL_ERROR, "%s is too large", file->path);
519 return false;
522 size = file->st.st_size;
524 else
525 /* 8 kilobytes is a sensible starting size. It ought to be bigger
526 than the kernel pipe buffer, and it's definitely bigger than
527 the majority of C source files. */
528 size = 8 * 1024;
530 buf = XNEWVEC (uchar, size + 1);
531 total = 0;
532 while ((count = read (file->fd, buf + total, size - total)) > 0)
534 total += count;
536 if (total == size)
538 if (regular)
539 break;
540 size *= 2;
541 buf = XRESIZEVEC (uchar, buf, size + 1);
545 if (count < 0)
547 cpp_errno (pfile, CPP_DL_ERROR, file->path);
548 return false;
551 if (regular && total != size && STAT_SIZE_RELIABLE (file->st))
552 cpp_error (pfile, CPP_DL_WARNING,
553 "%s is shorter than expected", file->path);
555 file->buffer = _cpp_convert_input (pfile, CPP_OPTION (pfile, input_charset),
556 buf, size, total, &file->st.st_size);
557 file->buffer_valid = true;
559 return true;
562 /* Convenience wrapper around read_file_guts that opens the file if
563 necessary and closes the file descriptor after reading. FILE must
564 have been passed through find_file() at some stage. */
565 static bool
566 read_file (cpp_reader *pfile, _cpp_file *file)
568 /* If we already have its contents in memory, succeed immediately. */
569 if (file->buffer_valid)
570 return true;
572 /* If an earlier read failed for some reason don't try again. */
573 if (file->dont_read || file->err_no)
574 return false;
576 if (file->fd == -1 && !open_file (file))
578 open_file_failed (pfile, file, 0);
579 return false;
582 file->dont_read = !read_file_guts (pfile, file);
583 close (file->fd);
584 file->fd = -1;
586 return !file->dont_read;
589 /* Returns TRUE if FILE's contents have been successfully placed in
590 FILE->buffer and the file should be stacked, otherwise false. */
591 static bool
592 should_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
594 _cpp_file *f;
596 /* Skip once-only files. */
597 if (file->once_only)
598 return false;
600 /* We must mark the file once-only if #import now, before header
601 guard checks. Otherwise, undefining the header guard might
602 cause the file to be re-stacked. */
603 if (import)
605 _cpp_mark_file_once_only (pfile, file);
607 /* Don't stack files that have been stacked before. */
608 if (file->stack_count)
609 return false;
612 /* Skip if the file had a header guard and the macro is defined.
613 PCH relies on this appearing before the PCH handler below. */
614 if (file->cmacro && file->cmacro->type == NT_MACRO)
615 return false;
617 /* Handle PCH files immediately; don't stack them. */
618 if (file->pch)
620 pfile->cb.read_pch (pfile, file->pchname, file->fd, file->path);
621 close (file->fd);
622 file->fd = -1;
623 return false;
626 if (!read_file (pfile, file))
627 return false;
629 /* Check the file against the PCH file. This is done before
630 checking against files we've already seen, since it may save on
631 I/O. */
632 if (check_file_against_entries (pfile, file, import))
634 /* If this isn't a #import, but yet we can't include the file,
635 that means that it was #import-ed in the PCH file,
636 so we can never include it again. */
637 if (! import)
638 _cpp_mark_file_once_only (pfile, file);
639 return false;
642 /* Now we've read the file's contents, we can stack it if there
643 are no once-only files. */
644 if (!pfile->seen_once_only)
645 return true;
647 /* We may have read the file under a different name. Look
648 for likely candidates and compare file contents to be sure. */
649 for (f = pfile->all_files; f; f = f->next_file)
651 if (f == file)
652 continue;
654 if ((import || f->once_only)
655 && f->err_no == 0
656 && f->st.st_mtime == file->st.st_mtime
657 && f->st.st_size == file->st.st_size)
659 _cpp_file *ref_file;
660 bool same_file_p = false;
662 if (f->buffer && !f->buffer_valid)
664 /* We already have a buffer but it is not valid, because
665 the file is still stacked. Make a new one. */
666 ref_file = make_cpp_file (pfile, f->dir, f->name);
667 ref_file->path = f->path;
669 else
670 /* The file is not stacked anymore. We can reuse it. */
671 ref_file = f;
673 same_file_p = read_file (pfile, ref_file)
674 /* Size might have changed in read_file(). */
675 && ref_file->st.st_size == file->st.st_size
676 && !memcmp (ref_file->buffer,
677 file->buffer,
678 file->st.st_size);
680 if (f->buffer && !f->buffer_valid)
682 ref_file->path = 0;
683 destroy_cpp_file (ref_file);
686 if (same_file_p)
687 break;
691 return f == NULL;
694 /* Place the file referenced by FILE into a new buffer on the buffer
695 stack if possible. IMPORT is true if this stacking attempt is
696 because of a #import directive. Returns true if a buffer is
697 stacked. */
698 bool
699 _cpp_stack_file (cpp_reader *pfile, _cpp_file *file, bool import)
701 cpp_buffer *buffer;
702 int sysp;
704 if (!should_stack_file (pfile, file, import))
705 return false;
707 if (pfile->buffer == NULL || file->dir == NULL)
708 sysp = 0;
709 else
710 sysp = MAX (pfile->buffer->sysp, file->dir->sysp);
712 /* Add the file to the dependencies on its first inclusion. */
713 if (CPP_OPTION (pfile, deps.style) > !!sysp && !file->stack_count)
715 if (!file->main_file || !CPP_OPTION (pfile, deps.ignore_main_file))
716 deps_add_dep (pfile->deps, file->path);
719 /* Clear buffer_valid since _cpp_clean_line messes it up. */
720 file->buffer_valid = false;
721 file->stack_count++;
723 /* Stack the buffer. */
724 buffer = cpp_push_buffer (pfile, file->buffer, file->st.st_size,
725 CPP_OPTION (pfile, preprocessed));
726 buffer->file = file;
727 buffer->sysp = sysp;
729 /* Initialize controlling macro state. */
730 pfile->mi_valid = true;
731 pfile->mi_cmacro = 0;
733 /* Generate the call back. */
734 _cpp_do_file_change (pfile, LC_ENTER, file->path, 1, sysp);
736 return true;
739 /* Mark FILE to be included once only. */
740 void
741 _cpp_mark_file_once_only (cpp_reader *pfile, _cpp_file *file)
743 pfile->seen_once_only = true;
744 file->once_only = true;
747 /* Return the directory from which searching for FNAME should start,
748 considering the directive TYPE and ANGLE_BRACKETS. If there is
749 nothing left in the path, returns NULL. */
750 static struct cpp_dir *
751 search_path_head (cpp_reader *pfile, const char *fname, int angle_brackets,
752 enum include_type type)
754 cpp_dir *dir;
755 _cpp_file *file;
757 if (IS_ABSOLUTE_PATH (fname))
758 return &pfile->no_search_path;
760 /* pfile->buffer is NULL when processing an -include command-line flag. */
761 file = pfile->buffer == NULL ? pfile->main_file : pfile->buffer->file;
763 /* For #include_next, skip in the search path past the dir in which
764 the current file was found, but if it was found via an absolute
765 path use the normal search logic. */
766 if (type == IT_INCLUDE_NEXT && file->dir)
767 dir = file->dir->next;
768 else if (angle_brackets)
769 dir = pfile->bracket_include;
770 else if (type == IT_CMDLINE)
771 /* -include and -imacros use the #include "" chain with the
772 preprocessor's cwd prepended. */
773 return make_cpp_dir (pfile, "./", false);
774 else if (pfile->quote_ignores_source_dir)
775 dir = pfile->quote_include;
776 else
777 return make_cpp_dir (pfile, dir_name_of_file (file),
778 pfile->buffer ? pfile->buffer->sysp : 0);
780 if (dir == NULL)
781 cpp_error (pfile, CPP_DL_ERROR,
782 "no include path in which to search for %s", fname);
784 return dir;
787 /* Strip the basename from the file's path. It ends with a slash if
788 of nonzero length. Note that this procedure also works for
789 <stdin>, which is represented by the empty string. */
790 static const char *
791 dir_name_of_file (_cpp_file *file)
793 if (!file->dir_name)
795 size_t len = lbasename (file->path) - file->path;
796 char *dir_name = XNEWVEC (char, len + 1);
798 memcpy (dir_name, file->path, len);
799 dir_name[len] = '\0';
800 file->dir_name = dir_name;
803 return file->dir_name;
806 /* Handles #include-family directives (distinguished by TYPE),
807 including HEADER, and the command line -imacros and -include.
808 Returns true if a buffer was stacked. */
809 bool
810 _cpp_stack_include (cpp_reader *pfile, const char *fname, int angle_brackets,
811 enum include_type type)
813 struct cpp_dir *dir;
814 _cpp_file *file;
816 dir = search_path_head (pfile, fname, angle_brackets, type);
817 if (!dir)
818 return false;
820 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets);
822 /* Compensate for the increment in linemap_add. In the case of a
823 normal #include, we're currently at the start of the line
824 *following* the #include. A separate source_location for this
825 location makes no sense (until we do the LC_LEAVE), and
826 complicates LAST_SOURCE_LINE_LOCATION. This does not apply if we
827 found a PCH file (in which case linemap_add is not called) or we
828 were included from the command-line. */
829 if (! file->pch && file->err_no == 0 && type != IT_CMDLINE)
830 pfile->line_table->highest_location--;
832 return _cpp_stack_file (pfile, file, type == IT_IMPORT);
835 /* Could not open FILE. The complication is dependency output. */
836 static void
837 open_file_failed (cpp_reader *pfile, _cpp_file *file, int angle_brackets)
839 int sysp = pfile->line_table->highest_line > 1 && pfile->buffer ? pfile->buffer->sysp : 0;
840 bool print_dep = CPP_OPTION (pfile, deps.style) > (angle_brackets || !!sysp);
842 errno = file->err_no;
843 if (print_dep && CPP_OPTION (pfile, deps.missing_files) && errno == ENOENT)
844 deps_add_dep (pfile->deps, file->name);
845 else
847 /* If we are outputting dependencies but not for this file then
848 don't error because we can still produce correct output. */
849 if (CPP_OPTION (pfile, deps.style) && ! print_dep)
850 cpp_errno (pfile, CPP_DL_WARNING, file->path);
851 else
852 cpp_errno (pfile, CPP_DL_ERROR, file->path);
856 /* Search in the chain beginning at HEAD for a file whose search path
857 started at START_DIR != NULL. */
858 static struct file_hash_entry *
859 search_cache (struct file_hash_entry *head, const cpp_dir *start_dir)
861 while (head && head->start_dir != start_dir)
862 head = head->next;
864 return head;
867 /* Allocate a new _cpp_file structure. */
868 static _cpp_file *
869 make_cpp_file (cpp_reader *pfile, cpp_dir *dir, const char *fname)
871 _cpp_file *file;
873 file = XCNEW (_cpp_file);
874 file->main_file = !pfile->buffer;
875 file->fd = -1;
876 file->dir = dir;
877 file->name = xstrdup (fname);
879 return file;
882 /* Release a _cpp_file structure. */
883 static void
884 destroy_cpp_file (_cpp_file *file)
886 if (file->buffer)
887 free ((void *) file->buffer);
888 free ((void *) file->name);
889 free (file);
892 /* A hash of directory names. The directory names are the path names
893 of files which contain a #include "", the included file name is
894 appended to this directories.
896 To avoid duplicate entries we follow the convention that all
897 non-empty directory names should end in a '/'. DIR_NAME must be
898 stored in permanently allocated memory. */
899 static cpp_dir *
900 make_cpp_dir (cpp_reader *pfile, const char *dir_name, int sysp)
902 struct file_hash_entry *entry, **hash_slot;
903 cpp_dir *dir;
905 hash_slot = (struct file_hash_entry **)
906 htab_find_slot_with_hash (pfile->dir_hash, dir_name,
907 htab_hash_string (dir_name),
908 INSERT);
910 /* Have we already hashed this directory? */
911 for (entry = *hash_slot; entry; entry = entry->next)
912 if (entry->start_dir == NULL)
913 return entry->u.dir;
915 dir = XCNEW (cpp_dir);
916 dir->next = pfile->quote_include;
917 dir->name = (char *) dir_name;
918 dir->len = strlen (dir_name);
919 dir->sysp = sysp;
920 dir->construct = 0;
922 /* Store this new result in the hash table. */
923 entry = new_file_hash_entry (pfile);
924 entry->next = *hash_slot;
925 entry->start_dir = NULL;
926 entry->u.dir = dir;
927 *hash_slot = entry;
929 return dir;
932 /* Create a new block of memory for file hash entries. */
933 static void
934 allocate_file_hash_entries (cpp_reader *pfile)
936 pfile->file_hash_entries_used = 0;
937 pfile->file_hash_entries_allocated = 127;
938 pfile->file_hash_entries = XNEWVEC (struct file_hash_entry,
939 pfile->file_hash_entries_allocated);
942 /* Return a new file hash entry. */
943 static struct file_hash_entry *
944 new_file_hash_entry (cpp_reader *pfile)
946 if (pfile->file_hash_entries_used == pfile->file_hash_entries_allocated)
947 allocate_file_hash_entries (pfile);
949 return &pfile->file_hash_entries[pfile->file_hash_entries_used++];
952 /* Returns TRUE if a file FNAME has ever been successfully opened.
953 This routine is not intended to correctly handle filenames aliased
954 by links or redundant . or .. traversals etc. */
955 bool
956 cpp_included (cpp_reader *pfile, const char *fname)
958 struct file_hash_entry *entry;
960 entry = (struct file_hash_entry *)
961 htab_find_with_hash (pfile->file_hash, fname, htab_hash_string (fname));
963 while (entry && (entry->start_dir == NULL || entry->u.file->err_no))
964 entry = entry->next;
966 return entry != NULL;
969 /* Calculate the hash value of a file hash entry P. */
971 static hashval_t
972 file_hash_hash (const void *p)
974 struct file_hash_entry *entry = (struct file_hash_entry *) p;
975 const char *hname;
976 if (entry->start_dir)
977 hname = entry->u.file->name;
978 else
979 hname = entry->u.dir->name;
981 return htab_hash_string (hname);
984 /* Compare a string Q against a file hash entry P. */
985 static int
986 file_hash_eq (const void *p, const void *q)
988 struct file_hash_entry *entry = (struct file_hash_entry *) p;
989 const char *fname = (const char *) q;
990 const char *hname;
992 if (entry->start_dir)
993 hname = entry->u.file->name;
994 else
995 hname = entry->u.dir->name;
997 return strcmp (hname, fname) == 0;
1000 /* Initialize everything in this source file. */
1001 void
1002 _cpp_init_files (cpp_reader *pfile)
1004 pfile->file_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1005 NULL, xcalloc, free);
1006 pfile->dir_hash = htab_create_alloc (127, file_hash_hash, file_hash_eq,
1007 NULL, xcalloc, free);
1008 allocate_file_hash_entries (pfile);
1011 /* Finalize everything in this source file. */
1012 void
1013 _cpp_cleanup_files (cpp_reader *pfile)
1015 htab_delete (pfile->file_hash);
1016 htab_delete (pfile->dir_hash);
1019 /* Enter a file name in the hash for the sake of cpp_included. */
1020 void
1021 _cpp_fake_include (cpp_reader *pfile, const char *fname)
1023 _cpp_find_file (pfile, fname, pfile->buffer->file->dir, true, 0);
1026 /* Not everyone who wants to set system-header-ness on a buffer can
1027 see the details of a buffer. This is an exported interface because
1028 fix-header needs it. */
1029 void
1030 cpp_make_system_header (cpp_reader *pfile, int syshdr, int externc)
1032 int flags = 0;
1033 const struct line_maps *line_table = pfile->line_table;
1034 const struct line_map *map = &line_table->maps[line_table->used-1];
1036 /* 1 = system header, 2 = system header to be treated as C. */
1037 if (syshdr)
1038 flags = 1 + (externc != 0);
1039 pfile->buffer->sysp = flags;
1040 _cpp_do_file_change (pfile, LC_RENAME, map->to_file,
1041 SOURCE_LINE (map, pfile->line_table->highest_line), flags);
1044 /* Allow the client to change the current file. Used by the front end
1045 to achieve pseudo-file names like <built-in>.
1046 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
1047 void
1048 cpp_change_file (cpp_reader *pfile, enum lc_reason reason,
1049 const char *new_name)
1051 _cpp_do_file_change (pfile, reason, new_name, 1, 0);
1054 /* Callback function for htab_traverse. */
1055 static int
1056 report_missing_guard (void **slot, void *b)
1058 struct file_hash_entry *entry = (struct file_hash_entry *) *slot;
1059 int *bannerp = (int *) b;
1061 /* Skip directories. */
1062 if (entry->start_dir != NULL)
1064 _cpp_file *file = entry->u.file;
1066 /* We don't want MI guard advice for the main file. */
1067 if (file->cmacro == NULL && file->stack_count == 1 && !file->main_file)
1069 if (*bannerp == 0)
1071 fputs (_("Multiple include guards may be useful for:\n"),
1072 stderr);
1073 *bannerp = 1;
1076 fputs (entry->u.file->path, stderr);
1077 putc ('\n', stderr);
1081 return 0;
1084 /* Report on all files that might benefit from a multiple include guard.
1085 Triggered by -H. */
1086 void
1087 _cpp_report_missing_guards (cpp_reader *pfile)
1089 int banner = 0;
1091 htab_traverse (pfile->file_hash, report_missing_guard, &banner);
1094 /* Locate HEADER, and determine whether it is newer than the current
1095 file. If it cannot be located or dated, return -1, if it is
1096 newer, return 1, otherwise 0. */
1098 _cpp_compare_file_date (cpp_reader *pfile, const char *fname,
1099 int angle_brackets)
1101 _cpp_file *file;
1102 struct cpp_dir *dir;
1104 dir = search_path_head (pfile, fname, angle_brackets, IT_INCLUDE);
1105 if (!dir)
1106 return -1;
1108 file = _cpp_find_file (pfile, fname, dir, false, angle_brackets);
1109 if (file->err_no)
1110 return -1;
1112 if (file->fd != -1)
1114 close (file->fd);
1115 file->fd = -1;
1118 return file->st.st_mtime > pfile->buffer->file->st.st_mtime;
1121 /* Pushes the given file onto the buffer stack. Returns nonzero if
1122 successful. */
1123 bool
1124 cpp_push_include (cpp_reader *pfile, const char *fname)
1126 return _cpp_stack_include (pfile, fname, false, IT_CMDLINE);
1129 /* Do appropriate cleanup when a file INC's buffer is popped off the
1130 input stack. */
1131 void
1132 _cpp_pop_file_buffer (cpp_reader *pfile, _cpp_file *file)
1134 /* Record the inclusion-preventing macro, which could be NULL
1135 meaning no controlling macro. */
1136 if (pfile->mi_valid && file->cmacro == NULL)
1137 file->cmacro = pfile->mi_cmacro;
1139 /* Invalidate control macros in the #including file. */
1140 pfile->mi_valid = false;
1142 if (file->buffer)
1144 free ((void *) file->buffer);
1145 file->buffer = NULL;
1146 file->buffer_valid = false;
1150 /* Inteface to file statistics record in _cpp_file structure. */
1151 struct stat *
1152 _cpp_get_file_stat (_cpp_file *file)
1154 return &file->st;
1157 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1158 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1159 directory of the including file.
1161 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1162 void
1163 cpp_set_include_chains (cpp_reader *pfile, cpp_dir *quote, cpp_dir *bracket,
1164 int quote_ignores_source_dir)
1166 pfile->quote_include = quote;
1167 pfile->bracket_include = quote;
1168 pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1170 for (; quote; quote = quote->next)
1172 quote->name_map = NULL;
1173 quote->len = strlen (quote->name);
1174 if (quote == bracket)
1175 pfile->bracket_include = bracket;
1179 /* Append the file name to the directory to create the path, but don't
1180 turn / into // or // into ///; // may be a namespace escape. */
1181 static char *
1182 append_file_to_dir (const char *fname, cpp_dir *dir)
1184 size_t dlen, flen;
1185 char *path;
1187 dlen = dir->len;
1188 flen = strlen (fname);
1189 path = XNEWVEC (char, dlen + 1 + flen + 1);
1190 memcpy (path, dir->name, dlen);
1191 if (dlen && path[dlen - 1] != '/')
1192 path[dlen++] = '/';
1193 memcpy (&path[dlen], fname, flen + 1);
1195 return path;
1198 /* Read a space delimited string of unlimited length from a stdio
1199 file F. */
1200 static char *
1201 read_filename_string (int ch, FILE *f)
1203 char *alloc, *set;
1204 int len;
1206 len = 20;
1207 set = alloc = XNEWVEC (char, len + 1);
1208 if (! is_space (ch))
1210 *set++ = ch;
1211 while ((ch = getc (f)) != EOF && ! is_space (ch))
1213 if (set - alloc == len)
1215 len *= 2;
1216 alloc = XRESIZEVEC (char, alloc, len + 1);
1217 set = alloc + len / 2;
1219 *set++ = ch;
1222 *set = '\0';
1223 ungetc (ch, f);
1224 return alloc;
1227 /* Read the file name map file for DIR. */
1228 static void
1229 read_name_map (cpp_dir *dir)
1231 static const char FILE_NAME_MAP_FILE[] = "header.gcc";
1232 char *name;
1233 FILE *f;
1234 size_t len, count = 0, room = 9;
1236 len = dir->len;
1237 name = (char *) alloca (len + sizeof (FILE_NAME_MAP_FILE) + 1);
1238 memcpy (name, dir->name, len);
1239 if (len && name[len - 1] != '/')
1240 name[len++] = '/';
1241 strcpy (name + len, FILE_NAME_MAP_FILE);
1242 f = fopen (name, "r");
1244 dir->name_map = XNEWVEC (const char *, room);
1246 /* Silently return NULL if we cannot open. */
1247 if (f)
1249 int ch;
1251 while ((ch = getc (f)) != EOF)
1253 char *to;
1255 if (is_space (ch))
1256 continue;
1258 if (count + 2 > room)
1260 room += 8;
1261 dir->name_map = XRESIZEVEC (const char *, dir->name_map, room);
1264 dir->name_map[count] = read_filename_string (ch, f);
1265 while ((ch = getc (f)) != EOF && is_hspace (ch))
1268 to = read_filename_string (ch, f);
1269 if (IS_ABSOLUTE_PATH (to))
1270 dir->name_map[count + 1] = to;
1271 else
1273 dir->name_map[count + 1] = append_file_to_dir (to, dir);
1274 free (to);
1277 count += 2;
1278 while ((ch = getc (f)) != '\n')
1279 if (ch == EOF)
1280 break;
1283 fclose (f);
1286 /* Terminate the list of maps. */
1287 dir->name_map[count] = NULL;
1290 /* Remap a FILE's name based on the file_name_map, if any, for
1291 FILE->dir. If the file name has any directory separators,
1292 recursively check those directories too. */
1293 static char *
1294 remap_filename (cpp_reader *pfile, _cpp_file *file)
1296 const char *fname, *p;
1297 char *new_dir;
1298 cpp_dir *dir;
1299 size_t index, len;
1301 dir = file->dir;
1302 fname = file->name;
1304 for (;;)
1306 if (!dir->name_map)
1307 read_name_map (dir);
1309 for (index = 0; dir->name_map[index]; index += 2)
1310 if (!strcmp (dir->name_map[index], fname))
1311 return xstrdup (dir->name_map[index + 1]);
1313 p = strchr (fname, '/');
1314 if (!p || p == fname)
1315 return NULL;
1317 len = dir->len + (p - fname + 1);
1318 new_dir = XNEWVEC (char, len + 1);
1319 memcpy (new_dir, dir->name, dir->len);
1320 memcpy (new_dir + dir->len, fname, p - fname + 1);
1321 new_dir[len] = '\0';
1323 dir = make_cpp_dir (pfile, new_dir, dir->sysp);
1324 fname = p + 1;
1328 /* Returns true if PCHNAME is a valid PCH file for FILE. */
1329 static bool
1330 validate_pch (cpp_reader *pfile, _cpp_file *file, const char *pchname)
1332 const char *saved_path = file->path;
1333 bool valid = false;
1335 file->path = pchname;
1336 if (open_file (file))
1338 valid = 1 & pfile->cb.valid_pch (pfile, pchname, file->fd);
1340 if (!valid)
1342 close (file->fd);
1343 file->fd = -1;
1346 if (CPP_OPTION (pfile, print_include_names))
1348 unsigned int i;
1349 for (i = 1; i < pfile->line_table->depth; i++)
1350 putc ('.', stderr);
1351 fprintf (stderr, "%c %s\n",
1352 valid ? '!' : 'x', pchname);
1356 file->path = saved_path;
1357 return valid;
1360 /* Get the path associated with the _cpp_file F. The path includes
1361 the base name from the include directive and the directory it was
1362 found in via the search path. */
1364 const char *
1365 cpp_get_path (struct _cpp_file *f)
1367 return f->path;
1370 /* Get the directory associated with the _cpp_file F. */
1372 cpp_dir *
1373 cpp_get_dir (struct _cpp_file *f)
1375 return f->dir;
1378 /* Get the cpp_buffer currently associated with the cpp_reader
1379 PFILE. */
1381 cpp_buffer *
1382 cpp_get_buffer (cpp_reader *pfile)
1384 return pfile->buffer;
1387 /* Get the _cpp_file associated with the cpp_buffer B. */
1389 _cpp_file *
1390 cpp_get_file (cpp_buffer *b)
1392 return b->file;
1395 /* Get the previous cpp_buffer given a cpp_buffer B. The previous
1396 buffer is the buffer that included the given buffer. */
1398 cpp_buffer *
1399 cpp_get_prev (cpp_buffer *b)
1401 return b->prev;
1404 /* This data structure holds the list of header files that were seen
1405 while the PCH was being built. The 'entries' field is kept sorted
1406 in memcmp() order; yes, this means that on little-endian systems,
1407 it's sorted initially by the least-significant byte of 'size', but
1408 that's OK. The code does rely on having entries with the same size
1409 next to each other. */
1411 struct pchf_entry {
1412 /* The size of this file. This is used to save running a MD5 checksum
1413 if the sizes don't match. */
1414 off_t size;
1415 /* The MD5 checksum of this file. */
1416 unsigned char sum[16];
1417 /* Is this file to be included only once? */
1418 bool once_only;
1421 struct pchf_data {
1422 /* Number of pchf_entry structures. */
1423 size_t count;
1425 /* Are there any values with once_only set?
1426 This is used as an optimisation, it means we don't have to search
1427 the structure if we're processing a regular #include. */
1428 bool have_once_only;
1430 struct pchf_entry entries[1];
1433 static struct pchf_data *pchf;
1435 /* A qsort ordering function for pchf_entry structures. */
1437 static int
1438 pchf_save_compare (const void *e1, const void *e2)
1440 return memcmp (e1, e2, sizeof (struct pchf_entry));
1443 /* Create and write to F a pchf_data structure. */
1445 bool
1446 _cpp_save_file_entries (cpp_reader *pfile, FILE *fp)
1448 size_t count = 0;
1449 struct pchf_data *result;
1450 size_t result_size;
1451 _cpp_file *f;
1453 for (f = pfile->all_files; f; f = f->next_file)
1454 ++count;
1456 result_size = (sizeof (struct pchf_data)
1457 + sizeof (struct pchf_entry) * (count - 1));
1458 result = XCNEWVAR (struct pchf_data, result_size);
1460 result->count = 0;
1461 result->have_once_only = false;
1463 for (f = pfile->all_files; f; f = f->next_file)
1465 size_t count;
1467 /* This should probably never happen, since if a read error occurred
1468 the PCH file shouldn't be written... */
1469 if (f->dont_read || f->err_no)
1470 continue;
1472 if (f->stack_count == 0)
1473 continue;
1475 count = result->count++;
1477 result->entries[count].once_only = f->once_only;
1478 /* |= is avoided in the next line because of an HP C compiler bug */
1479 result->have_once_only = result->have_once_only | f->once_only;
1480 if (f->buffer_valid)
1481 md5_buffer ((const char *)f->buffer,
1482 f->st.st_size, result->entries[count].sum);
1483 else
1485 FILE *ff;
1486 int oldfd = f->fd;
1488 if (!open_file (f))
1490 open_file_failed (pfile, f, 0);
1491 return false;
1493 ff = fdopen (f->fd, "rb");
1494 md5_stream (ff, result->entries[count].sum);
1495 fclose (ff);
1496 f->fd = oldfd;
1498 result->entries[count].size = f->st.st_size;
1501 result_size = (sizeof (struct pchf_data)
1502 + sizeof (struct pchf_entry) * (result->count - 1));
1504 qsort (result->entries, result->count, sizeof (struct pchf_entry),
1505 pchf_save_compare);
1507 return fwrite (result, result_size, 1, fp) == 1;
1510 /* Read the pchf_data structure from F. */
1512 bool
1513 _cpp_read_file_entries (cpp_reader *pfile ATTRIBUTE_UNUSED, FILE *f)
1515 struct pchf_data d;
1517 if (fread (&d, sizeof (struct pchf_data) - sizeof (struct pchf_entry), 1, f)
1518 != 1)
1519 return false;
1521 pchf = XNEWVAR (struct pchf_data, sizeof (struct pchf_data)
1522 + sizeof (struct pchf_entry) * (d.count - 1));
1523 memcpy (pchf, &d, sizeof (struct pchf_data) - sizeof (struct pchf_entry));
1524 if (fread (pchf->entries, sizeof (struct pchf_entry), d.count, f)
1525 != d.count)
1526 return false;
1527 return true;
1530 /* The parameters for pchf_compare. */
1532 struct pchf_compare_data
1534 /* The size of the file we're looking for. */
1535 off_t size;
1537 /* The MD5 checksum of the file, if it's been computed. */
1538 unsigned char sum[16];
1540 /* Is SUM valid? */
1541 bool sum_computed;
1543 /* Do we need to worry about entries that don't have ONCE_ONLY set? */
1544 bool check_included;
1546 /* The file that we're searching for. */
1547 _cpp_file *f;
1550 /* bsearch comparison function; look for D_P in E_P. */
1552 static int
1553 pchf_compare (const void *d_p, const void *e_p)
1555 const struct pchf_entry *e = (const struct pchf_entry *)e_p;
1556 struct pchf_compare_data *d = (struct pchf_compare_data *)d_p;
1557 int result;
1559 result = memcmp (&d->size, &e->size, sizeof (off_t));
1560 if (result != 0)
1561 return result;
1563 if (! d->sum_computed)
1565 _cpp_file *const f = d->f;
1567 md5_buffer ((const char *)f->buffer, f->st.st_size, d->sum);
1568 d->sum_computed = true;
1571 result = memcmp (d->sum, e->sum, 16);
1572 if (result != 0)
1573 return result;
1575 if (d->check_included || e->once_only)
1576 return 0;
1577 else
1578 return 1;
1581 /* Check that F is not in a list read from a PCH file (if any).
1582 Assumes that f->buffer_valid is true. Return TRUE if the file
1583 should not be read. */
1585 static bool
1586 check_file_against_entries (cpp_reader *pfile ATTRIBUTE_UNUSED,
1587 _cpp_file *f,
1588 bool check_included)
1590 struct pchf_compare_data d;
1592 if (pchf == NULL
1593 || (! check_included && ! pchf->have_once_only))
1594 return false;
1596 d.size = f->st.st_size;
1597 d.sum_computed = false;
1598 d.f = f;
1599 d.check_included = check_included;
1600 return bsearch (&d, pchf->entries, pchf->count, sizeof (struct pchf_entry),
1601 pchf_compare) != NULL;