1 /* Part of CPP library. (include file handling)
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1998,
3 1999, 2000, 2001, 2002 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. */
29 #include "splay-tree.h"
32 # include <sys/mman.h>
33 # ifndef MMAP_THRESHOLD
34 # define MMAP_THRESHOLD 3 /* Minimum page count to mmap the file. */
37 # define TEST_THRESHOLD(size, pagesize) \
38 (size / pagesize >= MMAP_THRESHOLD && (size % pagesize) != 0)
39 /* Use mmap if the file is big enough to be worth it (controlled
40 by MMAP_THRESHOLD) and if we can safely count on there being
41 at least one readable NUL byte after the end of the file's
42 contents. This is true for all tested operating systems when
43 the file size is not an exact multiple of the page size. */
45 # define SHOULD_MMAP(size, pagesize) TEST_THRESHOLD (size, pagesize)
47 # define WIN32_LEAN_AND_MEAN
49 /* Cygwin can't correctly emulate mmap under Windows 9x style systems so
50 disallow use of mmap on those systems. Windows 9x does not zero fill
51 memory at EOF and beyond, as required. */
52 # define SHOULD_MMAP(size, pagesize) ((GetVersion() & 0x80000000) \
53 ? 0 : TEST_THRESHOLD (size, pagesize))
57 #else /* No MMAP_FILE */
58 # undef MMAP_THRESHOLD
59 # define MMAP_THRESHOLD 0
66 /* If errno is inspected immediately after a system call fails, it will be
67 nonzero, and no error number will ever be zero. */
75 /* Suppress warning about function macros used w/o arguments in traditional
76 C. It is unlikely that glibc's strcmp macro helps this file at all. */
79 /* This structure is used for the table of all includes. */
82 const char *name; /* actual path name of file */
83 const cpp_hashnode *cmacro; /* macro, if any, preventing reinclusion. */
84 const struct search_path *foundhere;
85 /* location in search path where file was
86 found, for #include_next and sysp. */
87 const unsigned char *buffer; /* pointer to cached file contents */
88 struct stat st; /* copy of stat(2) data for file */
89 int fd; /* fd open on file (short term storage only) */
90 int err_no; /* errno obtained if opening a file failed */
91 unsigned short include_count; /* number of times file has been read */
92 unsigned short refcnt; /* number of stacked buffers using this file */
93 unsigned char mapped; /* file buffer is mmapped */
96 /* Variable length record files on VMS will have a stat size that includes
97 record control characters that won't be included in the read size. */
99 # define FAB_C_VAR 2 /* variable length records (see Starlet fabdef.h) */
100 # define STAT_SIZE_TOO_BIG(ST) ((ST).st_fab_rfm == FAB_C_VAR)
102 # define STAT_SIZE_TOO_BIG(ST) 0
105 /* The cmacro works like this: If it's NULL, the file is to be
106 included again. If it's NEVER_REREAD, the file is never to be
107 included again. Otherwise it is a macro hashnode, and the file is
108 to be included again if the macro is defined. */
109 #define NEVER_REREAD ((const cpp_hashnode *)-1)
110 #define DO_NOT_REREAD(inc) \
111 ((inc)->cmacro && ((inc)->cmacro == NEVER_REREAD \
112 || (inc)->cmacro->type == NT_MACRO))
113 #define NO_INCLUDE_PATH ((struct include_file *) -1)
115 static struct file_name_map *read_name_map
116 PARAMS ((cpp_reader *, const char *));
117 static char *read_filename_string PARAMS ((int, FILE *));
118 static char *remap_filename PARAMS ((cpp_reader *, char *,
119 struct search_path *));
120 static struct search_path *search_from PARAMS ((cpp_reader *,
122 static struct include_file *
123 find_include_file PARAMS ((cpp_reader *, const cpp_token *,
125 static struct include_file *open_file PARAMS ((cpp_reader *, const char *));
126 static int read_include_file PARAMS ((cpp_reader *, struct include_file *));
127 static bool stack_include_file PARAMS ((cpp_reader *, struct include_file *));
128 static void purge_cache PARAMS ((struct include_file *));
129 static void destroy_node PARAMS ((splay_tree_value));
130 static int report_missing_guard PARAMS ((splay_tree_node, void *));
131 static splay_tree_node find_or_create_entry PARAMS ((cpp_reader *,
133 static void handle_missing_header PARAMS ((cpp_reader *, const char *, int));
134 static int remove_component_p PARAMS ((const char *));
136 /* Set up the splay tree we use to store information about all the
137 file names seen in this compilation. We also have entries for each
138 file we tried to open but failed; this saves system calls since we
139 don't try to open it again in future.
141 The key of each node is the file name, after processing by
142 _cpp_simplify_pathname. The path name may or may not be absolute.
143 The path string has been malloced, as is automatically freed by
144 registering free () as the splay tree key deletion function.
146 A node's value is a pointer to a struct include_file, and is never
149 _cpp_init_includes (pfile)
152 pfile->all_include_files
153 = splay_tree_new ((splay_tree_compare_fn) strcmp,
154 (splay_tree_delete_key_fn) free,
158 /* Tear down the splay tree. */
160 _cpp_cleanup_includes (pfile)
163 splay_tree_delete (pfile->all_include_files);
166 /* Free a node. The path string is automatically freed. */
171 struct include_file *f = (struct include_file *)v;
180 /* Mark a file to not be reread (e.g. #import, read failure). */
182 _cpp_never_reread (file)
183 struct include_file *file;
185 file->cmacro = NEVER_REREAD;
188 /* Lookup a filename, which is simplified after making a copy, and
189 create an entry if none exists. errno is nonzero iff a (reported)
190 stat() error occurred during simplification. */
191 static splay_tree_node
192 find_or_create_entry (pfile, fname)
196 splay_tree_node node;
197 struct include_file *file;
198 char *name = xstrdup (fname);
200 _cpp_simplify_pathname (name);
201 node = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) name);
206 file = xcnew (struct include_file);
208 file->err_no = errno;
209 node = splay_tree_insert (pfile->all_include_files,
210 (splay_tree_key) file->name,
211 (splay_tree_value) file);
217 /* Enter a file name in the splay tree, for the sake of cpp_included. */
219 _cpp_fake_include (pfile, fname)
223 find_or_create_entry (pfile, fname);
226 /* Given a file name, look it up in the cache; if there is no entry,
227 create one with a non-NULL value (regardless of success in opening
228 the file). If the file doesn't exist or is inaccessible, this
229 entry is flagged so we don't attempt to open it again in the
230 future. If the file isn't open, open it. The empty string is
231 interpreted as stdin.
233 Returns an include_file structure with an open file descriptor on
234 success, or NULL on failure. */
235 static struct include_file *
236 open_file (pfile, filename)
238 const char *filename;
240 splay_tree_node nd = find_or_create_entry (pfile, filename);
241 struct include_file *file = (struct include_file *) nd->value;
245 /* Ugh. handle_missing_header () needs errno to be set. */
246 errno = file->err_no;
250 /* Don't reopen an idempotent file. */
251 if (DO_NOT_REREAD (file))
254 /* Don't reopen one which is already loaded. */
255 if (file->buffer != NULL)
258 /* We used to open files in nonblocking mode, but that caused more
259 problems than it solved. Do take care not to acquire a
260 controlling terminal by mistake (this can't happen on sane
261 systems, but paranoia is a virtue).
263 Use the three-argument form of open even though we aren't
264 specifying O_CREAT, to defend against broken system headers.
266 O_BINARY tells some runtime libraries (notably DJGPP) not to do
267 newline translation; we can handle DOS line breaks just fine
270 Special case: the empty string is translated to stdin. */
272 if (filename[0] == '\0')
275 file->fd = open (file->name, O_RDONLY | O_NOCTTY | O_BINARY, 0666);
277 if (file->fd != -1 && fstat (file->fd, &file->st) == 0)
279 if (!S_ISDIR (file->st.st_mode))
282 /* If it's a directory, we return null and continue the search
283 as the file we're looking for may appear elsewhere in the
290 file->err_no = errno;
294 /* Place the file referenced by INC into a new buffer on the buffer
295 stack, unless there are errors, or the file is not re-included
296 because of e.g. multiple-include guards. Returns true if a buffer
299 stack_include_file (pfile, inc)
301 struct include_file *inc;
305 const char *filename;
307 if (DO_NOT_REREAD (inc))
310 sysp = MAX ((pfile->map ? pfile->map->sysp : 0),
311 (inc->foundhere ? inc->foundhere->sysp : 0));
313 /* For -M, add the file to the dependencies on its first inclusion. */
314 if (CPP_OPTION (pfile, print_deps) > sysp && !inc->include_count)
315 deps_add_dep (pfile->deps, inc->name);
320 if (read_include_file (pfile, inc))
322 /* If an error occurs, do not try to read this file again. */
323 _cpp_never_reread (inc);
326 /* Mark a regular, zero-length file never-reread. We read it,
327 NUL-terminate it, and stack it once, so preprocessing a main
328 file of zero length does not raise an error. */
329 if (S_ISREG (inc->st.st_mode) && inc->st.st_size == 0)
330 _cpp_never_reread (inc);
336 /* We don't want MI guard advice for the main file. */
337 inc->include_count++;
340 fp = cpp_push_buffer (pfile, inc->buffer, inc->st.st_size,
341 /* from_stage3 */ CPP_OPTION (pfile, preprocessed), 0);
345 /* Initialise controlling macro state. */
346 pfile->mi_valid = true;
347 pfile->mi_cmacro = 0;
349 /* Generate the call back. */
350 filename = inc->name;
351 if (*filename == '\0')
352 filename = "<stdin>";
353 _cpp_do_file_change (pfile, LC_ENTER, filename, 1, sysp);
358 /* Read the file referenced by INC into the file cache.
360 If fd points to a plain file, we might be able to mmap it; we can
361 definitely allocate the buffer all at once. If fd is a pipe or
362 terminal, we can't do either. If fd is something weird, like a
363 block device, we don't want to read it at all.
365 Unfortunately, different systems use different st.st_mode values
366 for pipes: some have S_ISFIFO, some S_ISSOCK, some are buggy and
367 zero the entire struct stat except a couple fields. Hence we don't
368 even try to figure out what something is, except for plain files
371 FIXME: Flush file cache and try again if we run out of memory. */
373 read_include_file (pfile, inc)
375 struct include_file *inc;
377 ssize_t size, offset, count;
380 static int pagesize = -1;
383 if (S_ISREG (inc->st.st_mode))
385 /* off_t might have a wider range than ssize_t - in other words,
386 the max size of a file might be bigger than the address
387 space. We can't handle a file that large. (Anyone with
388 a single source file bigger than 2GB needs to rethink
389 their coding style.) Some systems (e.g. AIX 4.1) define
390 SSIZE_MAX to be much smaller than the actual range of the
391 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
393 if (inc->st.st_size > INTTYPE_MAXIMUM (ssize_t))
395 cpp_error (pfile, "%s is too large", inc->name);
398 size = inc->st.st_size;
403 pagesize = getpagesize ();
405 if (SHOULD_MMAP (size, pagesize))
407 buf = (U_CHAR *) mmap (0, size, PROT_READ, MAP_PRIVATE, inc->fd, 0);
408 if (buf == (U_CHAR *)-1)
415 buf = (U_CHAR *) xmalloc (size + 1);
417 while (offset < size)
419 count = read (inc->fd, buf + offset, size - offset);
424 if (!STAT_SIZE_TOO_BIG (inc->st))
426 (pfile, "%s is shorter than expected", inc->name);
428 buf = xrealloc (buf, size + 1);
429 inc->st.st_size = size;
434 /* The lexer requires that the buffer be NUL-terminated. */
438 else if (S_ISBLK (inc->st.st_mode))
440 cpp_error (pfile, "%s is a block device", inc->name);
445 /* 8 kilobytes is a sensible starting size. It ought to be
446 bigger than the kernel pipe buffer, and it's definitely
447 bigger than the majority of C source files. */
450 buf = (U_CHAR *) xmalloc (size + 1);
452 while ((count = read (inc->fd, buf + offset, size - offset)) > 0)
458 buf = xrealloc (buf, size + 1);
464 if (offset + 1 < size)
465 buf = xrealloc (buf, offset + 1);
467 /* The lexer requires that the buffer be NUL-terminated. */
469 inc->st.st_size = offset;
476 cpp_error_from_errno (pfile, inc->name);
481 /* Drop INC's buffer from memory, if we are unlikely to need it again. */
484 struct include_file *inc;
490 munmap ((PTR) inc->buffer, inc->st.st_size);
493 free ((PTR) inc->buffer);
498 /* Return 1 if the file named by FNAME has been included before in
499 any context, 0 otherwise. */
501 cpp_included (pfile, fname)
505 struct search_path *path;
509 if (IS_ABSOLUTE_PATHNAME (fname))
511 /* Just look it up. */
512 nd = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) fname);
513 return (nd && nd->value);
516 /* Search directory path for the file. */
517 name = (char *) alloca (strlen (fname) + pfile->max_include_len + 2);
518 for (path = CPP_OPTION (pfile, quote_include); path; path = path->next)
520 memcpy (name, path->name, path->len);
521 name[path->len] = '/';
522 strcpy (&name[path->len + 1], fname);
523 if (CPP_OPTION (pfile, remap))
524 n = remap_filename (pfile, name, path);
528 nd = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) n);
535 /* Search for HEADER. Return 0 if there is no such file (or it's
536 un-openable), in which case an error code will be in errno. If
537 there is no include path to use it returns NO_INCLUDE_PATH,
538 otherwise an include_file structure. If this request originates
539 from a directive of TYPE #include_next, set INCLUDE_NEXT to true. */
540 static struct include_file *
541 find_include_file (pfile, header, type)
543 const cpp_token *header;
544 enum include_type type;
546 const char *fname = (const char *) header->val.str.text;
547 struct search_path *path;
548 struct include_file *file;
551 if (IS_ABSOLUTE_PATHNAME (fname))
552 return open_file (pfile, fname);
554 /* For #include_next, skip in the search path past the dir in which
555 the current file was found, but if it was found via an absolute
556 path use the normal search logic. */
557 if (type == IT_INCLUDE_NEXT && pfile->buffer->inc->foundhere)
558 path = pfile->buffer->inc->foundhere->next;
559 else if (header->type == CPP_HEADER_NAME)
560 path = CPP_OPTION (pfile, bracket_include);
562 path = search_from (pfile, type);
566 cpp_error (pfile, "no include path in which to find %s", fname);
567 return NO_INCLUDE_PATH;
570 /* Search directory path for the file. */
571 name = (char *) alloca (strlen (fname) + pfile->max_include_len + 2);
572 for (; path; path = path->next)
575 memcpy (name, path->name, len);
576 /* Don't turn / into // or // into ///; // may be a namespace
578 if (name[len-1] == '/')
581 strcpy (&name[len + 1], fname);
582 if (CPP_OPTION (pfile, remap))
583 n = remap_filename (pfile, name, path);
587 file = open_file (pfile, n);
590 file->foundhere = path;
598 /* Not everyone who wants to set system-header-ness on a buffer can
599 see the details of a buffer. This is an exported interface because
600 fix-header needs it. */
602 cpp_make_system_header (pfile, syshdr, externc)
608 /* 1 = system header, 2 = system header to be treated as C. */
610 flags = 1 + (externc != 0);
611 _cpp_do_file_change (pfile, LC_RENAME, pfile->map->to_file,
612 SOURCE_LINE (pfile->map, pfile->line), flags);
615 /* Report on all files that might benefit from a multiple include guard.
618 _cpp_report_missing_guards (pfile)
622 splay_tree_foreach (pfile->all_include_files, report_missing_guard,
626 /* Callback function for splay_tree_foreach(). */
628 report_missing_guard (n, b)
632 struct include_file *f = (struct include_file *) n->value;
633 int *bannerp = (int *)b;
635 if (f && f->cmacro == 0 && f->include_count == 1)
639 fputs (_("Multiple include guards may be useful for:\n"), stderr);
642 fputs (f->name, stderr);
648 /* Create a dependency for file FNAME, or issue an error message as
649 appropriate. ANGLE_BRACKETS is non-zero if the file was bracketed
652 handle_missing_header (pfile, fname, angle_brackets)
657 int print_dep = CPP_PRINT_DEPS(pfile) > (angle_brackets || pfile->map->sysp);
659 if (CPP_OPTION (pfile, print_deps_missing_files) && print_dep)
661 if (!angle_brackets || IS_ABSOLUTE_PATHNAME (fname))
662 deps_add_dep (pfile->deps, fname);
665 /* If requested as a system header, assume it belongs in
666 the first system header directory. */
667 struct search_path *ptr = CPP_OPTION (pfile, bracket_include);
669 int len = 0, fname_len = strlen (fname);
674 p = (char *) alloca (len + fname_len + 2);
677 memcpy (p, ptr->name, len);
680 memcpy (p + len, fname, fname_len + 1);
681 deps_add_dep (pfile->deps, p);
684 /* If -M was specified, then don't count this as an error, because
685 we can still produce correct output. Otherwise, we can't produce
686 correct output, because there may be dependencies we need inside
687 the missing file, and we don't know what directory this missing
688 file exists in. FIXME: Use a future cpp_diagnostic_with_errno ()
689 for both of these cases. */
690 else if (CPP_PRINT_DEPS (pfile) && ! print_dep)
691 cpp_warning (pfile, "%s: %s", fname, xstrerror (errno));
693 cpp_error_from_errno (pfile, fname);
696 /* Handles #include-family directives (distinguished by TYPE),
697 including HEADER, and the command line -imacros and -include.
698 Returns true if a buffer was stacked. */
700 _cpp_execute_include (pfile, header, type)
702 const cpp_token *header;
703 enum include_type type;
705 bool stacked = false;
706 struct include_file *inc = find_include_file (pfile, header, type);
709 handle_missing_header (pfile, (const char *) header->val.str.text,
710 header->type == CPP_HEADER_NAME);
711 else if (inc != NO_INCLUDE_PATH)
713 stacked = stack_include_file (pfile, inc);
715 if (type == IT_IMPORT)
716 _cpp_never_reread (inc);
722 /* Locate HEADER, and determine whether it is newer than the current
723 file. If it cannot be located or dated, return -1, if it is newer
724 newer, return 1, otherwise 0. */
726 _cpp_compare_file_date (pfile, header)
728 const cpp_token *header;
730 struct include_file *inc = find_include_file (pfile, header, 0);
732 if (inc == NULL || inc == NO_INCLUDE_PATH)
741 return inc->st.st_mtime > pfile->buffer->inc->st.st_mtime;
745 /* Push an input buffer and load it up with the contents of FNAME. If
746 FNAME is "", read standard input. Return true if a buffer was
749 _cpp_read_file (pfile, fname)
753 struct include_file *f = open_file (pfile, fname);
757 cpp_error_from_errno (pfile, fname);
761 return stack_include_file (pfile, f);
764 /* Do appropriate cleanup when a file INC's buffer is popped off the
765 input stack. Push the next -include file, if any remain. */
767 _cpp_pop_file_buffer (pfile, inc)
769 struct include_file *inc;
773 /* Record the inclusion-preventing macro, which could be NULL
774 meaning no controlling macro. */
775 if (pfile->mi_valid && inc->cmacro == NULL)
776 inc->cmacro = pfile->mi_cmacro;
778 /* Invalidate control macros in the #including file. */
779 pfile->mi_valid = false;
782 if (inc->refcnt == 0 && DO_NOT_REREAD (inc))
785 /* Don't generate a callback for popping the main file. */
788 _cpp_do_file_change (pfile, LC_LEAVE, 0, 0, 0);
790 /* Finally, push the next -included file, if any. */
791 if (!pfile->buffer->prev)
792 pushed = _cpp_push_next_buffer (pfile);
798 /* Returns the first place in the include chain to start searching for
799 "" includes. This involves stripping away the basename of the
800 current file, unless -I- was specified.
802 If we're handling -include or -imacros, use the "" chain, but with
803 the preprocessor's cwd prepended. */
804 static struct search_path *
805 search_from (pfile, type)
807 enum include_type type;
809 cpp_buffer *buffer = pfile->buffer;
812 /* Command line uses the cwd, and does not cache the result. */
813 if (type == IT_CMDLINE)
816 /* Ignore the current file's directory if -I- was given. */
817 if (CPP_OPTION (pfile, ignore_srcdir))
818 return CPP_OPTION (pfile, quote_include);
820 if (! buffer->search_cached)
822 buffer->search_cached = 1;
824 dlen = lbasename (buffer->inc->name) - buffer->inc->name;
828 /* We don't guarantee NAME is null-terminated. This saves
829 allocating and freeing memory. Drop a trailing '/'. */
830 buffer->dir.name = buffer->inc->name;
837 buffer->dir.name = ".";
841 if (dlen > pfile->max_include_len)
842 pfile->max_include_len = dlen;
844 buffer->dir.len = dlen;
845 buffer->dir.next = CPP_OPTION (pfile, quote_include);
846 buffer->dir.sysp = pfile->map->sysp;
852 /* The file_name_map structure holds a mapping of file names for a
853 particular directory. This mapping is read from the file named
854 FILE_NAME_MAP_FILE in that directory. Such a file can be used to
855 map filenames on a file system with severe filename restrictions,
856 such as DOS. The format of the file name map file is just a series
857 of lines with two tokens on each line. The first token is the name
858 to map, and the second token is the actual name to use. */
861 struct file_name_map *map_next;
866 #define FILE_NAME_MAP_FILE "header.gcc"
868 /* Read a space delimited string of unlimited length from a stdio
871 read_filename_string (ch, f)
879 set = alloc = xmalloc (len + 1);
883 while ((ch = getc (f)) != EOF && ! is_space(ch))
885 if (set - alloc == len)
888 alloc = xrealloc (alloc, len + 1);
889 set = alloc + len / 2;
899 /* This structure holds a linked list of file name maps, one per directory. */
900 struct file_name_map_list
902 struct file_name_map_list *map_list_next;
904 struct file_name_map *map_list_map;
907 /* Read the file name map file for DIRNAME. */
908 static struct file_name_map *
909 read_name_map (pfile, dirname)
913 struct file_name_map_list *map_list_ptr;
917 /* Check the cache of directories, and mappings in their remap file. */
918 for (map_list_ptr = CPP_OPTION (pfile, map_list); map_list_ptr;
919 map_list_ptr = map_list_ptr->map_list_next)
920 if (! strcmp (map_list_ptr->map_list_name, dirname))
921 return map_list_ptr->map_list_map;
923 map_list_ptr = ((struct file_name_map_list *)
924 xmalloc (sizeof (struct file_name_map_list)));
925 map_list_ptr->map_list_name = xstrdup (dirname);
927 /* The end of the list ends in NULL. */
928 map_list_ptr->map_list_map = NULL;
930 name = (char *) alloca (strlen (dirname) + strlen (FILE_NAME_MAP_FILE) + 2);
931 strcpy (name, dirname);
934 strcat (name, FILE_NAME_MAP_FILE);
935 f = fopen (name, "r");
937 /* Silently return NULL if we cannot open. */
941 int dirlen = strlen (dirname);
943 while ((ch = getc (f)) != EOF)
946 struct file_name_map *ptr;
950 from = read_filename_string (ch, f);
951 while ((ch = getc (f)) != EOF && is_hspace(ch))
953 to = read_filename_string (ch, f);
955 ptr = ((struct file_name_map *)
956 xmalloc (sizeof (struct file_name_map)));
957 ptr->map_from = from;
959 /* Make the real filename absolute. */
960 if (IS_ABSOLUTE_PATHNAME (to))
964 ptr->map_to = xmalloc (dirlen + strlen (to) + 2);
965 strcpy (ptr->map_to, dirname);
966 ptr->map_to[dirlen] = '/';
967 strcpy (ptr->map_to + dirlen + 1, to);
971 ptr->map_next = map_list_ptr->map_list_map;
972 map_list_ptr->map_list_map = ptr;
974 while ((ch = getc (f)) != '\n')
981 /* Add this information to the cache. */
982 map_list_ptr->map_list_next = CPP_OPTION (pfile, map_list);
983 CPP_OPTION (pfile, map_list) = map_list_ptr;
985 return map_list_ptr->map_list_map;
988 /* Remap an unsimplified path NAME based on the file_name_map (if any)
991 remap_filename (pfile, name, loc)
994 struct search_path *loc;
996 struct file_name_map *map;
997 const char *from, *p;
1000 if (! loc->name_map)
1002 /* Get a null-terminated path. */
1003 char *dname = alloca (loc->len + 1);
1004 memcpy (dname, loc->name, loc->len);
1005 dname[loc->len] = '\0';
1007 loc->name_map = read_name_map (pfile, dname);
1008 if (! loc->name_map)
1012 /* This works since NAME has not been simplified yet. */
1013 from = name + loc->len + 1;
1015 for (map = loc->name_map; map; map = map->map_next)
1016 if (!strcmp (map->map_from, from))
1019 /* Try to find a mapping file for the particular directory we are
1020 looking in. Thus #include <sys/types.h> will look up sys/types.h
1021 in /usr/include/header.gcc and look up types.h in
1022 /usr/include/sys/header.gcc. */
1023 p = strrchr (name, '/');
1027 /* We know p != name as absolute paths don't call remap_filename. */
1029 cpp_ice (pfile, "absolute file name in remap_filename");
1031 dir = (char *) alloca (p - name + 1);
1032 memcpy (dir, name, p - name);
1033 dir[p - name] = '\0';
1036 for (map = read_name_map (pfile, dir); map; map = map->map_next)
1037 if (! strcmp (map->map_from, from))
1043 /* Returns true if it is safe to remove the final component of path,
1044 when it is followed by a ".." component. We use lstat to avoid
1045 symlinks if we have it. If not, we can still catch errors with
1048 remove_component_p (path)
1055 result = lstat (path, &s);
1057 result = stat (path, &s);
1060 /* There's no guarantee that errno will be unchanged, even on
1061 success. Cygwin's lstat(), for example, will often set errno to
1062 ENOSYS. In case of success, reset errno to zero. */
1066 return result == 0 && S_ISDIR (s.st_mode);
1069 /* Simplify a path name in place, deleting redundant components. This
1070 reduces OS overhead and guarantees that equivalent paths compare
1071 the same (modulo symlinks).
1074 foo/bar/../quux foo/quux
1078 //quux //quux (POSIX allows leading // as a namespace escape)
1080 Guarantees no trailing slashes. All transforms reduce the length
1081 of the string. Returns PATH. errno is 0 if no error occurred;
1082 nonzero if an error occurred when using stat () or lstat (). */
1084 _cpp_simplify_pathname (path)
1089 char *base, *orig_base;
1093 /* Don't overflow the empty path by putting a '.' in it below. */
1097 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
1098 /* Convert all backslashes to slashes. */
1099 for (from = path; *from; from++)
1100 if (*from == '\\') *from = '/';
1102 /* Skip over leading drive letter if present. */
1103 if (ISALPHA (path[0]) && path[1] == ':')
1104 from = to = &path[2];
1111 /* Remove redundant leading /s. */
1120 /* 3 or more initial /s are equivalent to 1 /. */
1121 while (*++from == '/');
1123 /* On some hosts // differs from /; Posix allows this. */
1128 base = orig_base = to;
1133 while (*from == '/')
1141 if (from[1] == '\0')
1148 else if (from[1] == '.' && (from[2] == '/' || from[2] == '\0'))
1150 /* Don't simplify if there was no previous component. */
1151 if (absolute && orig_base == to)
1156 /* Don't simplify if the previous component was "../",
1157 or if an error has already occurred with (l)stat. */
1158 if (base != to && errno == 0)
1160 /* We don't back up if it's a symlink. */
1162 if (remove_component_p (path))
1164 while (to > base && *to != '/')
1174 /* Add the component separator. */
1178 /* Copy this component until the trailing null or '/'. */
1179 while (*from != '\0' && *from != '/')
1186 /* Change the empty string to "." so that it is not treated as stdin.