1 /* Part of CPP library. (include file handling)
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1998,
3 1999, 2000, 2001 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 #else /* No MMAP_FILE */
38 # undef MMAP_THRESHOLD
39 # define MMAP_THRESHOLD 0
46 /* If errno is inspected immediately after a system call fails, it will be
47 nonzero, and no error number will ever be zero. */
55 /* Suppress warning about function macros used w/o arguments in traditional
56 C. It is unlikely that glibc's strcmp macro helps this file at all. */
59 /* This structure is used for the table of all includes. */
62 const char *name; /* actual path name of file */
63 const cpp_hashnode *cmacro; /* macro, if any, preventing reinclusion. */
64 const struct search_path *foundhere;
65 /* location in search path where file was
66 found, for #include_next and sysp. */
67 const unsigned char *buffer; /* pointer to cached file contents */
68 struct stat st; /* copy of stat(2) data for file */
69 int fd; /* fd open on file (short term storage only) */
70 unsigned short include_count; /* number of times file has been read */
71 unsigned short refcnt; /* number of stacked buffers using this file */
72 unsigned char mapped; /* file buffer is mmapped */
73 unsigned char defined; /* cmacro prevents inclusion in this state */
76 /* The cmacro works like this: If it's NULL, the file is to be
77 included again. If it's NEVER_REREAD, the file is never to be
78 included again. Otherwise it is a macro hashnode, and the file is
79 to be included again if the macro is defined or not as specified by
81 #define NEVER_REREAD ((const cpp_hashnode *)-1)
82 #define DO_NOT_REREAD(inc) \
83 ((inc)->cmacro && ((inc)->cmacro == NEVER_REREAD \
84 || ((inc)->cmacro->type == NT_MACRO) == (inc)->defined))
85 #define NO_INCLUDE_PATH ((struct include_file *) -1)
87 static struct file_name_map *read_name_map
88 PARAMS ((cpp_reader *, const char *));
89 static char *read_filename_string PARAMS ((int, FILE *));
90 static char *remap_filename PARAMS ((cpp_reader *, char *,
91 struct search_path *));
92 static struct search_path *search_from PARAMS ((cpp_reader *,
93 struct include_file *));
94 static struct include_file *
95 find_include_file PARAMS ((cpp_reader *, const cpp_token *, int));
96 static struct include_file *open_file PARAMS ((cpp_reader *, const char *));
97 static void read_include_file PARAMS ((cpp_reader *, struct include_file *));
98 static void stack_include_file PARAMS ((cpp_reader *, struct include_file *));
99 static void purge_cache PARAMS ((struct include_file *));
100 static void destroy_node PARAMS ((splay_tree_value));
101 static int report_missing_guard PARAMS ((splay_tree_node, void *));
102 static splay_tree_node find_or_create_entry PARAMS ((cpp_reader *,
104 static void handle_missing_header PARAMS ((cpp_reader *, const char *, int));
106 /* Set up the splay tree we use to store information about all the
107 file names seen in this compilation. We also have entries for each
108 file we tried to open but failed; this saves system calls since we
109 don't try to open it again in future.
111 The key of each node is the file name, after processing by
112 _cpp_simplify_pathname. The path name may or may not be absolute.
113 The path string has been malloced, as is automatically freed by
114 registering free () as the splay tree key deletion function.
116 A node's value is a pointer to a struct include_file, and is never
119 _cpp_init_includes (pfile)
122 pfile->all_include_files
123 = splay_tree_new ((splay_tree_compare_fn) strcmp,
124 (splay_tree_delete_key_fn) free,
128 /* Tear down the splay tree. */
130 _cpp_cleanup_includes (pfile)
133 splay_tree_delete (pfile->all_include_files);
136 /* Free a node. The path string is automatically freed. */
141 struct include_file *f = (struct include_file *)v;
150 /* Mark a file to not be reread (e.g. #import, read failure). */
152 _cpp_never_reread (file)
153 struct include_file *file;
155 file->cmacro = NEVER_REREAD;
158 /* Lookup a simplified filename, and create an entry if none exists. */
159 static splay_tree_node
160 find_or_create_entry (pfile, fname)
164 splay_tree_node node;
165 struct include_file *file;
167 node = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) fname);
170 file = xcnew (struct include_file);
171 file->name = xstrdup (fname);
172 node = splay_tree_insert (pfile->all_include_files,
173 (splay_tree_key) file->name,
174 (splay_tree_value) file);
180 /* Enter a simplified file name in the splay tree, for the sake of
183 _cpp_fake_include (pfile, fname)
187 find_or_create_entry (pfile, fname);
190 /* Given a file name, look it up in the cache; if there is no entry,
191 create one with a non-NULL value (regardless of success in opening
192 the file). If the file doesn't exist or is inaccessible, this
193 entry is flagged so we don't attempt to open it again in the
194 future. If the file isn't open, open it. The empty string is
195 interpreted as stdin.
197 Returns an include_file structure with an open file descriptor on
198 success, or NULL on failure. */
200 static struct include_file *
201 open_file (pfile, filename)
203 const char *filename;
205 splay_tree_node nd = find_or_create_entry (pfile, filename);
206 struct include_file *file = (struct include_file *) nd->value;
208 /* Don't retry opening if we failed previously. */
212 /* Don't reopen an idempotent file. */
213 if (DO_NOT_REREAD (file))
216 /* Don't reopen one which is already loaded. */
217 if (file->buffer != NULL)
220 /* We used to open files in nonblocking mode, but that caused more
221 problems than it solved. Do take care not to acquire a
222 controlling terminal by mistake (this can't happen on sane
223 systems, but paranoia is a virtue).
225 Use the three-argument form of open even though we aren't
226 specifying O_CREAT, to defend against broken system headers.
228 O_BINARY tells some runtime libraries (notably DJGPP) not to do
229 newline translation; we can handle DOS line breaks just fine
232 Special case: the empty string is translated to stdin. */
234 if (filename[0] == '\0')
237 file->fd = open (filename, O_RDONLY | O_NOCTTY | O_BINARY, 0666);
239 if (file->fd != -1 && fstat (file->fd, &file->st) == 0)
241 /* Mark a regular, zero-length file never-reread now. */
242 if (S_ISREG (file->st.st_mode) && file->st.st_size == 0)
244 _cpp_never_reread (file);
252 /* Don't issue an error message if the file doesn't exist. */
253 if (errno != ENOENT && errno != ENOTDIR)
254 cpp_error_from_errno (pfile, filename);
256 /* Create a negative node for this path, and return null. */
262 /* Place the file referenced by INC into a new buffer on PFILE's
263 stack. If there are errors, or the file should not be re-included,
264 a null (zero-length) buffer is pushed. */
267 stack_include_file (pfile, inc)
269 struct include_file *inc;
275 /* We'll try removing deps_sysp after the release of 3.0. */
276 deps_sysp = pfile->system_include_depth != 0;
277 sysp = ((pfile->buffer && pfile->buffer->sysp)
278 || (inc->foundhere && inc->foundhere->sysp));
280 /* For -M, add the file to the dependencies on its first inclusion. */
281 if (CPP_OPTION (pfile, print_deps) > deps_sysp && !inc->include_count)
282 deps_add_dep (pfile->deps, inc->name);
284 if (! DO_NOT_REREAD (inc))
288 read_include_file (pfile, inc);
289 len = inc->st.st_size;
293 /* We don't want MI guard advice for the main file. */
294 inc->include_count++;
296 /* Handle -H option. */
297 if (CPP_OPTION (pfile, print_include_names))
299 for (fp = pfile->buffer; fp; fp = fp->prev)
301 fprintf (stderr, " %s\n", inc->name);
307 fp = cpp_push_buffer (pfile, inc->buffer, len, BUF_FILE, inc->name);
311 fp->search_from = search_from (pfile, inc);
313 /* Initialise controlling macro state. */
314 pfile->mi_state = MI_OUTSIDE;
315 pfile->mi_cmacro = 0;
316 pfile->include_depth++;
318 /* Generate the call back. */
320 _cpp_do_file_change (pfile, FC_ENTER, 0, 0);
324 /* Read the file referenced by INC into the file cache.
326 If fd points to a plain file, we might be able to mmap it; we can
327 definitely allocate the buffer all at once. If fd is a pipe or
328 terminal, we can't do either. If fd is something weird, like a
329 block device or a directory, we don't want to read it at all.
331 Unfortunately, different systems use different st.st_mode values
332 for pipes: some have S_ISFIFO, some S_ISSOCK, some are buggy and
333 zero the entire struct stat except a couple fields. Hence we don't
334 even try to figure out what something is, except for plain files,
335 directories, and block devices.
337 FIXME: Flush file cache and try again if we run out of memory. */
340 read_include_file (pfile, inc)
342 struct include_file *inc;
344 ssize_t size, offset, count;
347 static int pagesize = -1;
350 if (S_ISREG (inc->st.st_mode))
352 /* off_t might have a wider range than ssize_t - in other words,
353 the max size of a file might be bigger than the address
354 space. We can't handle a file that large. (Anyone with
355 a single source file bigger than 2GB needs to rethink
356 their coding style.) Some systems (e.g. AIX 4.1) define
357 SSIZE_MAX to be much smaller than the actual range of the
358 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
360 if (inc->st.st_size > INTTYPE_MAXIMUM (ssize_t))
362 cpp_error (pfile, "%s is too large", inc->name);
365 size = inc->st.st_size;
370 pagesize = getpagesize ();
372 if (size / pagesize >= MMAP_THRESHOLD)
374 buf = (U_CHAR *) mmap (0, size, PROT_READ, MAP_PRIVATE, inc->fd, 0);
375 if (buf == (U_CHAR *)-1)
382 buf = (U_CHAR *) xmalloc (size);
384 while (offset < size)
386 count = read (inc->fd, buf + offset, size - offset);
391 cpp_warning (pfile, "%s is shorter than expected", inc->name);
398 else if (S_ISBLK (inc->st.st_mode))
400 cpp_error (pfile, "%s is a block device", inc->name);
403 else if (S_ISDIR (inc->st.st_mode))
405 cpp_error (pfile, "%s is a directory", inc->name);
410 /* 8 kilobytes is a sensible starting size. It ought to be
411 bigger than the kernel pipe buffer, and it's definitely
412 bigger than the majority of C source files. */
415 buf = (U_CHAR *) xmalloc (size);
417 while ((count = read (inc->fd, buf + offset, size - offset)) > 0)
421 buf = xrealloc (buf, (size *= 2));
427 buf = xrealloc (buf, offset);
428 inc->st.st_size = offset;
437 cpp_error_from_errno (pfile, inc->name);
439 /* Do not try to read this file again. */
442 _cpp_never_reread (inc);
448 struct include_file *inc;
454 munmap ((PTR) inc->buffer, inc->st.st_size);
457 free ((PTR) inc->buffer);
462 /* Return 1 if the file named by FNAME has been included before in
463 any context, 0 otherwise. */
465 cpp_included (pfile, fname)
469 struct search_path *path;
473 if (IS_ABSOLUTE_PATHNAME (fname))
475 /* Just look it up. */
476 nd = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) fname);
477 return (nd && nd->value);
480 /* Search directory path for the file. */
481 name = (char *) alloca (strlen (fname) + pfile->max_include_len + 2);
482 for (path = CPP_OPTION (pfile, quote_include); path; path = path->next)
484 memcpy (name, path->name, path->len);
485 name[path->len] = '/';
486 strcpy (&name[path->len + 1], fname);
487 if (CPP_OPTION (pfile, remap))
488 n = remap_filename (pfile, name, path);
490 n = _cpp_simplify_pathname (name);
492 nd = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) n);
499 /* Search for HEADER. Return 0 if there is no such file (or it's
500 un-openable), in which case an error code will be in errno. If
501 there is no include path to use it returns NO_INCLUDE_PATH,
502 otherwise an include_file structure. If this request originates
503 from a #include_next directive, set INCLUDE_NEXT to true. */
505 static struct include_file *
506 find_include_file (pfile, header, include_next)
508 const cpp_token *header;
511 const char *fname = (const char *) header->val.str.text;
512 struct search_path *path;
513 struct include_file *file;
516 if (IS_ABSOLUTE_PATHNAME (fname))
517 return open_file (pfile, fname);
519 /* For #include_next, skip in the search path past the dir in which
520 the current file was found, but if it was found via an absolute
521 path use the normal search logic. */
522 if (include_next && pfile->buffer->inc->foundhere)
523 path = pfile->buffer->inc->foundhere->next;
524 else if (header->type == CPP_HEADER_NAME)
525 path = CPP_OPTION (pfile, bracket_include);
527 path = pfile->buffer->search_from;
531 cpp_error (pfile, "No include path in which to find %s", fname);
532 return NO_INCLUDE_PATH;
535 /* Search directory path for the file. */
536 name = (char *) alloca (strlen (fname) + pfile->max_include_len + 2);
537 for (; path; path = path->next)
539 memcpy (name, path->name, path->len);
540 name[path->len] = '/';
541 strcpy (&name[path->len + 1], fname);
542 if (CPP_OPTION (pfile, remap))
543 n = remap_filename (pfile, name, path);
545 n = _cpp_simplify_pathname (name);
547 file = open_file (pfile, n);
550 file->foundhere = path;
558 /* Not everyone who wants to set system-header-ness on a buffer can
559 see the details of a buffer. This is an exported interface because
560 fix-header needs it. */
562 cpp_make_system_header (pfile, syshdr, externc)
568 /* 1 = system header, 2 = system header to be treated as C. */
570 flags = 1 + (externc != 0);
571 pfile->buffer->sysp = flags;
572 _cpp_do_file_change (pfile, FC_RENAME, pfile->buffer->nominal_fname,
573 pfile->buffer->lineno);
576 /* Report on all files that might benefit from a multiple include guard.
579 _cpp_report_missing_guards (pfile)
583 splay_tree_foreach (pfile->all_include_files, report_missing_guard,
588 report_missing_guard (n, b)
592 struct include_file *f = (struct include_file *) n->value;
593 int *bannerp = (int *)b;
595 if (f && f->cmacro == 0 && f->include_count == 1)
599 fputs (_("Multiple include guards may be useful for:\n"), stderr);
602 fputs (f->name, stderr);
608 /* Create a dependency, or issue an error message as appropriate. */
610 handle_missing_header (pfile, fname, angle_brackets)
615 /* We will try making the RHS pfile->buffer->sysp after 3.0. */
616 int print_dep = CPP_PRINT_DEPS(pfile) > (angle_brackets
617 || pfile->system_include_depth);
618 if (CPP_OPTION (pfile, print_deps_missing_files) && print_dep)
620 if (!angle_brackets || IS_ABSOLUTE_PATHNAME (fname))
621 deps_add_dep (pfile->deps, fname);
624 /* If requested as a system header, assume it belongs in
625 the first system header directory. */
626 struct search_path *ptr = CPP_OPTION (pfile, bracket_include);
628 int len = 0, fname_len = strlen (fname);
633 p = (char *) alloca (len + fname_len + 2);
636 memcpy (p, ptr->name, len);
639 memcpy (p + len, fname, fname_len + 1);
640 _cpp_simplify_pathname (p);
641 deps_add_dep (pfile->deps, p);
644 /* If -M was specified, then don't count this as an error, because
645 we can still produce correct output. Otherwise, we can't produce
646 correct output, because there may be dependencies we need inside
647 the missing file, and we don't know what directory this missing
648 file exists in. FIXME: Use a future cpp_diagnotic_with_errno ()
649 for both of these cases. */
650 else if (CPP_PRINT_DEPS (pfile) && ! print_dep)
651 cpp_warning (pfile, "%s: %s", fname, xstrerror (errno));
653 cpp_error_from_errno (pfile, fname);
657 _cpp_execute_include (pfile, header, no_reinclude, include_next)
659 const cpp_token *header;
663 struct include_file *inc;
665 /* Help protect #include or similar from recursion. */
666 if (pfile->buffer_stack_depth >= CPP_STACK_MAX)
668 cpp_fatal (pfile, "#include nested too deeply");
672 /* Check we've tidied up #include before entering the buffer. */
673 if (pfile->context->prev)
675 cpp_ice (pfile, "attempt to push file buffer with contexts stacked");
679 inc = find_include_file (pfile, header, include_next);
682 handle_missing_header (pfile, (const char *) header->val.str.text,
683 header->type == CPP_HEADER_NAME);
684 else if (inc != NO_INCLUDE_PATH)
686 if (header->type == CPP_HEADER_NAME)
687 pfile->system_include_depth++;
689 stack_include_file (pfile, inc);
692 _cpp_never_reread (inc);
696 /* Locate HEADER, and determine whether it is newer than the current
697 file. If it cannot be located or dated, return -1, if it is newer
698 newer, return 1, otherwise 0. */
700 _cpp_compare_file_date (pfile, header)
702 const cpp_token *header;
704 struct include_file *inc = find_include_file (pfile, header, 0);
706 if (inc == NULL || inc == NO_INCLUDE_PATH)
715 return inc->st.st_mtime > pfile->buffer->inc->st.st_mtime;
719 /* Push an input buffer and load it up with the contents of FNAME.
720 If FNAME is "", read standard input. */
722 _cpp_read_file (pfile, fname)
726 struct include_file *f = open_file (pfile, fname);
730 cpp_error_from_errno (pfile, fname);
734 stack_include_file (pfile, f);
738 /* Do appropriate cleanup when a file buffer is popped off the input
741 _cpp_pop_file_buffer (pfile, buf)
745 struct include_file *inc = buf->inc;
747 if (pfile->system_include_depth)
748 pfile->system_include_depth--;
749 if (pfile->include_depth)
750 pfile->include_depth--;
752 /* Record the inclusion-preventing macro and its definedness. */
753 if (pfile->mi_state == MI_OUTSIDE && inc->cmacro == NULL)
755 /* This could be NULL meaning no controlling macro. */
756 inc->cmacro = pfile->mi_cmacro;
760 /* Invalidate control macros in the #including file. */
761 pfile->mi_state = MI_FAILED;
764 if (inc->refcnt == 0 && DO_NOT_REREAD (inc))
768 /* Returns the first place in the include chain to start searching for
769 "" includes. This involves stripping away the basename of the
770 current file, unless -I- was specified. */
771 static struct search_path *
772 search_from (pfile, inc)
774 struct include_file *inc;
776 cpp_buffer *buffer = pfile->buffer;
779 /* Ignore the current file's directory if -I- was given. */
780 if (CPP_OPTION (pfile, ignore_srcdir))
781 return CPP_OPTION (pfile, quote_include);
783 dlen = lbasename (inc->name) - inc->name;
786 /* We don't guarantee NAME is null-terminated. This saves
787 allocating and freeing memory, and duplicating it when faking
788 buffers in cpp_push_buffer. Drop a trailing '/'. */
789 buffer->dir.name = inc->name;
795 buffer->dir.name = ".";
799 if (dlen > pfile->max_include_len)
800 pfile->max_include_len = dlen;
802 buffer->dir.len = dlen;
803 buffer->dir.next = CPP_OPTION (pfile, quote_include);
804 buffer->dir.sysp = buffer->sysp;
809 /* The file_name_map structure holds a mapping of file names for a
810 particular directory. This mapping is read from the file named
811 FILE_NAME_MAP_FILE in that directory. Such a file can be used to
812 map filenames on a file system with severe filename restrictions,
813 such as DOS. The format of the file name map file is just a series
814 of lines with two tokens on each line. The first token is the name
815 to map, and the second token is the actual name to use. */
819 struct file_name_map *map_next;
824 #define FILE_NAME_MAP_FILE "header.gcc"
826 /* Read a space delimited string of unlimited length from a stdio
830 read_filename_string (ch, f)
838 set = alloc = xmalloc (len + 1);
842 while ((ch = getc (f)) != EOF && ! is_space(ch))
844 if (set - alloc == len)
847 alloc = xrealloc (alloc, len + 1);
848 set = alloc + len / 2;
858 /* This structure holds a linked list of file name maps, one per directory. */
860 struct file_name_map_list
862 struct file_name_map_list *map_list_next;
864 struct file_name_map *map_list_map;
867 /* Read the file name map file for DIRNAME. */
869 static struct file_name_map *
870 read_name_map (pfile, dirname)
874 register struct file_name_map_list *map_list_ptr;
878 /* Check the cache of directories, and mappings in their remap file. */
879 for (map_list_ptr = CPP_OPTION (pfile, map_list); map_list_ptr;
880 map_list_ptr = map_list_ptr->map_list_next)
881 if (! strcmp (map_list_ptr->map_list_name, dirname))
882 return map_list_ptr->map_list_map;
884 map_list_ptr = ((struct file_name_map_list *)
885 xmalloc (sizeof (struct file_name_map_list)));
886 map_list_ptr->map_list_name = xstrdup (dirname);
888 /* The end of the list ends in NULL. */
889 map_list_ptr->map_list_map = NULL;
891 name = (char *) alloca (strlen (dirname) + strlen (FILE_NAME_MAP_FILE) + 2);
892 strcpy (name, dirname);
895 strcat (name, FILE_NAME_MAP_FILE);
896 f = fopen (name, "r");
898 /* Silently return NULL if we cannot open. */
902 int dirlen = strlen (dirname);
904 while ((ch = getc (f)) != EOF)
907 struct file_name_map *ptr;
911 from = read_filename_string (ch, f);
912 while ((ch = getc (f)) != EOF && is_hspace(ch))
914 to = read_filename_string (ch, f);
916 ptr = ((struct file_name_map *)
917 xmalloc (sizeof (struct file_name_map)));
918 ptr->map_from = from;
920 /* Make the real filename absolute. */
921 if (IS_ABSOLUTE_PATHNAME (to))
925 ptr->map_to = xmalloc (dirlen + strlen (to) + 2);
926 strcpy (ptr->map_to, dirname);
927 ptr->map_to[dirlen] = '/';
928 strcpy (ptr->map_to + dirlen + 1, to);
931 /* Simplify the result now. */
932 _cpp_simplify_pathname (ptr->map_to);
934 ptr->map_next = map_list_ptr->map_list_map;
935 map_list_ptr->map_list_map = ptr;
937 while ((ch = getc (f)) != '\n')
944 /* Add this information to the cache. */
945 map_list_ptr->map_list_next = CPP_OPTION (pfile, map_list);
946 CPP_OPTION (pfile, map_list) = map_list_ptr;
948 return map_list_ptr->map_list_map;
951 /* Remap an unsimplified path NAME based on the file_name_map (if any)
954 remap_filename (pfile, name, loc)
957 struct search_path *loc;
959 struct file_name_map *map;
960 const char *from, *p;
965 /* Get a null-terminated path. */
966 char *dname = alloca (loc->len + 1);
967 memcpy (dname, loc->name, loc->len);
968 dname[loc->len] = '\0';
970 loc->name_map = read_name_map (pfile, dname);
975 /* This works since NAME has not been simplified yet. */
976 from = name + loc->len + 1;
978 for (map = loc->name_map; map; map = map->map_next)
979 if (!strcmp (map->map_from, from))
982 /* Try to find a mapping file for the particular directory we are
983 looking in. Thus #include <sys/types.h> will look up sys/types.h
984 in /usr/include/header.gcc and look up types.h in
985 /usr/include/sys/header.gcc. */
986 p = strrchr (name, '/');
990 /* We know p != name as absolute paths don't call remap_filename. */
992 cpp_ice (pfile, "absolute file name in remap_filename");
994 dir = (char *) alloca (p - name + 1);
995 memcpy (dir, name, p - name);
996 dir[p - name] = '\0';
999 for (map = read_name_map (pfile, dir); map; map = map->map_next)
1000 if (! strcmp (map->map_from, from))
1006 /* Simplify a path name in place, deleting redundant components. This
1007 reduces OS overhead and guarantees that equivalent paths compare
1008 the same (modulo symlinks).
1011 foo/bar/../quux foo/quux
1015 //quux //quux (POSIX allows leading // as a namespace escape)
1017 Guarantees no trailing slashes. All transforms reduce the length
1018 of the string. Returns PATH;
1021 _cpp_simplify_pathname (path)
1028 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
1029 /* Convert all backslashes to slashes. */
1030 for (from = path; *from; from++)
1031 if (*from == '\\') *from = '/';
1033 /* Skip over leading drive letter if present. */
1034 if (ISALPHA (path[0]) && path[1] == ':')
1035 from = to = &path[2];
1042 /* Remove redundant initial /s. */
1051 /* 3 or more initial /s are equivalent to 1 /. */
1052 while (*++from == '/');
1054 /* On some hosts // differs from /; Posix allows this. */
1062 while (*from == '/')
1065 if (from[0] == '.' && from[1] == '/')
1067 else if (from[0] == '.' && from[1] == '\0')
1069 else if (from[0] == '.' && from[1] == '.' && from[2] == '/')
1086 while (to > base && *to != '/') to--;
1092 else if (from[0] == '.' && from[1] == '.' && from[2] == '\0')
1105 while (to > base && *to != '/') to--;
1112 /* Copy this component and trailing /, if any. */
1113 while ((*to++ = *from++) != '/')
1125 /* Trim trailing slash */
1126 if (to[0] == '/' && (!absolute || to > path+1))
1129 /* Change the empty string to "." so that stat() on the result
1130 will always work. */