1 /* Part of CPP library. (include file handling)
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1998,
3 1999, 2000, 2001, 2002, 2003 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
9 This program is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 2, or (at your option) any
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26 #include "coretypes.h"
32 #include "splay-tree.h"
33 #ifdef ENABLE_VALGRIND_CHECKING
36 /* Avoid #ifdef:s when we can help it. */
37 #define VALGRIND_DISCARD(x)
41 # include <sys/mman.h>
42 # ifndef MMAP_THRESHOLD
43 # define MMAP_THRESHOLD 3 /* Minimum page count to mmap the file. */
46 # define TEST_THRESHOLD(size, pagesize) \
47 (size / pagesize >= MMAP_THRESHOLD && (size % pagesize) != 0)
48 /* Use mmap if the file is big enough to be worth it (controlled
49 by MMAP_THRESHOLD) and if we can safely count on there being
50 at least one readable NUL byte after the end of the file's
51 contents. This is true for all tested operating systems when
52 the file size is not an exact multiple of the page size. */
54 # define SHOULD_MMAP(size, pagesize) TEST_THRESHOLD (size, pagesize)
56 # define WIN32_LEAN_AND_MEAN
58 /* Cygwin can't correctly emulate mmap under Windows 9x style systems so
59 disallow use of mmap on those systems. Windows 9x does not zero fill
60 memory at EOF and beyond, as required. */
61 # define SHOULD_MMAP(size, pagesize) ((GetVersion() & 0x80000000) \
62 ? 0 : TEST_THRESHOLD (size, pagesize))
66 #else /* No MMAP_FILE */
67 # undef MMAP_THRESHOLD
68 # define MMAP_THRESHOLD 0
75 /* If errno is inspected immediately after a system call fails, it will be
76 nonzero, and no error number will ever be zero. */
84 /* Suppress warning about function macros used w/o arguments in traditional
85 C. It is unlikely that glibc's strcmp macro helps this file at all. */
88 /* This structure is used for the table of all includes. */
90 const char *name; /* actual path name of file */
91 const char *header_name; /* the original header found */
92 const cpp_hashnode *cmacro; /* macro, if any, preventing reinclusion. */
93 const struct cpp_path *foundhere;
94 /* location in search path where file was
95 found, for #include_next and sysp. */
96 const unsigned char *buffer; /* pointer to cached file contents */
97 struct stat st; /* copy of stat(2) data for file */
98 int fd; /* fd open on file (short term storage only) */
99 int err_no; /* errno obtained if opening a file failed */
100 unsigned short include_count; /* number of times file has been read */
101 unsigned short refcnt; /* number of stacked buffers using this file */
102 unsigned char mapped; /* file buffer is mmapped */
103 unsigned char pch; /* 0: file not known to be a PCH.
105 (on return from find_include_file).
106 2: file is not and never will be a valid
108 3: file is always a valid precompiled
112 /* Variable length record files on VMS will have a stat size that includes
113 record control characters that won't be included in the read size. */
115 # define FAB_C_VAR 2 /* variable length records (see Starlet fabdef.h) */
116 # define STAT_SIZE_TOO_BIG(ST) ((ST).st_fab_rfm == FAB_C_VAR)
118 # define STAT_SIZE_TOO_BIG(ST) 0
121 /* The cmacro works like this: If it's NULL, the file is to be
122 included again. If it's NEVER_REREAD, the file is never to be
123 included again. Otherwise it is a macro hashnode, and the file is
124 to be included again if the macro is defined. */
125 #define NEVER_REREAD ((const cpp_hashnode *) -1)
126 #define DO_NOT_REREAD(inc) \
127 ((inc)->cmacro && ((inc)->cmacro == NEVER_REREAD \
128 || (inc)->cmacro->type == NT_MACRO))
129 #define NO_INCLUDE_PATH ((struct include_file *) -1)
130 #define INCLUDE_PCH_P(F) (((F)->pch & 1) != 0)
132 static struct file_name_map *read_name_map
133 PARAMS ((cpp_reader *, const char *));
134 static char *read_filename_string PARAMS ((int, FILE *));
135 static char *remap_filename PARAMS ((cpp_reader *, char *,
137 static struct cpp_path *search_from PARAMS ((cpp_reader *,
139 static struct include_file *
140 find_include_file PARAMS ((cpp_reader *, const cpp_token *,
142 static struct include_file *open_file PARAMS ((cpp_reader *, const char *));
143 static struct include_file *validate_pch PARAMS ((cpp_reader *,
146 static struct include_file *open_file_pch PARAMS ((cpp_reader *,
148 static int read_include_file PARAMS ((cpp_reader *, struct include_file *));
149 static bool stack_include_file PARAMS ((cpp_reader *, struct include_file *));
150 static void purge_cache PARAMS ((struct include_file *));
151 static void destroy_node PARAMS ((splay_tree_value));
152 static int report_missing_guard PARAMS ((splay_tree_node, void *));
153 static splay_tree_node find_or_create_entry PARAMS ((cpp_reader *,
155 static void handle_missing_header PARAMS ((cpp_reader *, const char *, int));
157 /* Set up the splay tree we use to store information about all the
158 file names seen in this compilation. We also have entries for each
159 file we tried to open but failed; this saves system calls since we
160 don't try to open it again in future.
162 The key of each node is the file name, after processing by
163 simplify_path. The path name may or may not be absolute.
164 The path string has been malloced, as is automatically freed by
165 registering free () as the splay tree key deletion function.
167 A node's value is a pointer to a struct include_file, and is never
170 _cpp_init_includes (pfile)
173 pfile->all_include_files
174 = splay_tree_new ((splay_tree_compare_fn) strcmp,
175 (splay_tree_delete_key_fn) free,
179 /* Tear down the splay tree. */
181 _cpp_cleanup_includes (pfile)
184 splay_tree_delete (pfile->all_include_files);
187 /* Free a node. The path string is automatically freed. */
192 struct include_file *f = (struct include_file *) v;
201 /* Mark a file to not be reread (e.g. #import, read failure). */
203 _cpp_never_reread (file)
204 struct include_file *file;
206 file->cmacro = NEVER_REREAD;
209 /* Lookup a filename, which is simplified after making a copy, and
210 create an entry if none exists. */
211 static splay_tree_node
212 find_or_create_entry (pfile, fname)
216 splay_tree_node node;
217 struct include_file *file;
218 char *name = xstrdup (fname);
221 if (pfile->cb.simplify_path)
224 (pfile->cb.simplify_path) (name);
228 node = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) name);
233 file = xcnew (struct include_file);
235 file->header_name = name;
236 file->err_no = saved_errno;
237 node = splay_tree_insert (pfile->all_include_files,
238 (splay_tree_key) file->name,
239 (splay_tree_value) file);
245 /* Enter a file name in the splay tree, for the sake of cpp_included. */
247 _cpp_fake_include (pfile, fname)
251 find_or_create_entry (pfile, fname);
254 /* Given a file name, look it up in the cache; if there is no entry,
255 create one with a non-NULL value (regardless of success in opening
256 the file). If the file doesn't exist or is inaccessible, this
257 entry is flagged so we don't attempt to open it again in the
258 future. If the file isn't open, open it. The empty string is
259 interpreted as stdin.
261 Returns an include_file structure with an open file descriptor on
262 success, or NULL on failure. */
263 static struct include_file *
264 open_file (pfile, filename)
266 const char *filename;
268 splay_tree_node nd = find_or_create_entry (pfile, filename);
269 struct include_file *file = (struct include_file *) nd->value;
273 /* Ugh. handle_missing_header () needs errno to be set. */
274 errno = file->err_no;
278 /* Don't reopen an idempotent file. */
279 if (DO_NOT_REREAD (file))
282 /* Don't reopen one which is already loaded. */
283 if (file->buffer != NULL)
286 /* We used to open files in nonblocking mode, but that caused more
287 problems than it solved. Do take care not to acquire a
288 controlling terminal by mistake (this can't happen on sane
289 systems, but paranoia is a virtue).
291 Use the three-argument form of open even though we aren't
292 specifying O_CREAT, to defend against broken system headers.
294 O_BINARY tells some runtime libraries (notably DJGPP) not to do
295 newline translation; we can handle DOS line breaks just fine
298 Special case: the empty string is translated to stdin. */
300 if (filename[0] == '\0')
304 /* For DJGPP redirected input is opened in text mode. Change it
306 if (! isatty (file->fd))
307 setmode (file->fd, O_BINARY);
311 file->fd = open (file->name, O_RDONLY | O_NOCTTY | O_BINARY, 0666);
313 if (file->fd != -1 && fstat (file->fd, &file->st) == 0)
315 if (!S_ISDIR (file->st.st_mode))
318 /* If it's a directory, we return null and continue the search
319 as the file we're looking for may appear elsewhere in the
326 file->err_no = errno;
330 static struct include_file *
331 validate_pch (pfile, filename, pchname)
333 const char *filename;
336 struct include_file * file;
338 file = open_file (pfile, pchname);
341 if ((file->pch & 2) == 0)
342 file->pch = pfile->cb.valid_pch (pfile, pchname, file->fd);
343 if (INCLUDE_PCH_P (file))
345 char *f = xstrdup (filename);
346 (pfile->cb.simplify_path) (f);
347 file->header_name = f;
356 /* Like open_file, but also look for a precompiled header if (a) one exists
357 and (b) it is valid. */
358 static struct include_file *
359 open_file_pch (pfile, filename)
361 const char *filename;
363 if (filename[0] != '\0'
364 && pfile->cb.valid_pch != NULL)
366 size_t namelen = strlen (filename);
367 char *pchname = alloca (namelen + 5);
368 struct include_file * file;
371 memcpy (pchname, filename, namelen);
372 memcpy (pchname + namelen, ".gch", 5);
374 nd = find_or_create_entry (pfile, pchname);
375 file = (struct include_file *) nd->value;
379 if (stat (file->name, &file->st) == 0 && S_ISDIR (file->st.st_mode))
383 size_t subname_len = namelen + 64;
384 char *subname = xmalloc (subname_len);
386 thedir = opendir (pchname);
389 memcpy (subname, pchname, namelen + 4);
390 subname[namelen+4] = '/';
391 while ((d = readdir (thedir)) != NULL)
393 if (strlen (d->d_name) + namelen + 7 > subname_len)
395 subname_len = strlen (d->d_name) + namelen + 64;
396 subname = xrealloc (subname, subname_len);
398 strcpy (subname + namelen + 5, d->d_name);
399 file = validate_pch (pfile, filename, subname);
407 file = validate_pch (pfile, filename, pchname);
412 return open_file (pfile, filename);
415 /* Place the file referenced by INC into a new buffer on the buffer
416 stack, unless there are errors, or the file is not re-included
417 because of e.g. multiple-include guards. Returns true if a buffer
420 stack_include_file (pfile, inc)
422 struct include_file *inc;
426 const char *filename;
428 if (DO_NOT_REREAD (inc))
431 sysp = MAX ((pfile->map ? pfile->map->sysp : 0),
432 (inc->foundhere ? inc->foundhere->sysp : 0));
434 /* Add the file to the dependencies on its first inclusion. */
435 if (CPP_OPTION (pfile, deps.style) > !!sysp && !inc->include_count)
437 if (pfile->buffer || CPP_OPTION (pfile, deps.ignore_main_file) == 0)
438 deps_add_dep (pfile->deps, inc->name);
441 /* PCH files get dealt with immediately. */
442 if (INCLUDE_PCH_P (inc))
444 pfile->cb.read_pch (pfile, inc->name, inc->fd, inc->header_name);
453 if (read_include_file (pfile, inc))
455 /* If an error occurs, do not try to read this file again. */
456 _cpp_never_reread (inc);
459 /* Mark a regular, zero-length file never-reread. We read it,
460 NUL-terminate it, and stack it once, so preprocessing a main
461 file of zero length does not raise an error. */
462 if (S_ISREG (inc->st.st_mode) && inc->st.st_size == 0)
463 _cpp_never_reread (inc);
469 /* We don't want MI guard advice for the main file. */
470 inc->include_count++;
473 fp = cpp_push_buffer (pfile, inc->buffer, inc->st.st_size,
474 /* from_stage3 */ CPP_OPTION (pfile, preprocessed), 0);
478 /* Initialize controlling macro state. */
479 pfile->mi_valid = true;
480 pfile->mi_cmacro = 0;
482 /* Generate the call back. */
483 filename = inc->name;
484 if (*filename == '\0')
485 filename = "<stdin>";
486 _cpp_do_file_change (pfile, LC_ENTER, filename, 1, sysp);
491 /* Read the file referenced by INC into the file cache.
493 If fd points to a plain file, we might be able to mmap it; we can
494 definitely allocate the buffer all at once. If fd is a pipe or
495 terminal, we can't do either. If fd is something weird, like a
496 block device, we don't want to read it at all.
498 Unfortunately, different systems use different st.st_mode values
499 for pipes: some have S_ISFIFO, some S_ISSOCK, some are buggy and
500 zero the entire struct stat except a couple fields. Hence we don't
501 even try to figure out what something is, except for plain files
504 FIXME: Flush file cache and try again if we run out of memory. */
506 read_include_file (pfile, inc)
508 struct include_file *inc;
510 ssize_t size, offset, count;
513 static int pagesize = -1;
516 if (S_ISREG (inc->st.st_mode))
518 /* off_t might have a wider range than ssize_t - in other words,
519 the max size of a file might be bigger than the address
520 space. We can't handle a file that large. (Anyone with
521 a single source file bigger than 2GB needs to rethink
522 their coding style.) Some systems (e.g. AIX 4.1) define
523 SSIZE_MAX to be much smaller than the actual range of the
524 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
526 if (inc->st.st_size > INTTYPE_MAXIMUM (ssize_t))
528 cpp_error (pfile, DL_ERROR, "%s is too large", inc->name);
531 size = inc->st.st_size;
536 pagesize = getpagesize ();
538 if (SHOULD_MMAP (size, pagesize))
540 buf = (uchar *) mmap (0, size, PROT_READ, MAP_PRIVATE, inc->fd, 0);
541 if (buf == (uchar *) -1)
544 /* We must tell Valgrind that the byte at buf[size] is actually
545 readable. Discard the handle to avoid handle leak. */
546 VALGRIND_DISCARD (VALGRIND_MAKE_READABLE (buf + size, 1));
553 buf = (uchar *) xmalloc (size + 1);
555 while (offset < size)
557 count = read (inc->fd, buf + offset, size - offset);
562 if (!STAT_SIZE_TOO_BIG (inc->st))
563 cpp_error (pfile, DL_WARNING,
564 "%s is shorter than expected", inc->name);
566 buf = xrealloc (buf, size + 1);
567 inc->st.st_size = size;
572 /* The lexer requires that the buffer be NUL-terminated. */
576 else if (S_ISBLK (inc->st.st_mode))
578 cpp_error (pfile, DL_ERROR, "%s is a block device", inc->name);
583 /* 8 kilobytes is a sensible starting size. It ought to be
584 bigger than the kernel pipe buffer, and it's definitely
585 bigger than the majority of C source files. */
588 buf = (uchar *) xmalloc (size + 1);
590 while ((count = read (inc->fd, buf + offset, size - offset)) > 0)
596 buf = xrealloc (buf, size + 1);
602 if (offset + 1 < size)
603 buf = xrealloc (buf, offset + 1);
605 /* The lexer requires that the buffer be NUL-terminated. */
607 inc->st.st_size = offset;
614 cpp_errno (pfile, DL_ERROR, inc->name);
619 /* Drop INC's buffer from memory, if we are unlikely to need it again. */
622 struct include_file *inc;
629 /* Undo the previous annotation for the
630 known-zero-byte-after-mmap. Discard the handle to avoid
632 VALGRIND_DISCARD (VALGRIND_MAKE_NOACCESS (inc->buffer
633 + inc->st.st_size, 1));
634 munmap ((PTR) inc->buffer, inc->st.st_size);
638 free ((PTR) inc->buffer);
643 /* Return 1 if the file named by FNAME has been included before in
644 any context, 0 otherwise. */
646 cpp_included (pfile, fname)
650 struct cpp_path *path;
654 if (IS_ABSOLUTE_PATHNAME (fname))
656 /* Just look it up. */
657 nd = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) fname);
658 return (nd && nd->value);
661 /* Search directory path for the file. */
662 name = (char *) alloca (strlen (fname) + pfile->max_include_len + 2);
663 for (path = pfile->quote_include; path; path = path->next)
665 memcpy (name, path->name, path->len);
666 name[path->len] = '/';
667 strcpy (&name[path->len + 1], fname);
668 if (CPP_OPTION (pfile, remap))
669 n = remap_filename (pfile, name, path);
673 nd = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) n);
680 /* Search for HEADER. Return 0 if there is no such file (or it's
681 un-openable), in which case an error code will be in errno. If
682 there is no include path to use it returns NO_INCLUDE_PATH,
683 otherwise an include_file structure. If this request originates
684 from a directive of TYPE #include_next, set INCLUDE_NEXT to true. */
685 static struct include_file *
686 find_include_file (pfile, header, type)
688 const cpp_token *header;
689 enum include_type type;
691 const char *fname = (const char *) header->val.str.text;
692 struct cpp_path *path;
693 struct include_file *file;
696 if (IS_ABSOLUTE_PATHNAME (fname))
697 return open_file_pch (pfile, fname);
699 /* For #include_next, skip in the search path past the dir in which
700 the current file was found, but if it was found via an absolute
701 path use the normal search logic. */
702 if (type == IT_INCLUDE_NEXT && pfile->buffer->inc->foundhere)
703 path = pfile->buffer->inc->foundhere->next;
704 else if (header->type == CPP_HEADER_NAME)
705 path = pfile->bracket_include;
707 path = search_from (pfile, type);
711 cpp_error (pfile, DL_ERROR, "no include path in which to find %s",
713 return NO_INCLUDE_PATH;
716 /* Search directory path for the file. */
717 name = (char *) alloca (strlen (fname) + pfile->max_include_len + 2);
718 for (; path; path = path->next)
721 memcpy (name, path->name, len);
722 /* Don't turn / into // or // into ///; // may be a namespace
724 if (name[len-1] == '/')
727 strcpy (&name[len + 1], fname);
728 if (CPP_OPTION (pfile, remap))
729 n = remap_filename (pfile, name, path);
733 file = open_file_pch (pfile, n);
736 file->foundhere = path;
744 /* Not everyone who wants to set system-header-ness on a buffer can
745 see the details of a buffer. This is an exported interface because
746 fix-header needs it. */
748 cpp_make_system_header (pfile, syshdr, externc)
754 /* 1 = system header, 2 = system header to be treated as C. */
756 flags = 1 + (externc != 0);
757 _cpp_do_file_change (pfile, LC_RENAME, pfile->map->to_file,
758 SOURCE_LINE (pfile->map, pfile->line), flags);
761 /* Report on all files that might benefit from a multiple include guard.
764 _cpp_report_missing_guards (pfile)
768 splay_tree_foreach (pfile->all_include_files, report_missing_guard,
772 /* Callback function for splay_tree_foreach(). */
774 report_missing_guard (n, b)
778 struct include_file *f = (struct include_file *) n->value;
779 int *bannerp = (int *) b;
781 if (f && f->cmacro == 0 && f->include_count == 1)
785 fputs (_("Multiple include guards may be useful for:\n"), stderr);
788 fputs (f->name, stderr);
794 /* Create a dependency for file FNAME, or issue an error message as
795 appropriate. ANGLE_BRACKETS is nonzero if the file was bracketed
798 handle_missing_header (pfile, fname, angle_brackets)
804 = CPP_OPTION (pfile, deps.style) > (angle_brackets || pfile->map->sysp);
806 if (CPP_OPTION (pfile, deps.missing_files) && print_dep)
807 deps_add_dep (pfile->deps, fname);
808 /* If -M was specified, then don't count this as an error, because
809 we can still produce correct output. Otherwise, we can't produce
810 correct output, because there may be dependencies we need inside
811 the missing file, and we don't know what directory this missing
814 cpp_errno (pfile, CPP_OPTION (pfile, deps.style) && ! print_dep
815 ? DL_WARNING: DL_ERROR, fname);
818 /* Handles #include-family directives (distinguished by TYPE),
819 including HEADER, and the command line -imacros and -include.
820 Returns true if a buffer was stacked. */
822 _cpp_execute_include (pfile, header, type)
824 const cpp_token *header;
825 enum include_type type;
827 bool stacked = false;
828 struct include_file *inc = find_include_file (pfile, header, type);
831 handle_missing_header (pfile, (const char *) header->val.str.text,
832 header->type == CPP_HEADER_NAME);
833 else if (inc != NO_INCLUDE_PATH)
835 stacked = stack_include_file (pfile, inc);
837 if (type == IT_IMPORT)
838 _cpp_never_reread (inc);
844 /* Locate HEADER, and determine whether it is newer than the current
845 file. If it cannot be located or dated, return -1, if it is newer
846 newer, return 1, otherwise 0. */
848 _cpp_compare_file_date (pfile, header)
850 const cpp_token *header;
852 struct include_file *inc = find_include_file (pfile, header, 0);
854 if (inc == NULL || inc == NO_INCLUDE_PATH)
863 return inc->st.st_mtime > pfile->buffer->inc->st.st_mtime;
867 /* Push an input buffer and load it up with the contents of FNAME. If
868 FNAME is "", read standard input. Return true if a buffer was
871 _cpp_read_file (pfile, fname)
875 /* This uses open_file, because we don't allow a PCH to be used as
876 the toplevel compilation (that would prevent re-compiling an
877 existing PCH without deleting it first). */
878 struct include_file *f = open_file (pfile, fname);
882 cpp_errno (pfile, DL_ERROR, fname);
886 return stack_include_file (pfile, f);
889 /* Do appropriate cleanup when a file INC's buffer is popped off the
892 _cpp_pop_file_buffer (pfile, inc)
894 struct include_file *inc;
896 /* Record the inclusion-preventing macro, which could be NULL
897 meaning no controlling macro. */
898 if (pfile->mi_valid && inc->cmacro == NULL)
899 inc->cmacro = pfile->mi_cmacro;
901 /* Invalidate control macros in the #including file. */
902 pfile->mi_valid = false;
905 if (inc->refcnt == 0 && DO_NOT_REREAD (inc))
909 /* Returns the first place in the include chain to start searching for
910 "" includes. This involves stripping away the basename of the
911 current file, unless -I- was specified.
913 If we're handling -include or -imacros, use the "" chain, but with
914 the preprocessor's cwd prepended. */
915 static struct cpp_path *
916 search_from (pfile, type)
918 enum include_type type;
920 cpp_buffer *buffer = pfile->buffer;
923 /* Command line uses the cwd, and does not cache the result. */
924 if (type == IT_CMDLINE)
927 /* Ignore the current file's directory? */
928 if (pfile->quote_ignores_source_dir)
929 return pfile->quote_include;
931 if (! buffer->search_cached)
933 buffer->search_cached = 1;
935 dlen = lbasename (buffer->inc->name) - buffer->inc->name;
939 /* We don't guarantee NAME is null-terminated. This saves
940 allocating and freeing memory. Drop a trailing '/'. */
941 buffer->dir.name = (char *) buffer->inc->name;
948 buffer->dir.name = (char *) ".";
952 if (dlen > pfile->max_include_len)
953 pfile->max_include_len = dlen;
955 buffer->dir.len = dlen;
956 buffer->dir.next = pfile->quote_include;
957 buffer->dir.sysp = pfile->map->sysp;
963 /* The file_name_map structure holds a mapping of file names for a
964 particular directory. This mapping is read from the file named
965 FILE_NAME_MAP_FILE in that directory. Such a file can be used to
966 map filenames on a file system with severe filename restrictions,
967 such as DOS. The format of the file name map file is just a series
968 of lines with two tokens on each line. The first token is the name
969 to map, and the second token is the actual name to use. */
970 struct file_name_map {
971 struct file_name_map *map_next;
976 #define FILE_NAME_MAP_FILE "header.gcc"
978 /* Read a space delimited string of unlimited length from a stdio
981 read_filename_string (ch, f)
989 set = alloc = xmalloc (len + 1);
993 while ((ch = getc (f)) != EOF && ! is_space (ch))
995 if (set - alloc == len)
998 alloc = xrealloc (alloc, len + 1);
999 set = alloc + len / 2;
1009 /* This structure holds a linked list of file name maps, one per directory. */
1010 struct file_name_map_list {
1011 struct file_name_map_list *map_list_next;
1012 char *map_list_name;
1013 struct file_name_map *map_list_map;
1016 /* Read the file name map file for DIRNAME. */
1017 static struct file_name_map *
1018 read_name_map (pfile, dirname)
1020 const char *dirname;
1022 struct file_name_map_list *map_list_ptr;
1026 /* Check the cache of directories, and mappings in their remap file. */
1027 for (map_list_ptr = CPP_OPTION (pfile, map_list); map_list_ptr;
1028 map_list_ptr = map_list_ptr->map_list_next)
1029 if (! strcmp (map_list_ptr->map_list_name, dirname))
1030 return map_list_ptr->map_list_map;
1032 map_list_ptr = ((struct file_name_map_list *)
1033 xmalloc (sizeof (struct file_name_map_list)));
1034 map_list_ptr->map_list_name = xstrdup (dirname);
1036 /* The end of the list ends in NULL. */
1037 map_list_ptr->map_list_map = NULL;
1039 name = (char *) alloca (strlen (dirname) + strlen (FILE_NAME_MAP_FILE) + 2);
1040 strcpy (name, dirname);
1043 strcat (name, FILE_NAME_MAP_FILE);
1044 f = fopen (name, "r");
1046 /* Silently return NULL if we cannot open. */
1051 while ((ch = getc (f)) != EOF)
1054 struct file_name_map *ptr;
1058 from = read_filename_string (ch, f);
1059 while ((ch = getc (f)) != EOF && is_hspace (ch))
1061 to = read_filename_string (ch, f);
1063 ptr = ((struct file_name_map *)
1064 xmalloc (sizeof (struct file_name_map)));
1065 ptr->map_from = from;
1067 /* Make the real filename absolute. */
1068 if (IS_ABSOLUTE_PATHNAME (to))
1072 ptr->map_to = concat (dirname, "/", to, NULL);
1076 ptr->map_next = map_list_ptr->map_list_map;
1077 map_list_ptr->map_list_map = ptr;
1079 while ((ch = getc (f)) != '\n')
1086 /* Add this information to the cache. */
1087 map_list_ptr->map_list_next = CPP_OPTION (pfile, map_list);
1088 CPP_OPTION (pfile, map_list) = map_list_ptr;
1090 return map_list_ptr->map_list_map;
1093 /* Remap an unsimplified path NAME based on the file_name_map (if any)
1096 remap_filename (pfile, name, loc)
1099 struct cpp_path *loc;
1101 struct file_name_map *map;
1102 const char *from, *p;
1105 if (! loc->name_map)
1107 /* Get a null-terminated path. */
1108 char *dname = alloca (loc->len + 1);
1109 memcpy (dname, loc->name, loc->len);
1110 dname[loc->len] = '\0';
1112 loc->name_map = read_name_map (pfile, dname);
1113 if (! loc->name_map)
1117 /* This works since NAME has not been simplified yet. */
1118 from = name + loc->len + 1;
1120 for (map = loc->name_map; map; map = map->map_next)
1121 if (!strcmp (map->map_from, from))
1124 /* Try to find a mapping file for the particular directory we are
1125 looking in. Thus #include <sys/types.h> will look up sys/types.h
1126 in /usr/include/header.gcc and look up types.h in
1127 /usr/include/sys/header.gcc. */
1128 p = strrchr (name, '/');
1132 /* We know p != name as absolute paths don't call remap_filename. */
1134 cpp_error (pfile, DL_ICE, "absolute file name in remap_filename");
1136 dir = (char *) alloca (p - name + 1);
1137 memcpy (dir, name, p - name);
1138 dir[p - name] = '\0';
1141 for (map = read_name_map (pfile, dir); map; map = map->map_next)
1142 if (! strcmp (map->map_from, from))
1148 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1149 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1150 directory of the including file.
1152 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1154 cpp_set_include_chains (pfile, quote, bracket, quote_ignores_source_dir)
1156 cpp_path *quote, *bracket;
1157 int quote_ignores_source_dir;
1159 pfile->quote_include = quote;
1160 pfile->bracket_include = quote;
1161 pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1162 pfile->max_include_len = 0;
1164 for (; quote; quote = quote->next)
1166 quote->name_map = NULL;
1167 quote->len = strlen (quote->name);
1168 if (quote->len > pfile->max_include_len)
1169 pfile->max_include_len = quote->len;
1170 if (quote == bracket)
1171 pfile->bracket_include = bracket;