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
34 # ifdef HAVE_MEMCHECK_H
35 # include <memcheck.h>
37 # include <valgrind.h>
40 /* Avoid #ifdef:s when we can help it. */
41 #define VALGRIND_DISCARD(x)
45 # include <sys/mman.h>
46 # ifndef MMAP_THRESHOLD
47 # define MMAP_THRESHOLD 3 /* Minimum page count to mmap the file. */
50 # define TEST_THRESHOLD(size, pagesize) \
51 (size / pagesize >= MMAP_THRESHOLD && (size % pagesize) != 0)
52 /* Use mmap if the file is big enough to be worth it (controlled
53 by MMAP_THRESHOLD) and if we can safely count on there being
54 at least one readable NUL byte after the end of the file's
55 contents. This is true for all tested operating systems when
56 the file size is not an exact multiple of the page size. */
58 # define SHOULD_MMAP(size, pagesize) TEST_THRESHOLD (size, pagesize)
60 # define WIN32_LEAN_AND_MEAN
62 /* Cygwin can't correctly emulate mmap under Windows 9x style systems so
63 disallow use of mmap on those systems. Windows 9x does not zero fill
64 memory at EOF and beyond, as required. */
65 # define SHOULD_MMAP(size, pagesize) ((GetVersion() & 0x80000000) \
66 ? 0 : TEST_THRESHOLD (size, pagesize))
70 #else /* No MMAP_FILE */
71 # undef MMAP_THRESHOLD
72 # define MMAP_THRESHOLD 0
79 /* If errno is inspected immediately after a system call fails, it will be
80 nonzero, and no error number will ever be zero. */
88 /* Suppress warning about function macros used w/o arguments in traditional
89 C. It is unlikely that glibc's strcmp macro helps this file at all. */
92 /* This structure is used for the table of all includes. */
94 const char *name; /* actual path name of file */
95 const char *header_name; /* the original header found */
96 const cpp_hashnode *cmacro; /* macro, if any, preventing reinclusion. */
97 const struct cpp_path *foundhere;
98 /* location in search path where file was
99 found, for #include_next and sysp. */
100 const unsigned char *buffer; /* pointer to cached file contents */
101 struct stat st; /* copy of stat(2) data for file */
102 int fd; /* fd open on file (short term storage only) */
103 int err_no; /* errno obtained if opening a file failed */
104 unsigned short include_count; /* number of times file has been read */
105 unsigned short refcnt; /* number of stacked buffers using this file */
106 unsigned char mapped; /* file buffer is mmapped */
107 unsigned char pch; /* 0: file not known to be a PCH.
109 (on return from find_include_file).
110 2: file is not and never will be a valid
112 3: file is always a valid precompiled
116 /* Variable length record files on VMS will have a stat size that includes
117 record control characters that won't be included in the read size. */
119 # define FAB_C_VAR 2 /* variable length records (see Starlet fabdef.h) */
120 # define STAT_SIZE_TOO_BIG(ST) ((ST).st_fab_rfm == FAB_C_VAR)
122 # define STAT_SIZE_TOO_BIG(ST) 0
125 /* The cmacro works like this: If it's NULL, the file is to be
126 included again. If it's NEVER_REREAD, the file is never to be
127 included again. Otherwise it is a macro hashnode, and the file is
128 to be included again if the macro is defined. */
129 #define NEVER_REREAD ((const cpp_hashnode *) -1)
130 #define DO_NOT_REREAD(inc) \
131 ((inc)->cmacro && ((inc)->cmacro == NEVER_REREAD \
132 || (inc)->cmacro->type == NT_MACRO))
133 #define NO_INCLUDE_PATH ((struct include_file *) -1)
134 #define INCLUDE_PCH_P(F) (((F)->pch & 1) != 0)
136 static struct file_name_map *read_name_map
137 PARAMS ((cpp_reader *, const char *));
138 static char *read_filename_string PARAMS ((int, FILE *));
139 static char *remap_filename PARAMS ((cpp_reader *, char *,
141 static struct cpp_path *search_from PARAMS ((cpp_reader *,
143 static struct include_file *
144 find_include_file PARAMS ((cpp_reader *, const cpp_token *,
146 static struct include_file *open_file PARAMS ((cpp_reader *, const char *));
147 static struct include_file *validate_pch PARAMS ((cpp_reader *,
150 static struct include_file *open_file_pch PARAMS ((cpp_reader *,
152 static int read_include_file PARAMS ((cpp_reader *, struct include_file *));
153 static bool stack_include_file PARAMS ((cpp_reader *, struct include_file *));
154 static void purge_cache PARAMS ((struct include_file *));
155 static void destroy_node PARAMS ((splay_tree_value));
156 static int report_missing_guard PARAMS ((splay_tree_node, void *));
157 static splay_tree_node find_or_create_entry PARAMS ((cpp_reader *,
159 static void handle_missing_header PARAMS ((cpp_reader *, const char *, int));
160 static int remove_component_p PARAMS ((const char *));
162 /* Set up the splay tree we use to store information about all the
163 file names seen in this compilation. We also have entries for each
164 file we tried to open but failed; this saves system calls since we
165 don't try to open it again in future.
167 The key of each node is the file name, after processing by
168 cpp_simplify_path. The path name may or may not be absolute.
169 The path string has been malloced, as is automatically freed by
170 registering free () as the splay tree key deletion function.
172 A node's value is a pointer to a struct include_file, and is never
175 _cpp_init_includes (pfile)
178 pfile->all_include_files
179 = splay_tree_new ((splay_tree_compare_fn) strcmp,
180 (splay_tree_delete_key_fn) free,
184 /* Tear down the splay tree. */
186 _cpp_cleanup_includes (pfile)
189 splay_tree_delete (pfile->all_include_files);
192 /* Free a node. The path string is automatically freed. */
197 struct include_file *f = (struct include_file *) v;
206 /* Mark a file to not be reread (e.g. #import, read failure). */
208 _cpp_never_reread (file)
209 struct include_file *file;
211 file->cmacro = NEVER_REREAD;
214 /* Lookup a filename, which is simplified after making a copy, and
215 create an entry if none exists. */
216 static splay_tree_node
217 find_or_create_entry (pfile, fname)
221 splay_tree_node node;
222 struct include_file *file;
223 char *name = xstrdup (fname);
225 cpp_simplify_path (name);
226 node = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) name);
231 file = xcnew (struct include_file);
233 file->header_name = name;
234 file->err_no = errno;
235 node = splay_tree_insert (pfile->all_include_files,
236 (splay_tree_key) file->name,
237 (splay_tree_value) file);
243 /* Enter a file name in the splay tree, for the sake of cpp_included. */
245 _cpp_fake_include (pfile, fname)
249 find_or_create_entry (pfile, fname);
252 /* Given a file name, look it up in the cache; if there is no entry,
253 create one with a non-NULL value (regardless of success in opening
254 the file). If the file doesn't exist or is inaccessible, this
255 entry is flagged so we don't attempt to open it again in the
256 future. If the file isn't open, open it. The empty string is
257 interpreted as stdin.
259 Returns an include_file structure with an open file descriptor on
260 success, or NULL on failure. */
261 static struct include_file *
262 open_file (pfile, filename)
264 const char *filename;
266 splay_tree_node nd = find_or_create_entry (pfile, filename);
267 struct include_file *file = (struct include_file *) nd->value;
271 /* Ugh. handle_missing_header () needs errno to be set. */
272 errno = file->err_no;
276 /* Don't reopen an idempotent file. */
277 if (DO_NOT_REREAD (file))
280 /* Don't reopen one which is already loaded. */
281 if (file->buffer != NULL)
284 /* We used to open files in nonblocking mode, but that caused more
285 problems than it solved. Do take care not to acquire a
286 controlling terminal by mistake (this can't happen on sane
287 systems, but paranoia is a virtue).
289 Use the three-argument form of open even though we aren't
290 specifying O_CREAT, to defend against broken system headers.
292 O_BINARY tells some runtime libraries (notably DJGPP) not to do
293 newline translation; we can handle DOS line breaks just fine
296 Special case: the empty string is translated to stdin. */
298 if (filename[0] == '\0')
302 /* For DJGPP redirected input is opened in text mode. Change it
304 if (! isatty (file->fd))
305 setmode (file->fd, O_BINARY);
309 file->fd = open (file->name, O_RDONLY | O_NOCTTY | O_BINARY, 0666);
311 if (file->fd != -1 && fstat (file->fd, &file->st) == 0)
313 if (!S_ISDIR (file->st.st_mode))
316 /* If it's a directory, we return null and continue the search
317 as the file we're looking for may appear elsewhere in the
324 file->err_no = errno;
328 static struct include_file *
329 validate_pch (pfile, filename, pchname)
331 const char *filename;
334 struct include_file * file;
336 file = open_file (pfile, pchname);
339 if ((file->pch & 2) == 0)
340 file->pch = pfile->cb.valid_pch (pfile, pchname, file->fd);
341 if (INCLUDE_PCH_P (file))
343 char *f = xstrdup (filename);
344 cpp_simplify_path (f);
345 file->header_name = f;
354 /* Like open_file, but also look for a precompiled header if (a) one exists
355 and (b) it is valid. */
356 static struct include_file *
357 open_file_pch (pfile, filename)
359 const char *filename;
361 if (filename[0] != '\0'
362 && pfile->cb.valid_pch != NULL)
364 size_t namelen = strlen (filename);
365 char *pchname = alloca (namelen + 5);
366 struct include_file * file;
369 memcpy (pchname, filename, namelen);
370 memcpy (pchname + namelen, ".gch", 5);
372 nd = find_or_create_entry (pfile, pchname);
373 file = (struct include_file *) nd->value;
377 if (stat (file->name, &file->st) == 0 && S_ISDIR (file->st.st_mode))
381 size_t subname_len = namelen + 64;
382 char *subname = xmalloc (subname_len);
384 thedir = opendir (pchname);
387 memcpy (subname, pchname, namelen + 4);
388 subname[namelen+4] = '/';
389 while ((d = readdir (thedir)) != NULL)
391 if (strlen (d->d_name) + namelen + 7 > subname_len)
393 subname_len = strlen (d->d_name) + namelen + 64;
394 subname = xrealloc (subname, subname_len);
396 strcpy (subname + namelen + 5, d->d_name);
397 file = validate_pch (pfile, filename, subname);
405 file = validate_pch (pfile, filename, pchname);
410 return open_file (pfile, filename);
413 /* Place the file referenced by INC into a new buffer on the buffer
414 stack, unless there are errors, or the file is not re-included
415 because of e.g. multiple-include guards. Returns true if a buffer
418 stack_include_file (pfile, inc)
420 struct include_file *inc;
424 const char *filename;
426 if (DO_NOT_REREAD (inc))
429 sysp = MAX ((pfile->map ? pfile->map->sysp : 0),
430 (inc->foundhere ? inc->foundhere->sysp : 0));
432 /* Add the file to the dependencies on its first inclusion. */
433 if (CPP_OPTION (pfile, deps.style) > !!sysp && !inc->include_count)
435 if (pfile->buffer || CPP_OPTION (pfile, deps.ignore_main_file) == 0)
436 deps_add_dep (pfile->deps, inc->name);
439 /* PCH files get dealt with immediately. */
440 if (INCLUDE_PCH_P (inc))
442 pfile->cb.read_pch (pfile, inc->name, inc->fd, inc->header_name);
451 if (read_include_file (pfile, inc))
453 /* If an error occurs, do not try to read this file again. */
454 _cpp_never_reread (inc);
457 /* Mark a regular, zero-length file never-reread. We read it,
458 NUL-terminate it, and stack it once, so preprocessing a main
459 file of zero length does not raise an error. */
460 if (S_ISREG (inc->st.st_mode) && inc->st.st_size == 0)
461 _cpp_never_reread (inc);
467 /* We don't want MI guard advice for the main file. */
468 inc->include_count++;
471 fp = cpp_push_buffer (pfile, inc->buffer, inc->st.st_size,
472 /* from_stage3 */ CPP_OPTION (pfile, preprocessed), 0);
476 /* Initialize controlling macro state. */
477 pfile->mi_valid = true;
478 pfile->mi_cmacro = 0;
480 /* Generate the call back. */
481 filename = inc->name;
482 if (*filename == '\0')
483 filename = "<stdin>";
484 _cpp_do_file_change (pfile, LC_ENTER, filename, 1, sysp);
489 /* Read the file referenced by INC into the file cache.
491 If fd points to a plain file, we might be able to mmap it; we can
492 definitely allocate the buffer all at once. If fd is a pipe or
493 terminal, we can't do either. If fd is something weird, like a
494 block device, we don't want to read it at all.
496 Unfortunately, different systems use different st.st_mode values
497 for pipes: some have S_ISFIFO, some S_ISSOCK, some are buggy and
498 zero the entire struct stat except a couple fields. Hence we don't
499 even try to figure out what something is, except for plain files
502 FIXME: Flush file cache and try again if we run out of memory. */
504 read_include_file (pfile, inc)
506 struct include_file *inc;
508 ssize_t size, offset, count;
511 static int pagesize = -1;
514 if (S_ISREG (inc->st.st_mode))
516 /* off_t might have a wider range than ssize_t - in other words,
517 the max size of a file might be bigger than the address
518 space. We can't handle a file that large. (Anyone with
519 a single source file bigger than 2GB needs to rethink
520 their coding style.) Some systems (e.g. AIX 4.1) define
521 SSIZE_MAX to be much smaller than the actual range of the
522 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
524 if (inc->st.st_size > INTTYPE_MAXIMUM (ssize_t))
526 cpp_error (pfile, DL_ERROR, "%s is too large", inc->name);
529 size = inc->st.st_size;
534 pagesize = getpagesize ();
536 if (SHOULD_MMAP (size, pagesize))
538 buf = (uchar *) mmap (0, size, PROT_READ, MAP_PRIVATE, inc->fd, 0);
539 if (buf == (uchar *) -1)
542 /* We must tell Valgrind that the byte at buf[size] is actually
543 readable. Discard the handle to avoid handle leak. */
544 VALGRIND_DISCARD (VALGRIND_MAKE_READABLE (buf + size, 1));
551 buf = (uchar *) xmalloc (size + 1);
553 while (offset < size)
555 count = read (inc->fd, buf + offset, size - offset);
560 if (!STAT_SIZE_TOO_BIG (inc->st))
561 cpp_error (pfile, DL_WARNING,
562 "%s is shorter than expected", inc->name);
564 buf = xrealloc (buf, size + 1);
565 inc->st.st_size = size;
570 /* The lexer requires that the buffer be NUL-terminated. */
574 else if (S_ISBLK (inc->st.st_mode))
576 cpp_error (pfile, DL_ERROR, "%s is a block device", inc->name);
581 /* 8 kilobytes is a sensible starting size. It ought to be
582 bigger than the kernel pipe buffer, and it's definitely
583 bigger than the majority of C source files. */
586 buf = (uchar *) xmalloc (size + 1);
588 while ((count = read (inc->fd, buf + offset, size - offset)) > 0)
594 buf = xrealloc (buf, size + 1);
600 if (offset + 1 < size)
601 buf = xrealloc (buf, offset + 1);
603 /* The lexer requires that the buffer be NUL-terminated. */
605 inc->st.st_size = offset;
612 cpp_errno (pfile, DL_ERROR, inc->name);
617 /* Drop INC's buffer from memory, if we are unlikely to need it again. */
620 struct include_file *inc;
627 /* Undo the previous annotation for the
628 known-zero-byte-after-mmap. Discard the handle to avoid
630 VALGRIND_DISCARD (VALGRIND_MAKE_NOACCESS (inc->buffer
631 + inc->st.st_size, 1));
632 munmap ((PTR) inc->buffer, inc->st.st_size);
636 free ((PTR) inc->buffer);
641 /* Return 1 if the file named by FNAME has been included before in
642 any context, 0 otherwise. */
644 cpp_included (pfile, fname)
648 struct cpp_path *path;
652 if (IS_ABSOLUTE_PATHNAME (fname))
654 /* Just look it up. */
655 nd = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) fname);
656 return (nd && nd->value);
659 /* Search directory path for the file. */
660 name = (char *) alloca (strlen (fname) + pfile->max_include_len + 2);
661 for (path = pfile->quote_include; path; path = path->next)
663 memcpy (name, path->name, path->len);
664 name[path->len] = '/';
665 strcpy (&name[path->len + 1], fname);
666 if (CPP_OPTION (pfile, remap))
667 n = remap_filename (pfile, name, path);
671 nd = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) n);
678 /* Search for HEADER. Return 0 if there is no such file (or it's
679 un-openable), in which case an error code will be in errno. If
680 there is no include path to use it returns NO_INCLUDE_PATH,
681 otherwise an include_file structure. If this request originates
682 from a directive of TYPE #include_next, set INCLUDE_NEXT to true. */
683 static struct include_file *
684 find_include_file (pfile, header, type)
686 const cpp_token *header;
687 enum include_type type;
689 const char *fname = (const char *) header->val.str.text;
690 struct cpp_path *path;
691 struct include_file *file;
694 if (IS_ABSOLUTE_PATHNAME (fname))
695 return open_file_pch (pfile, fname);
697 /* For #include_next, skip in the search path past the dir in which
698 the current file was found, but if it was found via an absolute
699 path use the normal search logic. */
700 if (type == IT_INCLUDE_NEXT && pfile->buffer->inc->foundhere)
701 path = pfile->buffer->inc->foundhere->next;
702 else if (header->type == CPP_HEADER_NAME)
703 path = pfile->bracket_include;
705 path = search_from (pfile, type);
709 cpp_error (pfile, DL_ERROR, "no include path in which to find %s",
711 return NO_INCLUDE_PATH;
714 /* Search directory path for the file. */
715 name = (char *) alloca (strlen (fname) + pfile->max_include_len + 2);
716 for (; path; path = path->next)
719 memcpy (name, path->name, len);
720 /* Don't turn / into // or // into ///; // may be a namespace
722 if (name[len-1] == '/')
725 strcpy (&name[len + 1], fname);
726 if (CPP_OPTION (pfile, remap))
727 n = remap_filename (pfile, name, path);
731 file = open_file_pch (pfile, n);
734 file->foundhere = path;
742 /* Not everyone who wants to set system-header-ness on a buffer can
743 see the details of a buffer. This is an exported interface because
744 fix-header needs it. */
746 cpp_make_system_header (pfile, syshdr, externc)
752 /* 1 = system header, 2 = system header to be treated as C. */
754 flags = 1 + (externc != 0);
755 _cpp_do_file_change (pfile, LC_RENAME, pfile->map->to_file,
756 SOURCE_LINE (pfile->map, pfile->line), flags);
759 /* Report on all files that might benefit from a multiple include guard.
762 _cpp_report_missing_guards (pfile)
766 splay_tree_foreach (pfile->all_include_files, report_missing_guard,
770 /* Callback function for splay_tree_foreach(). */
772 report_missing_guard (n, b)
776 struct include_file *f = (struct include_file *) n->value;
777 int *bannerp = (int *) b;
779 if (f && f->cmacro == 0 && f->include_count == 1)
783 fputs (_("Multiple include guards may be useful for:\n"), stderr);
786 fputs (f->name, stderr);
792 /* Create a dependency for file FNAME, or issue an error message as
793 appropriate. ANGLE_BRACKETS is nonzero if the file was bracketed
796 handle_missing_header (pfile, fname, angle_brackets)
802 = CPP_OPTION (pfile, deps.style) > (angle_brackets || pfile->map->sysp);
804 if (CPP_OPTION (pfile, deps.missing_files) && print_dep)
805 deps_add_dep (pfile->deps, fname);
806 /* If -M was specified, then don't count this as an error, because
807 we can still produce correct output. Otherwise, we can't produce
808 correct output, because there may be dependencies we need inside
809 the missing file, and we don't know what directory this missing
812 cpp_errno (pfile, CPP_OPTION (pfile, deps.style) && ! print_dep
813 ? DL_WARNING: DL_ERROR, fname);
816 /* Handles #include-family directives (distinguished by TYPE),
817 including HEADER, and the command line -imacros and -include.
818 Returns true if a buffer was stacked. */
820 _cpp_execute_include (pfile, header, type)
822 const cpp_token *header;
823 enum include_type type;
825 bool stacked = false;
826 struct include_file *inc = find_include_file (pfile, header, type);
829 handle_missing_header (pfile, (const char *) header->val.str.text,
830 header->type == CPP_HEADER_NAME);
831 else if (inc != NO_INCLUDE_PATH)
833 stacked = stack_include_file (pfile, inc);
835 if (type == IT_IMPORT)
836 _cpp_never_reread (inc);
842 /* Locate HEADER, and determine whether it is newer than the current
843 file. If it cannot be located or dated, return -1, if it is newer
844 newer, return 1, otherwise 0. */
846 _cpp_compare_file_date (pfile, header)
848 const cpp_token *header;
850 struct include_file *inc = find_include_file (pfile, header, 0);
852 if (inc == NULL || inc == NO_INCLUDE_PATH)
861 return inc->st.st_mtime > pfile->buffer->inc->st.st_mtime;
865 /* Push an input buffer and load it up with the contents of FNAME. If
866 FNAME is "", read standard input. Return true if a buffer was
869 _cpp_read_file (pfile, fname)
873 /* This uses open_file, because we don't allow a PCH to be used as
874 the toplevel compilation (that would prevent re-compiling an
875 existing PCH without deleting it first). */
876 struct include_file *f = open_file (pfile, fname);
880 cpp_errno (pfile, DL_ERROR, fname);
884 return stack_include_file (pfile, f);
887 /* Do appropriate cleanup when a file INC's buffer is popped off the
890 _cpp_pop_file_buffer (pfile, inc)
892 struct include_file *inc;
894 /* Record the inclusion-preventing macro, which could be NULL
895 meaning no controlling macro. */
896 if (pfile->mi_valid && inc->cmacro == NULL)
897 inc->cmacro = pfile->mi_cmacro;
899 /* Invalidate control macros in the #including file. */
900 pfile->mi_valid = false;
903 if (inc->refcnt == 0 && DO_NOT_REREAD (inc))
907 /* Returns the first place in the include chain to start searching for
908 "" includes. This involves stripping away the basename of the
909 current file, unless -I- was specified.
911 If we're handling -include or -imacros, use the "" chain, but with
912 the preprocessor's cwd prepended. */
913 static struct cpp_path *
914 search_from (pfile, type)
916 enum include_type type;
918 cpp_buffer *buffer = pfile->buffer;
921 /* Command line uses the cwd, and does not cache the result. */
922 if (type == IT_CMDLINE)
925 /* Ignore the current file's directory? */
926 if (pfile->quote_ignores_source_dir)
927 return pfile->quote_include;
929 if (! buffer->search_cached)
931 buffer->search_cached = 1;
933 dlen = lbasename (buffer->inc->name) - buffer->inc->name;
937 /* We don't guarantee NAME is null-terminated. This saves
938 allocating and freeing memory. Drop a trailing '/'. */
939 buffer->dir.name = (char *) buffer->inc->name;
946 buffer->dir.name = (char *) ".";
950 if (dlen > pfile->max_include_len)
951 pfile->max_include_len = dlen;
953 buffer->dir.len = dlen;
954 buffer->dir.next = pfile->quote_include;
955 buffer->dir.sysp = pfile->map->sysp;
961 /* The file_name_map structure holds a mapping of file names for a
962 particular directory. This mapping is read from the file named
963 FILE_NAME_MAP_FILE in that directory. Such a file can be used to
964 map filenames on a file system with severe filename restrictions,
965 such as DOS. The format of the file name map file is just a series
966 of lines with two tokens on each line. The first token is the name
967 to map, and the second token is the actual name to use. */
968 struct file_name_map {
969 struct file_name_map *map_next;
974 #define FILE_NAME_MAP_FILE "header.gcc"
976 /* Read a space delimited string of unlimited length from a stdio
979 read_filename_string (ch, f)
987 set = alloc = xmalloc (len + 1);
991 while ((ch = getc (f)) != EOF && ! is_space (ch))
993 if (set - alloc == len)
996 alloc = xrealloc (alloc, len + 1);
997 set = alloc + len / 2;
1007 /* This structure holds a linked list of file name maps, one per directory. */
1008 struct file_name_map_list {
1009 struct file_name_map_list *map_list_next;
1010 char *map_list_name;
1011 struct file_name_map *map_list_map;
1014 /* Read the file name map file for DIRNAME. */
1015 static struct file_name_map *
1016 read_name_map (pfile, dirname)
1018 const char *dirname;
1020 struct file_name_map_list *map_list_ptr;
1024 /* Check the cache of directories, and mappings in their remap file. */
1025 for (map_list_ptr = CPP_OPTION (pfile, map_list); map_list_ptr;
1026 map_list_ptr = map_list_ptr->map_list_next)
1027 if (! strcmp (map_list_ptr->map_list_name, dirname))
1028 return map_list_ptr->map_list_map;
1030 map_list_ptr = ((struct file_name_map_list *)
1031 xmalloc (sizeof (struct file_name_map_list)));
1032 map_list_ptr->map_list_name = xstrdup (dirname);
1034 /* The end of the list ends in NULL. */
1035 map_list_ptr->map_list_map = NULL;
1037 name = (char *) alloca (strlen (dirname) + strlen (FILE_NAME_MAP_FILE) + 2);
1038 strcpy (name, dirname);
1041 strcat (name, FILE_NAME_MAP_FILE);
1042 f = fopen (name, "r");
1044 /* Silently return NULL if we cannot open. */
1049 while ((ch = getc (f)) != EOF)
1052 struct file_name_map *ptr;
1056 from = read_filename_string (ch, f);
1057 while ((ch = getc (f)) != EOF && is_hspace (ch))
1059 to = read_filename_string (ch, f);
1061 ptr = ((struct file_name_map *)
1062 xmalloc (sizeof (struct file_name_map)));
1063 ptr->map_from = from;
1065 /* Make the real filename absolute. */
1066 if (IS_ABSOLUTE_PATHNAME (to))
1070 ptr->map_to = concat (dirname, "/", to, NULL);
1074 ptr->map_next = map_list_ptr->map_list_map;
1075 map_list_ptr->map_list_map = ptr;
1077 while ((ch = getc (f)) != '\n')
1084 /* Add this information to the cache. */
1085 map_list_ptr->map_list_next = CPP_OPTION (pfile, map_list);
1086 CPP_OPTION (pfile, map_list) = map_list_ptr;
1088 return map_list_ptr->map_list_map;
1091 /* Remap an unsimplified path NAME based on the file_name_map (if any)
1094 remap_filename (pfile, name, loc)
1097 struct cpp_path *loc;
1099 struct file_name_map *map;
1100 const char *from, *p;
1103 if (! loc->name_map)
1105 /* Get a null-terminated path. */
1106 char *dname = alloca (loc->len + 1);
1107 memcpy (dname, loc->name, loc->len);
1108 dname[loc->len] = '\0';
1110 loc->name_map = read_name_map (pfile, dname);
1111 if (! loc->name_map)
1115 /* This works since NAME has not been simplified yet. */
1116 from = name + loc->len + 1;
1118 for (map = loc->name_map; map; map = map->map_next)
1119 if (!strcmp (map->map_from, from))
1122 /* Try to find a mapping file for the particular directory we are
1123 looking in. Thus #include <sys/types.h> will look up sys/types.h
1124 in /usr/include/header.gcc and look up types.h in
1125 /usr/include/sys/header.gcc. */
1126 p = strrchr (name, '/');
1130 /* We know p != name as absolute paths don't call remap_filename. */
1132 cpp_error (pfile, DL_ICE, "absolute file name in remap_filename");
1134 dir = (char *) alloca (p - name + 1);
1135 memcpy (dir, name, p - name);
1136 dir[p - name] = '\0';
1139 for (map = read_name_map (pfile, dir); map; map = map->map_next)
1140 if (! strcmp (map->map_from, from))
1146 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1147 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1148 directory of the including file.
1150 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1152 cpp_set_include_chains (pfile, quote, bracket, quote_ignores_source_dir)
1154 cpp_path *quote, *bracket;
1155 int quote_ignores_source_dir;
1157 pfile->quote_include = quote;
1158 pfile->bracket_include = quote;
1159 pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1160 pfile->max_include_len = 0;
1162 for (; quote; quote = quote->next)
1164 quote->name_map = NULL;
1165 quote->len = strlen (quote->name);
1166 if (quote->len > pfile->max_include_len)
1167 pfile->max_include_len = quote->len;
1168 if (quote == bracket)
1169 pfile->bracket_include = bracket;
1173 /* Returns true if it is safe to remove the final component of path,
1174 when it is followed by a ".." component. We use lstat to avoid
1175 symlinks if we have it. If not, we can still catch errors with
1178 remove_component_p (path)
1185 result = lstat (path, &s);
1187 result = stat (path, &s);
1190 /* There's no guarantee that errno will be unchanged, even on
1191 success. Cygwin's lstat(), for example, will often set errno to
1192 ENOSYS. In case of success, reset errno to zero. */
1196 return result == 0 && S_ISDIR (s.st_mode);
1199 /* Simplify a path name in place, deleting redundant components. This
1200 reduces OS overhead and guarantees that equivalent paths compare
1201 the same (modulo symlinks).
1204 foo/bar/../quux foo/quux
1208 //quux //quux (POSIX allows leading // as a namespace escape)
1210 Guarantees no trailing slashes. All transforms reduce the length
1211 of the string. Returns PATH. errno is 0 if no error occurred;
1212 nonzero if an error occurred when using stat () or lstat (). */
1214 cpp_simplify_path (path)
1215 char *path ATTRIBUTE_UNUSED;
1219 char *base, *orig_base;
1223 /* Don't overflow the empty path by putting a '.' in it below. */
1227 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
1228 /* Convert all backslashes to slashes. */
1229 for (from = path; *from; from++)
1230 if (*from == '\\') *from = '/';
1232 /* Skip over leading drive letter if present. */
1233 if (ISALPHA (path[0]) && path[1] == ':')
1234 from = to = &path[2];
1241 /* Remove redundant leading /s. */
1250 /* 3 or more initial /s are equivalent to 1 /. */
1251 while (*++from == '/');
1253 /* On some hosts // differs from /; Posix allows this. */
1258 base = orig_base = to;
1263 while (*from == '/')
1271 if (from[1] == '\0')
1278 else if (from[1] == '.' && (from[2] == '/' || from[2] == '\0'))
1280 /* Don't simplify if there was no previous component. */
1281 if (absolute && orig_base == to)
1286 /* Don't simplify if the previous component was "../",
1287 or if an error has already occurred with (l)stat. */
1288 if (base != to && errno == 0)
1290 /* We don't back up if it's a symlink. */
1292 if (remove_component_p (path))
1294 while (to > base && *to != '/')
1304 /* Add the component separator. */
1308 /* Copy this component until the trailing null or '/'. */
1309 while (*from != '\0' && *from != '/')
1316 /* Change the empty string to "." so that it is not treated as stdin.