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 /* For -M, add the file to the dependencies on its first inclusion. */
322 if (CPP_OPTION (pfile
, print_deps
) > sysp
&& !inc
->include_count
)
323 deps_add_dep (pfile
->deps
, inc
->name
);
328 if (read_include_file (pfile
, inc
))
330 /* If an error occurs, do not try to read this file again. */
331 _cpp_never_reread (inc
);
334 /* Mark a regular, zero-length file never-reread. We read it,
335 NUL-terminate it, and stack it once, so preprocessing a main
336 file of zero length does not raise an error. */
337 if (S_ISREG (inc
->st
.st_mode
) && inc
->st
.st_size
== 0)
338 _cpp_never_reread (inc
);
344 /* We don't want MI guard advice for the main file. */
345 inc
->include_count
++;
348 fp
= cpp_push_buffer (pfile
, inc
->buffer
, inc
->st
.st_size
,
349 /* from_stage3 */ CPP_OPTION (pfile
, preprocessed
), 0);
353 /* Initialise controlling macro state. */
354 pfile
->mi_valid
= true;
355 pfile
->mi_cmacro
= 0;
357 /* Generate the call back. */
358 filename
= inc
->name
;
359 if (*filename
== '\0')
360 filename
= "<stdin>";
361 _cpp_do_file_change (pfile
, LC_ENTER
, filename
, 1, sysp
);
366 /* Read the file referenced by INC into the file cache.
368 If fd points to a plain file, we might be able to mmap it; we can
369 definitely allocate the buffer all at once. If fd is a pipe or
370 terminal, we can't do either. If fd is something weird, like a
371 block device, we don't want to read it at all.
373 Unfortunately, different systems use different st.st_mode values
374 for pipes: some have S_ISFIFO, some S_ISSOCK, some are buggy and
375 zero the entire struct stat except a couple fields. Hence we don't
376 even try to figure out what something is, except for plain files
379 FIXME: Flush file cache and try again if we run out of memory. */
381 read_include_file (pfile
, inc
)
383 struct include_file
*inc
;
385 ssize_t size
, offset
, count
;
388 static int pagesize
= -1;
391 if (S_ISREG (inc
->st
.st_mode
))
393 /* off_t might have a wider range than ssize_t - in other words,
394 the max size of a file might be bigger than the address
395 space. We can't handle a file that large. (Anyone with
396 a single source file bigger than 2GB needs to rethink
397 their coding style.) Some systems (e.g. AIX 4.1) define
398 SSIZE_MAX to be much smaller than the actual range of the
399 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
401 if (inc
->st
.st_size
> INTTYPE_MAXIMUM (ssize_t
))
403 cpp_error (pfile
, DL_ERROR
, "%s is too large", inc
->name
);
406 size
= inc
->st
.st_size
;
411 pagesize
= getpagesize ();
413 if (SHOULD_MMAP (size
, pagesize
))
415 buf
= (uchar
*) mmap (0, size
, PROT_READ
, MAP_PRIVATE
, inc
->fd
, 0);
416 if (buf
== (uchar
*)-1)
423 buf
= (uchar
*) xmalloc (size
+ 1);
425 while (offset
< size
)
427 count
= read (inc
->fd
, buf
+ offset
, size
- offset
);
432 if (!STAT_SIZE_TOO_BIG (inc
->st
))
433 cpp_error (pfile
, DL_WARNING
,
434 "%s is shorter than expected", inc
->name
);
436 buf
= xrealloc (buf
, size
+ 1);
437 inc
->st
.st_size
= size
;
442 /* The lexer requires that the buffer be NUL-terminated. */
446 else if (S_ISBLK (inc
->st
.st_mode
))
448 cpp_error (pfile
, DL_ERROR
, "%s is a block device", inc
->name
);
453 /* 8 kilobytes is a sensible starting size. It ought to be
454 bigger than the kernel pipe buffer, and it's definitely
455 bigger than the majority of C source files. */
458 buf
= (uchar
*) xmalloc (size
+ 1);
460 while ((count
= read (inc
->fd
, buf
+ offset
, size
- offset
)) > 0)
466 buf
= xrealloc (buf
, size
+ 1);
472 if (offset
+ 1 < size
)
473 buf
= xrealloc (buf
, offset
+ 1);
475 /* The lexer requires that the buffer be NUL-terminated. */
477 inc
->st
.st_size
= offset
;
484 cpp_errno (pfile
, DL_ERROR
, inc
->name
);
489 /* Drop INC's buffer from memory, if we are unlikely to need it again. */
492 struct include_file
*inc
;
498 munmap ((PTR
) inc
->buffer
, inc
->st
.st_size
);
501 free ((PTR
) inc
->buffer
);
506 /* Return 1 if the file named by FNAME has been included before in
507 any context, 0 otherwise. */
509 cpp_included (pfile
, fname
)
513 struct search_path
*path
;
517 if (IS_ABSOLUTE_PATHNAME (fname
))
519 /* Just look it up. */
520 nd
= splay_tree_lookup (pfile
->all_include_files
, (splay_tree_key
) fname
);
521 return (nd
&& nd
->value
);
524 /* Search directory path for the file. */
525 name
= (char *) alloca (strlen (fname
) + pfile
->max_include_len
+ 2);
526 for (path
= CPP_OPTION (pfile
, quote_include
); path
; path
= path
->next
)
528 memcpy (name
, path
->name
, path
->len
);
529 name
[path
->len
] = '/';
530 strcpy (&name
[path
->len
+ 1], fname
);
531 if (CPP_OPTION (pfile
, remap
))
532 n
= remap_filename (pfile
, name
, path
);
536 nd
= splay_tree_lookup (pfile
->all_include_files
, (splay_tree_key
) n
);
543 /* Search for HEADER. Return 0 if there is no such file (or it's
544 un-openable), in which case an error code will be in errno. If
545 there is no include path to use it returns NO_INCLUDE_PATH,
546 otherwise an include_file structure. If this request originates
547 from a directive of TYPE #include_next, set INCLUDE_NEXT to true. */
548 static struct include_file
*
549 find_include_file (pfile
, header
, type
)
551 const cpp_token
*header
;
552 enum include_type type
;
554 const char *fname
= (const char *) header
->val
.str
.text
;
555 struct search_path
*path
;
556 struct include_file
*file
;
559 if (IS_ABSOLUTE_PATHNAME (fname
))
560 return open_file (pfile
, fname
);
562 /* For #include_next, skip in the search path past the dir in which
563 the current file was found, but if it was found via an absolute
564 path use the normal search logic. */
565 if (type
== IT_INCLUDE_NEXT
&& pfile
->buffer
->inc
->foundhere
)
566 path
= pfile
->buffer
->inc
->foundhere
->next
;
567 else if (header
->type
== CPP_HEADER_NAME
)
568 path
= CPP_OPTION (pfile
, bracket_include
);
570 path
= search_from (pfile
, type
);
574 cpp_error (pfile
, DL_ERROR
, "no include path in which to find %s",
576 return NO_INCLUDE_PATH
;
579 /* Search directory path for the file. */
580 name
= (char *) alloca (strlen (fname
) + pfile
->max_include_len
+ 2);
581 for (; path
; path
= path
->next
)
584 memcpy (name
, path
->name
, len
);
585 /* Don't turn / into // or // into ///; // may be a namespace
587 if (name
[len
-1] == '/')
590 strcpy (&name
[len
+ 1], fname
);
591 if (CPP_OPTION (pfile
, remap
))
592 n
= remap_filename (pfile
, name
, path
);
596 file
= open_file (pfile
, n
);
599 file
->foundhere
= path
;
607 /* Not everyone who wants to set system-header-ness on a buffer can
608 see the details of a buffer. This is an exported interface because
609 fix-header needs it. */
611 cpp_make_system_header (pfile
, syshdr
, externc
)
617 /* 1 = system header, 2 = system header to be treated as C. */
619 flags
= 1 + (externc
!= 0);
620 _cpp_do_file_change (pfile
, LC_RENAME
, pfile
->map
->to_file
,
621 SOURCE_LINE (pfile
->map
, pfile
->line
), flags
);
624 /* Report on all files that might benefit from a multiple include guard.
627 _cpp_report_missing_guards (pfile
)
631 splay_tree_foreach (pfile
->all_include_files
, report_missing_guard
,
635 /* Callback function for splay_tree_foreach(). */
637 report_missing_guard (n
, b
)
641 struct include_file
*f
= (struct include_file
*) n
->value
;
642 int *bannerp
= (int *)b
;
644 if (f
&& f
->cmacro
== 0 && f
->include_count
== 1)
648 fputs (_("Multiple include guards may be useful for:\n"), stderr
);
651 fputs (f
->name
, stderr
);
657 /* Create a dependency for file FNAME, or issue an error message as
658 appropriate. ANGLE_BRACKETS is non-zero if the file was bracketed
661 handle_missing_header (pfile
, fname
, angle_brackets
)
666 int print_dep
= CPP_PRINT_DEPS(pfile
) > (angle_brackets
|| pfile
->map
->sysp
);
668 if (CPP_OPTION (pfile
, print_deps_missing_files
) && print_dep
)
669 deps_add_dep (pfile
->deps
, fname
);
670 /* If -M was specified, then don't count this as an error, because
671 we can still produce correct output. Otherwise, we can't produce
672 correct output, because there may be dependencies we need inside
673 the missing file, and we don't know what directory this missing
676 cpp_errno (pfile
, CPP_PRINT_DEPS (pfile
) && ! print_dep
677 ? DL_WARNING
: DL_ERROR
, fname
);
680 /* Handles #include-family directives (distinguished by TYPE),
681 including HEADER, and the command line -imacros and -include.
682 Returns true if a buffer was stacked. */
684 _cpp_execute_include (pfile
, header
, type
)
686 const cpp_token
*header
;
687 enum include_type type
;
689 bool stacked
= false;
690 struct include_file
*inc
= find_include_file (pfile
, header
, type
);
693 handle_missing_header (pfile
, (const char *) header
->val
.str
.text
,
694 header
->type
== CPP_HEADER_NAME
);
695 else if (inc
!= NO_INCLUDE_PATH
)
697 stacked
= stack_include_file (pfile
, inc
);
699 if (type
== IT_IMPORT
)
700 _cpp_never_reread (inc
);
706 /* Locate HEADER, and determine whether it is newer than the current
707 file. If it cannot be located or dated, return -1, if it is newer
708 newer, return 1, otherwise 0. */
710 _cpp_compare_file_date (pfile
, header
)
712 const cpp_token
*header
;
714 struct include_file
*inc
= find_include_file (pfile
, header
, 0);
716 if (inc
== NULL
|| inc
== NO_INCLUDE_PATH
)
725 return inc
->st
.st_mtime
> pfile
->buffer
->inc
->st
.st_mtime
;
729 /* Push an input buffer and load it up with the contents of FNAME. If
730 FNAME is "", read standard input. Return true if a buffer was
733 _cpp_read_file (pfile
, fname
)
737 struct include_file
*f
= open_file (pfile
, fname
);
741 cpp_errno (pfile
, DL_ERROR
, fname
);
745 return stack_include_file (pfile
, f
);
748 /* Do appropriate cleanup when a file INC's buffer is popped off the
751 _cpp_pop_file_buffer (pfile
, inc
)
753 struct include_file
*inc
;
755 /* Record the inclusion-preventing macro, which could be NULL
756 meaning no controlling macro. */
757 if (pfile
->mi_valid
&& inc
->cmacro
== NULL
)
758 inc
->cmacro
= pfile
->mi_cmacro
;
760 /* Invalidate control macros in the #including file. */
761 pfile
->mi_valid
= false;
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.
772 If we're handling -include or -imacros, use the "" chain, but with
773 the preprocessor's cwd prepended. */
774 static struct search_path
*
775 search_from (pfile
, type
)
777 enum include_type type
;
779 cpp_buffer
*buffer
= pfile
->buffer
;
782 /* Command line uses the cwd, and does not cache the result. */
783 if (type
== IT_CMDLINE
)
786 /* Ignore the current file's directory if -I- was given. */
787 if (CPP_OPTION (pfile
, ignore_srcdir
))
788 return CPP_OPTION (pfile
, quote_include
);
790 if (! buffer
->search_cached
)
792 buffer
->search_cached
= 1;
794 dlen
= lbasename (buffer
->inc
->name
) - buffer
->inc
->name
;
798 /* We don't guarantee NAME is null-terminated. This saves
799 allocating and freeing memory. Drop a trailing '/'. */
800 buffer
->dir
.name
= buffer
->inc
->name
;
807 buffer
->dir
.name
= ".";
811 if (dlen
> pfile
->max_include_len
)
812 pfile
->max_include_len
= dlen
;
814 buffer
->dir
.len
= dlen
;
815 buffer
->dir
.next
= CPP_OPTION (pfile
, quote_include
);
816 buffer
->dir
.sysp
= pfile
->map
->sysp
;
822 /* The file_name_map structure holds a mapping of file names for a
823 particular directory. This mapping is read from the file named
824 FILE_NAME_MAP_FILE in that directory. Such a file can be used to
825 map filenames on a file system with severe filename restrictions,
826 such as DOS. The format of the file name map file is just a series
827 of lines with two tokens on each line. The first token is the name
828 to map, and the second token is the actual name to use. */
831 struct file_name_map
*map_next
;
836 #define FILE_NAME_MAP_FILE "header.gcc"
838 /* Read a space delimited string of unlimited length from a stdio
841 read_filename_string (ch
, f
)
849 set
= alloc
= xmalloc (len
+ 1);
853 while ((ch
= getc (f
)) != EOF
&& ! is_space(ch
))
855 if (set
- alloc
== len
)
858 alloc
= xrealloc (alloc
, len
+ 1);
859 set
= alloc
+ len
/ 2;
869 /* This structure holds a linked list of file name maps, one per directory. */
870 struct file_name_map_list
872 struct file_name_map_list
*map_list_next
;
874 struct file_name_map
*map_list_map
;
877 /* Read the file name map file for DIRNAME. */
878 static struct file_name_map
*
879 read_name_map (pfile
, dirname
)
883 struct file_name_map_list
*map_list_ptr
;
887 /* Check the cache of directories, and mappings in their remap file. */
888 for (map_list_ptr
= CPP_OPTION (pfile
, map_list
); map_list_ptr
;
889 map_list_ptr
= map_list_ptr
->map_list_next
)
890 if (! strcmp (map_list_ptr
->map_list_name
, dirname
))
891 return map_list_ptr
->map_list_map
;
893 map_list_ptr
= ((struct file_name_map_list
*)
894 xmalloc (sizeof (struct file_name_map_list
)));
895 map_list_ptr
->map_list_name
= xstrdup (dirname
);
897 /* The end of the list ends in NULL. */
898 map_list_ptr
->map_list_map
= NULL
;
900 name
= (char *) alloca (strlen (dirname
) + strlen (FILE_NAME_MAP_FILE
) + 2);
901 strcpy (name
, dirname
);
904 strcat (name
, FILE_NAME_MAP_FILE
);
905 f
= fopen (name
, "r");
907 /* Silently return NULL if we cannot open. */
911 int dirlen
= strlen (dirname
);
913 while ((ch
= getc (f
)) != EOF
)
916 struct file_name_map
*ptr
;
920 from
= read_filename_string (ch
, f
);
921 while ((ch
= getc (f
)) != EOF
&& is_hspace(ch
))
923 to
= read_filename_string (ch
, f
);
925 ptr
= ((struct file_name_map
*)
926 xmalloc (sizeof (struct file_name_map
)));
927 ptr
->map_from
= from
;
929 /* Make the real filename absolute. */
930 if (IS_ABSOLUTE_PATHNAME (to
))
934 ptr
->map_to
= xmalloc (dirlen
+ strlen (to
) + 2);
935 strcpy (ptr
->map_to
, dirname
);
936 ptr
->map_to
[dirlen
] = '/';
937 strcpy (ptr
->map_to
+ dirlen
+ 1, to
);
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.