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')
276 /* For DJGPP redirected input is opened in text mode. Change it
278 if (! isatty (file->fd))
279 setmode (file->fd, O_BINARY);
283 file->fd = open (file->name, O_RDONLY | O_NOCTTY | O_BINARY, 0666);
285 if (file->fd != -1 && fstat (file->fd, &file->st) == 0)
287 if (!S_ISDIR (file->st.st_mode))
290 /* If it's a directory, we return null and continue the search
291 as the file we're looking for may appear elsewhere in the
298 file->err_no = errno;
302 /* Place the file referenced by INC into a new buffer on the buffer
303 stack, unless there are errors, or the file is not re-included
304 because of e.g. multiple-include guards. Returns true if a buffer
307 stack_include_file (pfile, inc)
309 struct include_file *inc;
313 const char *filename;
315 if (DO_NOT_REREAD (inc))
318 sysp = MAX ((pfile->map ? pfile->map->sysp : 0),
319 (inc->foundhere ? inc->foundhere->sysp : 0));
321 /* Add the file to the dependencies on its first inclusion. */
322 if (CPP_OPTION (pfile, deps.style) > !!sysp && !inc->include_count)
324 if (pfile->buffer || CPP_OPTION (pfile, deps.ignore_main_file) == 0)
325 deps_add_dep (pfile->deps, inc->name);
331 if (read_include_file (pfile, inc))
333 /* If an error occurs, do not try to read this file again. */
334 _cpp_never_reread (inc);
337 /* Mark a regular, zero-length file never-reread. We read it,
338 NUL-terminate it, and stack it once, so preprocessing a main
339 file of zero length does not raise an error. */
340 if (S_ISREG (inc->st.st_mode) && inc->st.st_size == 0)
341 _cpp_never_reread (inc);
347 /* We don't want MI guard advice for the main file. */
348 inc->include_count++;
351 fp = cpp_push_buffer (pfile, inc->buffer, inc->st.st_size,
352 /* from_stage3 */ CPP_OPTION (pfile, preprocessed), 0);
356 /* Initialise controlling macro state. */
357 pfile->mi_valid = true;
358 pfile->mi_cmacro = 0;
360 /* Generate the call back. */
361 filename = inc->name;
362 if (*filename == '\0')
363 filename = "<stdin>";
364 _cpp_do_file_change (pfile, LC_ENTER, filename, 1, sysp);
369 /* Read the file referenced by INC into the file cache.
371 If fd points to a plain file, we might be able to mmap it; we can
372 definitely allocate the buffer all at once. If fd is a pipe or
373 terminal, we can't do either. If fd is something weird, like a
374 block device, we don't want to read it at all.
376 Unfortunately, different systems use different st.st_mode values
377 for pipes: some have S_ISFIFO, some S_ISSOCK, some are buggy and
378 zero the entire struct stat except a couple fields. Hence we don't
379 even try to figure out what something is, except for plain files
382 FIXME: Flush file cache and try again if we run out of memory. */
384 read_include_file (pfile, inc)
386 struct include_file *inc;
388 ssize_t size, offset, count;
391 static int pagesize = -1;
394 if (S_ISREG (inc->st.st_mode))
396 /* off_t might have a wider range than ssize_t - in other words,
397 the max size of a file might be bigger than the address
398 space. We can't handle a file that large. (Anyone with
399 a single source file bigger than 2GB needs to rethink
400 their coding style.) Some systems (e.g. AIX 4.1) define
401 SSIZE_MAX to be much smaller than the actual range of the
402 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
404 if (inc->st.st_size > INTTYPE_MAXIMUM (ssize_t))
406 cpp_error (pfile, DL_ERROR, "%s is too large", inc->name);
409 size = inc->st.st_size;
414 pagesize = getpagesize ();
416 if (SHOULD_MMAP (size, pagesize))
418 buf = (uchar *) mmap (0, size, PROT_READ, MAP_PRIVATE, inc->fd, 0);
419 if (buf == (uchar *)-1)
426 buf = (uchar *) xmalloc (size + 1);
428 while (offset < size)
430 count = read (inc->fd, buf + offset, size - offset);
435 if (!STAT_SIZE_TOO_BIG (inc->st))
436 cpp_error (pfile, DL_WARNING,
437 "%s is shorter than expected", inc->name);
439 buf = xrealloc (buf, size + 1);
440 inc->st.st_size = size;
445 /* The lexer requires that the buffer be NUL-terminated. */
449 else if (S_ISBLK (inc->st.st_mode))
451 cpp_error (pfile, DL_ERROR, "%s is a block device", inc->name);
456 /* 8 kilobytes is a sensible starting size. It ought to be
457 bigger than the kernel pipe buffer, and it's definitely
458 bigger than the majority of C source files. */
461 buf = (uchar *) xmalloc (size + 1);
463 while ((count = read (inc->fd, buf + offset, size - offset)) > 0)
469 buf = xrealloc (buf, size + 1);
475 if (offset + 1 < size)
476 buf = xrealloc (buf, offset + 1);
478 /* The lexer requires that the buffer be NUL-terminated. */
480 inc->st.st_size = offset;
487 cpp_errno (pfile, DL_ERROR, inc->name);
492 /* Drop INC's buffer from memory, if we are unlikely to need it again. */
495 struct include_file *inc;
501 munmap ((PTR) inc->buffer, inc->st.st_size);
504 free ((PTR) inc->buffer);
509 /* Return 1 if the file named by FNAME has been included before in
510 any context, 0 otherwise. */
512 cpp_included (pfile, fname)
516 struct search_path *path;
520 if (IS_ABSOLUTE_PATHNAME (fname))
522 /* Just look it up. */
523 nd = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) fname);
524 return (nd && nd->value);
527 /* Search directory path for the file. */
528 name = (char *) alloca (strlen (fname) + pfile->max_include_len + 2);
529 for (path = CPP_OPTION (pfile, quote_include); path; path = path->next)
531 memcpy (name, path->name, path->len);
532 name[path->len] = '/';
533 strcpy (&name[path->len + 1], fname);
534 if (CPP_OPTION (pfile, remap))
535 n = remap_filename (pfile, name, path);
539 nd = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) n);
546 /* Search for HEADER. Return 0 if there is no such file (or it's
547 un-openable), in which case an error code will be in errno. If
548 there is no include path to use it returns NO_INCLUDE_PATH,
549 otherwise an include_file structure. If this request originates
550 from a directive of TYPE #include_next, set INCLUDE_NEXT to true. */
551 static struct include_file *
552 find_include_file (pfile, header, type)
554 const cpp_token *header;
555 enum include_type type;
557 const char *fname = (const char *) header->val.str.text;
558 struct search_path *path;
559 struct include_file *file;
562 if (IS_ABSOLUTE_PATHNAME (fname))
563 return open_file (pfile, fname);
565 /* For #include_next, skip in the search path past the dir in which
566 the current file was found, but if it was found via an absolute
567 path use the normal search logic. */
568 if (type == IT_INCLUDE_NEXT && pfile->buffer->inc->foundhere)
569 path = pfile->buffer->inc->foundhere->next;
570 else if (header->type == CPP_HEADER_NAME)
571 path = CPP_OPTION (pfile, bracket_include);
573 path = search_from (pfile, type);
577 cpp_error (pfile, DL_ERROR, "no include path in which to find %s",
579 return NO_INCLUDE_PATH;
582 /* Search directory path for the file. */
583 name = (char *) alloca (strlen (fname) + pfile->max_include_len + 2);
584 for (; path; path = path->next)
587 memcpy (name, path->name, len);
588 /* Don't turn / into // or // into ///; // may be a namespace
590 if (name[len-1] == '/')
593 strcpy (&name[len + 1], fname);
594 if (CPP_OPTION (pfile, remap))
595 n = remap_filename (pfile, name, path);
599 file = open_file (pfile, n);
602 file->foundhere = path;
610 /* Not everyone who wants to set system-header-ness on a buffer can
611 see the details of a buffer. This is an exported interface because
612 fix-header needs it. */
614 cpp_make_system_header (pfile, syshdr, externc)
620 /* 1 = system header, 2 = system header to be treated as C. */
622 flags = 1 + (externc != 0);
623 _cpp_do_file_change (pfile, LC_RENAME, pfile->map->to_file,
624 SOURCE_LINE (pfile->map, pfile->line), flags);
627 /* Report on all files that might benefit from a multiple include guard.
630 _cpp_report_missing_guards (pfile)
634 splay_tree_foreach (pfile->all_include_files, report_missing_guard,
638 /* Callback function for splay_tree_foreach(). */
640 report_missing_guard (n, b)
644 struct include_file *f = (struct include_file *) n->value;
645 int *bannerp = (int *)b;
647 if (f && f->cmacro == 0 && f->include_count == 1)
651 fputs (_("Multiple include guards may be useful for:\n"), stderr);
654 fputs (f->name, stderr);
660 /* Create a dependency for file FNAME, or issue an error message as
661 appropriate. ANGLE_BRACKETS is non-zero if the file was bracketed
664 handle_missing_header (pfile, fname, angle_brackets)
670 = CPP_OPTION (pfile, deps.style) > (angle_brackets || pfile->map->sysp);
672 if (CPP_OPTION (pfile, deps.missing_files) && print_dep)
673 deps_add_dep (pfile->deps, fname);
674 /* If -M was specified, then don't count this as an error, because
675 we can still produce correct output. Otherwise, we can't produce
676 correct output, because there may be dependencies we need inside
677 the missing file, and we don't know what directory this missing
680 cpp_errno (pfile, CPP_OPTION (pfile, deps.style) && ! print_dep
681 ? DL_WARNING: DL_ERROR, fname);
684 /* Handles #include-family directives (distinguished by TYPE),
685 including HEADER, and the command line -imacros and -include.
686 Returns true if a buffer was stacked. */
688 _cpp_execute_include (pfile, header, type)
690 const cpp_token *header;
691 enum include_type type;
693 bool stacked = false;
694 struct include_file *inc = find_include_file (pfile, header, type);
697 handle_missing_header (pfile, (const char *) header->val.str.text,
698 header->type == CPP_HEADER_NAME);
699 else if (inc != NO_INCLUDE_PATH)
701 stacked = stack_include_file (pfile, inc);
703 if (type == IT_IMPORT)
704 _cpp_never_reread (inc);
710 /* Locate HEADER, and determine whether it is newer than the current
711 file. If it cannot be located or dated, return -1, if it is newer
712 newer, return 1, otherwise 0. */
714 _cpp_compare_file_date (pfile, header)
716 const cpp_token *header;
718 struct include_file *inc = find_include_file (pfile, header, 0);
720 if (inc == NULL || inc == NO_INCLUDE_PATH)
729 return inc->st.st_mtime > pfile->buffer->inc->st.st_mtime;
733 /* Push an input buffer and load it up with the contents of FNAME. If
734 FNAME is "", read standard input. Return true if a buffer was
737 _cpp_read_file (pfile, fname)
741 struct include_file *f = open_file (pfile, fname);
745 cpp_errno (pfile, DL_ERROR, fname);
749 return stack_include_file (pfile, f);
752 /* Do appropriate cleanup when a file INC's buffer is popped off the
755 _cpp_pop_file_buffer (pfile, inc)
757 struct include_file *inc;
759 /* Record the inclusion-preventing macro, which could be NULL
760 meaning no controlling macro. */
761 if (pfile->mi_valid && inc->cmacro == NULL)
762 inc->cmacro = pfile->mi_cmacro;
764 /* Invalidate control macros in the #including file. */
765 pfile->mi_valid = false;
768 if (inc->refcnt == 0 && DO_NOT_REREAD (inc))
772 /* Returns the first place in the include chain to start searching for
773 "" includes. This involves stripping away the basename of the
774 current file, unless -I- was specified.
776 If we're handling -include or -imacros, use the "" chain, but with
777 the preprocessor's cwd prepended. */
778 static struct search_path *
779 search_from (pfile, type)
781 enum include_type type;
783 cpp_buffer *buffer = pfile->buffer;
786 /* Command line uses the cwd, and does not cache the result. */
787 if (type == IT_CMDLINE)
790 /* Ignore the current file's directory if -I- was given. */
791 if (CPP_OPTION (pfile, ignore_srcdir))
792 return CPP_OPTION (pfile, quote_include);
794 if (! buffer->search_cached)
796 buffer->search_cached = 1;
798 dlen = lbasename (buffer->inc->name) - buffer->inc->name;
802 /* We don't guarantee NAME is null-terminated. This saves
803 allocating and freeing memory. Drop a trailing '/'. */
804 buffer->dir.name = buffer->inc->name;
811 buffer->dir.name = ".";
815 if (dlen > pfile->max_include_len)
816 pfile->max_include_len = dlen;
818 buffer->dir.len = dlen;
819 buffer->dir.next = CPP_OPTION (pfile, quote_include);
820 buffer->dir.sysp = pfile->map->sysp;
826 /* The file_name_map structure holds a mapping of file names for a
827 particular directory. This mapping is read from the file named
828 FILE_NAME_MAP_FILE in that directory. Such a file can be used to
829 map filenames on a file system with severe filename restrictions,
830 such as DOS. The format of the file name map file is just a series
831 of lines with two tokens on each line. The first token is the name
832 to map, and the second token is the actual name to use. */
835 struct file_name_map *map_next;
840 #define FILE_NAME_MAP_FILE "header.gcc"
842 /* Read a space delimited string of unlimited length from a stdio
845 read_filename_string (ch, f)
853 set = alloc = xmalloc (len + 1);
857 while ((ch = getc (f)) != EOF && ! is_space(ch))
859 if (set - alloc == len)
862 alloc = xrealloc (alloc, len + 1);
863 set = alloc + len / 2;
873 /* This structure holds a linked list of file name maps, one per directory. */
874 struct file_name_map_list
876 struct file_name_map_list *map_list_next;
878 struct file_name_map *map_list_map;
881 /* Read the file name map file for DIRNAME. */
882 static struct file_name_map *
883 read_name_map (pfile, dirname)
887 struct file_name_map_list *map_list_ptr;
891 /* Check the cache of directories, and mappings in their remap file. */
892 for (map_list_ptr = CPP_OPTION (pfile, map_list); map_list_ptr;
893 map_list_ptr = map_list_ptr->map_list_next)
894 if (! strcmp (map_list_ptr->map_list_name, dirname))
895 return map_list_ptr->map_list_map;
897 map_list_ptr = ((struct file_name_map_list *)
898 xmalloc (sizeof (struct file_name_map_list)));
899 map_list_ptr->map_list_name = xstrdup (dirname);
901 /* The end of the list ends in NULL. */
902 map_list_ptr->map_list_map = NULL;
904 name = (char *) alloca (strlen (dirname) + strlen (FILE_NAME_MAP_FILE) + 2);
905 strcpy (name, dirname);
908 strcat (name, FILE_NAME_MAP_FILE);
909 f = fopen (name, "r");
911 /* Silently return NULL if we cannot open. */
916 while ((ch = getc (f)) != EOF)
919 struct file_name_map *ptr;
923 from = read_filename_string (ch, f);
924 while ((ch = getc (f)) != EOF && is_hspace(ch))
926 to = read_filename_string (ch, f);
928 ptr = ((struct file_name_map *)
929 xmalloc (sizeof (struct file_name_map)));
930 ptr->map_from = from;
932 /* Make the real filename absolute. */
933 if (IS_ABSOLUTE_PATHNAME (to))
937 ptr->map_to = concat (dirname, "/", to, NULL);
941 ptr->map_next = map_list_ptr->map_list_map;
942 map_list_ptr->map_list_map = ptr;
944 while ((ch = getc (f)) != '\n')
951 /* Add this information to the cache. */
952 map_list_ptr->map_list_next = CPP_OPTION (pfile, map_list);
953 CPP_OPTION (pfile, map_list) = map_list_ptr;
955 return map_list_ptr->map_list_map;
958 /* Remap an unsimplified path NAME based on the file_name_map (if any)
961 remap_filename (pfile, name, loc)
964 struct search_path *loc;
966 struct file_name_map *map;
967 const char *from, *p;
972 /* Get a null-terminated path. */
973 char *dname = alloca (loc->len + 1);
974 memcpy (dname, loc->name, loc->len);
975 dname[loc->len] = '\0';
977 loc->name_map = read_name_map (pfile, dname);
982 /* This works since NAME has not been simplified yet. */
983 from = name + loc->len + 1;
985 for (map = loc->name_map; map; map = map->map_next)
986 if (!strcmp (map->map_from, from))
989 /* Try to find a mapping file for the particular directory we are
990 looking in. Thus #include <sys/types.h> will look up sys/types.h
991 in /usr/include/header.gcc and look up types.h in
992 /usr/include/sys/header.gcc. */
993 p = strrchr (name, '/');
997 /* We know p != name as absolute paths don't call remap_filename. */
999 cpp_error (pfile, DL_ICE, "absolute file name in remap_filename");
1001 dir = (char *) alloca (p - name + 1);
1002 memcpy (dir, name, p - name);
1003 dir[p - name] = '\0';
1006 for (map = read_name_map (pfile, dir); map; map = map->map_next)
1007 if (! strcmp (map->map_from, from))
1013 /* Returns true if it is safe to remove the final component of path,
1014 when it is followed by a ".." component. We use lstat to avoid
1015 symlinks if we have it. If not, we can still catch errors with
1018 remove_component_p (path)
1025 result = lstat (path, &s);
1027 result = stat (path, &s);
1030 /* There's no guarantee that errno will be unchanged, even on
1031 success. Cygwin's lstat(), for example, will often set errno to
1032 ENOSYS. In case of success, reset errno to zero. */
1036 return result == 0 && S_ISDIR (s.st_mode);
1039 /* Simplify a path name in place, deleting redundant components. This
1040 reduces OS overhead and guarantees that equivalent paths compare
1041 the same (modulo symlinks).
1044 foo/bar/../quux foo/quux
1048 //quux //quux (POSIX allows leading // as a namespace escape)
1050 Guarantees no trailing slashes. All transforms reduce the length
1051 of the string. Returns PATH. errno is 0 if no error occurred;
1052 nonzero if an error occurred when using stat () or lstat (). */
1054 _cpp_simplify_pathname (path)
1059 char *base, *orig_base;
1063 /* Don't overflow the empty path by putting a '.' in it below. */
1067 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
1068 /* Convert all backslashes to slashes. */
1069 for (from = path; *from; from++)
1070 if (*from == '\\') *from = '/';
1072 /* Skip over leading drive letter if present. */
1073 if (ISALPHA (path[0]) && path[1] == ':')
1074 from = to = &path[2];
1081 /* Remove redundant leading /s. */
1090 /* 3 or more initial /s are equivalent to 1 /. */
1091 while (*++from == '/');
1093 /* On some hosts // differs from /; Posix allows this. */
1098 base = orig_base = to;
1103 while (*from == '/')
1111 if (from[1] == '\0')
1118 else if (from[1] == '.' && (from[2] == '/' || from[2] == '\0'))
1120 /* Don't simplify if there was no previous component. */
1121 if (absolute && orig_base == to)
1126 /* Don't simplify if the previous component was "../",
1127 or if an error has already occurred with (l)stat. */
1128 if (base != to && errno == 0)
1130 /* We don't back up if it's a symlink. */
1132 if (remove_component_p (path))
1134 while (to > base && *to != '/')
1144 /* Add the component separator. */
1148 /* Copy this component until the trailing null or '/'. */
1149 while (*from != '\0' && *from != '/')
1156 /* Change the empty string to "." so that it is not treated as stdin.