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 /* Add the file to the dependencies on its first inclusion. */
314 if (CPP_OPTION (pfile, print_deps) > !!sysp && !inc->include_count)
316 if (pfile->buffer || CPP_OPTION (pfile, deps_ignore_main_file) == 0)
317 deps_add_dep (pfile->deps, inc->name);
323 if (read_include_file (pfile, inc))
325 /* If an error occurs, do not try to read this file again. */
326 _cpp_never_reread (inc);
329 /* Mark a regular, zero-length file never-reread. We read it,
330 NUL-terminate it, and stack it once, so preprocessing a main
331 file of zero length does not raise an error. */
332 if (S_ISREG (inc->st.st_mode) && inc->st.st_size == 0)
333 _cpp_never_reread (inc);
339 /* We don't want MI guard advice for the main file. */
340 inc->include_count++;
343 fp = cpp_push_buffer (pfile, inc->buffer, inc->st.st_size,
344 /* from_stage3 */ CPP_OPTION (pfile, preprocessed), 0);
348 /* Initialise controlling macro state. */
349 pfile->mi_valid = true;
350 pfile->mi_cmacro = 0;
352 /* Generate the call back. */
353 filename = inc->name;
354 if (*filename == '\0')
355 filename = "<stdin>";
356 _cpp_do_file_change (pfile, LC_ENTER, filename, 1, sysp);
361 /* Read the file referenced by INC into the file cache.
363 If fd points to a plain file, we might be able to mmap it; we can
364 definitely allocate the buffer all at once. If fd is a pipe or
365 terminal, we can't do either. If fd is something weird, like a
366 block device, we don't want to read it at all.
368 Unfortunately, different systems use different st.st_mode values
369 for pipes: some have S_ISFIFO, some S_ISSOCK, some are buggy and
370 zero the entire struct stat except a couple fields. Hence we don't
371 even try to figure out what something is, except for plain files
374 FIXME: Flush file cache and try again if we run out of memory. */
376 read_include_file (pfile, inc)
378 struct include_file *inc;
380 ssize_t size, offset, count;
383 static int pagesize = -1;
386 if (S_ISREG (inc->st.st_mode))
388 /* off_t might have a wider range than ssize_t - in other words,
389 the max size of a file might be bigger than the address
390 space. We can't handle a file that large. (Anyone with
391 a single source file bigger than 2GB needs to rethink
392 their coding style.) Some systems (e.g. AIX 4.1) define
393 SSIZE_MAX to be much smaller than the actual range of the
394 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
396 if (inc->st.st_size > INTTYPE_MAXIMUM (ssize_t))
398 cpp_error (pfile, "%s is too large", inc->name);
401 size = inc->st.st_size;
406 pagesize = getpagesize ();
408 if (SHOULD_MMAP (size, pagesize))
410 buf = (U_CHAR *) mmap (0, size, PROT_READ, MAP_PRIVATE, inc->fd, 0);
411 if (buf == (U_CHAR *)-1)
418 buf = (U_CHAR *) xmalloc (size + 1);
420 while (offset < size)
422 count = read (inc->fd, buf + offset, size - offset);
427 if (!STAT_SIZE_TOO_BIG (inc->st))
429 (pfile, "%s is shorter than expected", inc->name);
431 buf = xrealloc (buf, size + 1);
432 inc->st.st_size = size;
437 /* The lexer requires that the buffer be NUL-terminated. */
441 else if (S_ISBLK (inc->st.st_mode))
443 cpp_error (pfile, "%s is a block device", inc->name);
448 /* 8 kilobytes is a sensible starting size. It ought to be
449 bigger than the kernel pipe buffer, and it's definitely
450 bigger than the majority of C source files. */
453 buf = (U_CHAR *) xmalloc (size + 1);
455 while ((count = read (inc->fd, buf + offset, size - offset)) > 0)
461 buf = xrealloc (buf, size + 1);
467 if (offset + 1 < size)
468 buf = xrealloc (buf, offset + 1);
470 /* The lexer requires that the buffer be NUL-terminated. */
472 inc->st.st_size = offset;
479 cpp_error_from_errno (pfile, inc->name);
484 /* Drop INC's buffer from memory, if we are unlikely to need it again. */
487 struct include_file *inc;
493 munmap ((PTR) inc->buffer, inc->st.st_size);
496 free ((PTR) inc->buffer);
501 /* Return 1 if the file named by FNAME has been included before in
502 any context, 0 otherwise. */
504 cpp_included (pfile, fname)
508 struct search_path *path;
512 if (IS_ABSOLUTE_PATHNAME (fname))
514 /* Just look it up. */
515 nd = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) fname);
516 return (nd && nd->value);
519 /* Search directory path for the file. */
520 name = (char *) alloca (strlen (fname) + pfile->max_include_len + 2);
521 for (path = CPP_OPTION (pfile, quote_include); path; path = path->next)
523 memcpy (name, path->name, path->len);
524 name[path->len] = '/';
525 strcpy (&name[path->len + 1], fname);
526 if (CPP_OPTION (pfile, remap))
527 n = remap_filename (pfile, name, path);
531 nd = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) n);
538 /* Search for HEADER. Return 0 if there is no such file (or it's
539 un-openable), in which case an error code will be in errno. If
540 there is no include path to use it returns NO_INCLUDE_PATH,
541 otherwise an include_file structure. If this request originates
542 from a directive of TYPE #include_next, set INCLUDE_NEXT to true. */
543 static struct include_file *
544 find_include_file (pfile, header, type)
546 const cpp_token *header;
547 enum include_type type;
549 const char *fname = (const char *) header->val.str.text;
550 struct search_path *path;
551 struct include_file *file;
554 if (IS_ABSOLUTE_PATHNAME (fname))
555 return open_file (pfile, fname);
557 /* For #include_next, skip in the search path past the dir in which
558 the current file was found, but if it was found via an absolute
559 path use the normal search logic. */
560 if (type == IT_INCLUDE_NEXT && pfile->buffer->inc->foundhere)
561 path = pfile->buffer->inc->foundhere->next;
562 else if (header->type == CPP_HEADER_NAME)
563 path = CPP_OPTION (pfile, bracket_include);
565 path = search_from (pfile, type);
569 cpp_error (pfile, "no include path in which to find %s", fname);
570 return NO_INCLUDE_PATH;
573 /* Search directory path for the file. */
574 name = (char *) alloca (strlen (fname) + pfile->max_include_len + 2);
575 for (; path; path = path->next)
578 memcpy (name, path->name, len);
579 /* Don't turn / into // or // into ///; // may be a namespace
581 if (name[len-1] == '/')
584 strcpy (&name[len + 1], fname);
585 if (CPP_OPTION (pfile, remap))
586 n = remap_filename (pfile, name, path);
590 file = open_file (pfile, n);
593 file->foundhere = path;
601 /* Not everyone who wants to set system-header-ness on a buffer can
602 see the details of a buffer. This is an exported interface because
603 fix-header needs it. */
605 cpp_make_system_header (pfile, syshdr, externc)
611 /* 1 = system header, 2 = system header to be treated as C. */
613 flags = 1 + (externc != 0);
614 _cpp_do_file_change (pfile, LC_RENAME, pfile->map->to_file,
615 SOURCE_LINE (pfile->map, pfile->line), flags);
618 /* Report on all files that might benefit from a multiple include guard.
621 _cpp_report_missing_guards (pfile)
625 splay_tree_foreach (pfile->all_include_files, report_missing_guard,
629 /* Callback function for splay_tree_foreach(). */
631 report_missing_guard (n, b)
635 struct include_file *f = (struct include_file *) n->value;
636 int *bannerp = (int *)b;
638 if (f && f->cmacro == 0 && f->include_count == 1)
642 fputs (_("Multiple include guards may be useful for:\n"), stderr);
645 fputs (f->name, stderr);
651 /* Create a dependency for file FNAME, or issue an error message as
652 appropriate. ANGLE_BRACKETS is non-zero if the file was bracketed
655 handle_missing_header (pfile, fname, angle_brackets)
660 int print_dep = CPP_PRINT_DEPS(pfile) > (angle_brackets || pfile->map->sysp);
662 if (CPP_OPTION (pfile, print_deps_missing_files) && print_dep)
664 if (!angle_brackets || IS_ABSOLUTE_PATHNAME (fname))
665 deps_add_dep (pfile->deps, fname);
668 /* If requested as a system header, assume it belongs in
669 the first system header directory. */
670 struct search_path *ptr = CPP_OPTION (pfile, bracket_include);
672 int len = 0, fname_len = strlen (fname);
677 p = (char *) alloca (len + fname_len + 2);
680 memcpy (p, ptr->name, len);
683 memcpy (p + len, fname, fname_len + 1);
684 deps_add_dep (pfile->deps, p);
687 /* If -M was specified, then don't count this as an error, because
688 we can still produce correct output. Otherwise, we can't produce
689 correct output, because there may be dependencies we need inside
690 the missing file, and we don't know what directory this missing
691 file exists in. FIXME: Use a future cpp_diagnostic_with_errno ()
692 for both of these cases. */
693 else if (CPP_PRINT_DEPS (pfile) && ! print_dep)
694 cpp_warning (pfile, "%s: %s", fname, xstrerror (errno));
696 cpp_error_from_errno (pfile, fname);
699 /* Handles #include-family directives (distinguished by TYPE),
700 including HEADER, and the command line -imacros and -include.
701 Returns true if a buffer was stacked. */
703 _cpp_execute_include (pfile, header, type)
705 const cpp_token *header;
706 enum include_type type;
708 bool stacked = false;
709 struct include_file *inc = find_include_file (pfile, header, type);
712 handle_missing_header (pfile, (const char *) header->val.str.text,
713 header->type == CPP_HEADER_NAME);
714 else if (inc != NO_INCLUDE_PATH)
716 stacked = stack_include_file (pfile, inc);
718 if (type == IT_IMPORT)
719 _cpp_never_reread (inc);
725 /* Locate HEADER, and determine whether it is newer than the current
726 file. If it cannot be located or dated, return -1, if it is newer
727 newer, return 1, otherwise 0. */
729 _cpp_compare_file_date (pfile, header)
731 const cpp_token *header;
733 struct include_file *inc = find_include_file (pfile, header, 0);
735 if (inc == NULL || inc == NO_INCLUDE_PATH)
744 return inc->st.st_mtime > pfile->buffer->inc->st.st_mtime;
748 /* Push an input buffer and load it up with the contents of FNAME. If
749 FNAME is "", read standard input. Return true if a buffer was
752 _cpp_read_file (pfile, fname)
756 struct include_file *f = open_file (pfile, fname);
760 cpp_error_from_errno (pfile, fname);
764 return stack_include_file (pfile, f);
767 /* Do appropriate cleanup when a file INC's buffer is popped off the
768 input stack. Push the next -include file, if any remain. */
770 _cpp_pop_file_buffer (pfile, inc)
772 struct include_file *inc;
776 /* Record the inclusion-preventing macro, which could be NULL
777 meaning no controlling macro. */
778 if (pfile->mi_valid && inc->cmacro == NULL)
779 inc->cmacro = pfile->mi_cmacro;
781 /* Invalidate control macros in the #including file. */
782 pfile->mi_valid = false;
785 if (inc->refcnt == 0 && DO_NOT_REREAD (inc))
788 /* Don't generate a callback for popping the main file. */
791 _cpp_do_file_change (pfile, LC_LEAVE, 0, 0, 0);
793 /* Finally, push the next -included file, if any. */
794 if (!pfile->buffer->prev)
795 pushed = _cpp_push_next_buffer (pfile);
801 /* Returns the first place in the include chain to start searching for
802 "" includes. This involves stripping away the basename of the
803 current file, unless -I- was specified.
805 If we're handling -include or -imacros, use the "" chain, but with
806 the preprocessor's cwd prepended. */
807 static struct search_path *
808 search_from (pfile, type)
810 enum include_type type;
812 cpp_buffer *buffer = pfile->buffer;
815 /* Command line uses the cwd, and does not cache the result. */
816 if (type == IT_CMDLINE)
819 /* Ignore the current file's directory if -I- was given. */
820 if (CPP_OPTION (pfile, ignore_srcdir))
821 return CPP_OPTION (pfile, quote_include);
823 if (! buffer->search_cached)
825 buffer->search_cached = 1;
827 dlen = lbasename (buffer->inc->name) - buffer->inc->name;
831 /* We don't guarantee NAME is null-terminated. This saves
832 allocating and freeing memory. Drop a trailing '/'. */
833 buffer->dir.name = buffer->inc->name;
840 buffer->dir.name = ".";
844 if (dlen > pfile->max_include_len)
845 pfile->max_include_len = dlen;
847 buffer->dir.len = dlen;
848 buffer->dir.next = CPP_OPTION (pfile, quote_include);
849 buffer->dir.sysp = pfile->map->sysp;
855 /* The file_name_map structure holds a mapping of file names for a
856 particular directory. This mapping is read from the file named
857 FILE_NAME_MAP_FILE in that directory. Such a file can be used to
858 map filenames on a file system with severe filename restrictions,
859 such as DOS. The format of the file name map file is just a series
860 of lines with two tokens on each line. The first token is the name
861 to map, and the second token is the actual name to use. */
864 struct file_name_map *map_next;
869 #define FILE_NAME_MAP_FILE "header.gcc"
871 /* Read a space delimited string of unlimited length from a stdio
874 read_filename_string (ch, f)
882 set = alloc = xmalloc (len + 1);
886 while ((ch = getc (f)) != EOF && ! is_space(ch))
888 if (set - alloc == len)
891 alloc = xrealloc (alloc, len + 1);
892 set = alloc + len / 2;
902 /* This structure holds a linked list of file name maps, one per directory. */
903 struct file_name_map_list
905 struct file_name_map_list *map_list_next;
907 struct file_name_map *map_list_map;
910 /* Read the file name map file for DIRNAME. */
911 static struct file_name_map *
912 read_name_map (pfile, dirname)
916 struct file_name_map_list *map_list_ptr;
920 /* Check the cache of directories, and mappings in their remap file. */
921 for (map_list_ptr = CPP_OPTION (pfile, map_list); map_list_ptr;
922 map_list_ptr = map_list_ptr->map_list_next)
923 if (! strcmp (map_list_ptr->map_list_name, dirname))
924 return map_list_ptr->map_list_map;
926 map_list_ptr = ((struct file_name_map_list *)
927 xmalloc (sizeof (struct file_name_map_list)));
928 map_list_ptr->map_list_name = xstrdup (dirname);
930 /* The end of the list ends in NULL. */
931 map_list_ptr->map_list_map = NULL;
933 name = (char *) alloca (strlen (dirname) + strlen (FILE_NAME_MAP_FILE) + 2);
934 strcpy (name, dirname);
937 strcat (name, FILE_NAME_MAP_FILE);
938 f = fopen (name, "r");
940 /* Silently return NULL if we cannot open. */
944 int dirlen = strlen (dirname);
946 while ((ch = getc (f)) != EOF)
949 struct file_name_map *ptr;
953 from = read_filename_string (ch, f);
954 while ((ch = getc (f)) != EOF && is_hspace(ch))
956 to = read_filename_string (ch, f);
958 ptr = ((struct file_name_map *)
959 xmalloc (sizeof (struct file_name_map)));
960 ptr->map_from = from;
962 /* Make the real filename absolute. */
963 if (IS_ABSOLUTE_PATHNAME (to))
967 ptr->map_to = xmalloc (dirlen + strlen (to) + 2);
968 strcpy (ptr->map_to, dirname);
969 ptr->map_to[dirlen] = '/';
970 strcpy (ptr->map_to + dirlen + 1, to);
974 ptr->map_next = map_list_ptr->map_list_map;
975 map_list_ptr->map_list_map = ptr;
977 while ((ch = getc (f)) != '\n')
984 /* Add this information to the cache. */
985 map_list_ptr->map_list_next = CPP_OPTION (pfile, map_list);
986 CPP_OPTION (pfile, map_list) = map_list_ptr;
988 return map_list_ptr->map_list_map;
991 /* Remap an unsimplified path NAME based on the file_name_map (if any)
994 remap_filename (pfile, name, loc)
997 struct search_path *loc;
999 struct file_name_map *map;
1000 const char *from, *p;
1003 if (! loc->name_map)
1005 /* Get a null-terminated path. */
1006 char *dname = alloca (loc->len + 1);
1007 memcpy (dname, loc->name, loc->len);
1008 dname[loc->len] = '\0';
1010 loc->name_map = read_name_map (pfile, dname);
1011 if (! loc->name_map)
1015 /* This works since NAME has not been simplified yet. */
1016 from = name + loc->len + 1;
1018 for (map = loc->name_map; map; map = map->map_next)
1019 if (!strcmp (map->map_from, from))
1022 /* Try to find a mapping file for the particular directory we are
1023 looking in. Thus #include <sys/types.h> will look up sys/types.h
1024 in /usr/include/header.gcc and look up types.h in
1025 /usr/include/sys/header.gcc. */
1026 p = strrchr (name, '/');
1030 /* We know p != name as absolute paths don't call remap_filename. */
1032 cpp_ice (pfile, "absolute file name in remap_filename");
1034 dir = (char *) alloca (p - name + 1);
1035 memcpy (dir, name, p - name);
1036 dir[p - name] = '\0';
1039 for (map = read_name_map (pfile, dir); map; map = map->map_next)
1040 if (! strcmp (map->map_from, from))
1046 /* Returns true if it is safe to remove the final component of path,
1047 when it is followed by a ".." component. We use lstat to avoid
1048 symlinks if we have it. If not, we can still catch errors with
1051 remove_component_p (path)
1058 result = lstat (path, &s);
1060 result = stat (path, &s);
1063 /* There's no guarantee that errno will be unchanged, even on
1064 success. Cygwin's lstat(), for example, will often set errno to
1065 ENOSYS. In case of success, reset errno to zero. */
1069 return result == 0 && S_ISDIR (s.st_mode);
1072 /* Simplify a path name in place, deleting redundant components. This
1073 reduces OS overhead and guarantees that equivalent paths compare
1074 the same (modulo symlinks).
1077 foo/bar/../quux foo/quux
1081 //quux //quux (POSIX allows leading // as a namespace escape)
1083 Guarantees no trailing slashes. All transforms reduce the length
1084 of the string. Returns PATH. errno is 0 if no error occurred;
1085 nonzero if an error occurred when using stat () or lstat (). */
1087 _cpp_simplify_pathname (path)
1092 char *base, *orig_base;
1096 /* Don't overflow the empty path by putting a '.' in it below. */
1100 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
1101 /* Convert all backslashes to slashes. */
1102 for (from = path; *from; from++)
1103 if (*from == '\\') *from = '/';
1105 /* Skip over leading drive letter if present. */
1106 if (ISALPHA (path[0]) && path[1] == ':')
1107 from = to = &path[2];
1114 /* Remove redundant leading /s. */
1123 /* 3 or more initial /s are equivalent to 1 /. */
1124 while (*++from == '/');
1126 /* On some hosts // differs from /; Posix allows this. */
1131 base = orig_base = to;
1136 while (*from == '/')
1144 if (from[1] == '\0')
1151 else if (from[1] == '.' && (from[2] == '/' || from[2] == '\0'))
1153 /* Don't simplify if there was no previous component. */
1154 if (absolute && orig_base == to)
1159 /* Don't simplify if the previous component was "../",
1160 or if an error has already occurred with (l)stat. */
1161 if (base != to && errno == 0)
1163 /* We don't back up if it's a symlink. */
1165 if (remove_component_p (path))
1167 while (to > base && *to != '/')
1177 /* Add the component separator. */
1181 /* Copy this component until the trailing null or '/'. */
1182 while (*from != '\0' && *from != '/')
1189 /* Change the empty string to "." so that it is not treated as stdin.