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 int err_no
; /* errno obtained if opening a file failed */
71 unsigned short include_count
; /* number of times file has been read */
72 unsigned short refcnt
; /* number of stacked buffers using this file */
73 unsigned char mapped
; /* file buffer is mmapped */
74 unsigned char pch
; /* 0: file not known to be a PCH.
76 (on return from find_include_file).
77 2: file is not and never will be a valid
79 3: file is always a valid precompiled
83 /* The cmacro works like this: If it's NULL, the file is to be
84 included again. If it's NEVER_REREAD, the file is never to be
85 included again. Otherwise it is a macro hashnode, and the file is
86 to be included again if the macro is defined. */
87 #define NEVER_REREAD ((const cpp_hashnode *)-1)
88 #define DO_NOT_REREAD(inc) \
89 ((inc)->cmacro && ((inc)->cmacro == NEVER_REREAD \
90 || (inc)->cmacro->type == NT_MACRO))
91 #define INCLUDE_PCH_P(i) (((i)->pch & 1) != 0)
92 #define NO_INCLUDE_PATH ((struct include_file *) -1)
94 static struct file_name_map
*read_name_map
95 PARAMS ((cpp_reader
*, const char *));
96 static char *read_filename_string
PARAMS ((int, FILE *));
97 static char *remap_filename
PARAMS ((cpp_reader
*, char *,
98 struct search_path
*));
99 static struct search_path
*search_from
PARAMS ((cpp_reader
*,
101 static struct include_file
*
102 find_include_file
PARAMS ((cpp_reader
*, const cpp_token
*,
104 static struct include_file
*open_file
PARAMS ((cpp_reader
*, const char *));
105 static struct include_file
*open_file_pch
PARAMS ((cpp_reader
*,
107 static int read_include_file
PARAMS ((cpp_reader
*, struct include_file
*));
108 static bool stack_include_file
PARAMS ((cpp_reader
*, struct include_file
*));
109 static void purge_cache
PARAMS ((struct include_file
*));
110 static void destroy_node
PARAMS ((splay_tree_value
));
111 static int report_missing_guard
PARAMS ((splay_tree_node
, void *));
112 static splay_tree_node find_or_create_entry
PARAMS ((cpp_reader
*,
114 static void handle_missing_header
PARAMS ((cpp_reader
*, const char *, int));
115 static int remove_component_p
PARAMS ((const char *));
117 /* Set up the splay tree we use to store information about all the
118 file names seen in this compilation. We also have entries for each
119 file we tried to open but failed; this saves system calls since we
120 don't try to open it again in future.
122 The key of each node is the file name, after processing by
123 _cpp_simplify_pathname. The path name may or may not be absolute.
124 The path string has been malloced, as is automatically freed by
125 registering free () as the splay tree key deletion function.
127 A node's value is a pointer to a struct include_file, and is never
130 _cpp_init_includes (pfile
)
133 pfile
->all_include_files
134 = splay_tree_new ((splay_tree_compare_fn
) strcmp
,
135 (splay_tree_delete_key_fn
) free
,
139 /* Tear down the splay tree. */
141 _cpp_cleanup_includes (pfile
)
144 splay_tree_delete (pfile
->all_include_files
);
147 /* Free a node. The path string is automatically freed. */
152 struct include_file
*f
= (struct include_file
*)v
;
161 /* Mark a file to not be reread (e.g. #import, read failure). */
163 _cpp_never_reread (file
)
164 struct include_file
*file
;
166 file
->cmacro
= NEVER_REREAD
;
169 /* Lookup a filename, which is simplified after making a copy, and
170 create an entry if none exists. errno is nonzero iff a (reported)
171 stat() error occurred during simplification. */
172 static splay_tree_node
173 find_or_create_entry (pfile
, fname
)
177 splay_tree_node node
;
178 struct include_file
*file
;
179 char *name
= xstrdup (fname
);
181 _cpp_simplify_pathname (name
);
182 node
= splay_tree_lookup (pfile
->all_include_files
, (splay_tree_key
) name
);
187 file
= xcnew (struct include_file
);
189 file
->err_no
= errno
;
190 node
= splay_tree_insert (pfile
->all_include_files
,
191 (splay_tree_key
) file
->name
,
192 (splay_tree_value
) file
);
198 /* Enter a file name in the splay tree, for the sake of cpp_included. */
200 _cpp_fake_include (pfile
, fname
)
204 find_or_create_entry (pfile
, fname
);
207 /* Given a file name, look it up in the cache; if there is no entry,
208 create one with a non-NULL value (regardless of success in opening
209 the file). If the file doesn't exist or is inaccessible, this
210 entry is flagged so we don't attempt to open it again in the
211 future. If the file isn't open, open it. The empty string is
212 interpreted as stdin.
214 Returns an include_file structure with an open file descriptor on
215 success, or NULL on failure. */
217 static struct include_file
*
218 open_file (pfile
, filename
)
220 const char *filename
;
222 splay_tree_node nd
= find_or_create_entry (pfile
, filename
);
223 struct include_file
*file
= (struct include_file
*) nd
->value
;
227 /* Ugh. handle_missing_header () needs errno to be set. */
228 errno
= file
->err_no
;
232 /* Don't reopen an idempotent file. */
233 if (DO_NOT_REREAD (file
))
236 /* Don't reopen one which is already loaded. */
237 if (file
->buffer
!= NULL
)
240 /* We used to open files in nonblocking mode, but that caused more
241 problems than it solved. Do take care not to acquire a
242 controlling terminal by mistake (this can't happen on sane
243 systems, but paranoia is a virtue).
245 Use the three-argument form of open even though we aren't
246 specifying O_CREAT, to defend against broken system headers.
248 O_BINARY tells some runtime libraries (notably DJGPP) not to do
249 newline translation; we can handle DOS line breaks just fine
252 Special case: the empty string is translated to stdin. */
254 if (filename
[0] == '\0')
257 file
->fd
= open (file
->name
, O_RDONLY
| O_NOCTTY
| O_BINARY
, 0666);
259 if (file
->fd
!= -1 && fstat (file
->fd
, &file
->st
) == 0)
261 /* If it's a directory, we return null and continue the search
262 as the file we're looking for may appear elsewhere in the
264 if (S_ISDIR (file
->st
.st_mode
))
268 /* Mark a regular, zero-length file never-reread now. */
269 if (S_ISREG (file
->st
.st_mode
) && file
->st
.st_size
== 0)
271 _cpp_never_reread (file
);
280 /* Don't issue an error message if the file doesn't exist. */
281 file
->err_no
= errno
;
282 if (errno
!= ENOENT
&& errno
!= ENOTDIR
)
283 cpp_error_from_errno (pfile
, file
->name
);
288 /* Like open_file, but also look for a precompiled header if (a) one exists
289 and (b) it is valid. */
290 static struct include_file
*
291 open_file_pch (pfile
, filename
)
293 const char *filename
;
295 if (filename
[0] != '\0')
297 size_t namelen
= strlen (filename
);
298 char *pchname
= alloca (namelen
+ 5);
299 struct include_file
* file
;
301 memcpy (pchname
, filename
, namelen
);
302 memcpy (pchname
+ namelen
, ".pch", 5);
303 file
= open_file (pfile
, pchname
);
306 // file->name = xstrdup (filename);
307 if ((file
->pch
& 2) == 0)
309 if (INCLUDE_PCH_P (file
))
315 return open_file (pfile
, filename
);
317 /* Place the file referenced by INC into a new buffer on the buffer
318 stack, unless there are errors, or the file is not re-included
319 because of e.g. multiple-include guards. Returns true if a buffer
323 stack_include_file (pfile
, inc
)
325 struct include_file
*inc
;
329 const char *filename
;
331 if (DO_NOT_REREAD (inc
))
334 sysp
= MAX ((pfile
->map
? pfile
->map
->sysp
: 0),
335 (inc
->foundhere
? inc
->foundhere
->sysp
: 0));
337 /* For -M, add the file to the dependencies on its first inclusion. */
338 if (CPP_OPTION (pfile
, print_deps
) > sysp
&& !inc
->include_count
)
339 deps_add_dep (pfile
->deps
, inc
->name
);
344 /* PCH files get dealt with immediately.
345 We stack a zero-sized buffer below.
346 The reason for this is that reading a PCH directly into memory
347 will approximately double the memory consumption of the compiler. */
348 if (INCLUDE_PCH_P (inc
))
350 pfile
->cb
.read_pch (pfile
, inc
->fd
, inc
->name
);
355 fp
= cpp_push_buffer (pfile
, (unsigned char *)"", 0, 0, inc
->name
);
357 fp
= cpp_push_buffer (pfile
, (unsigned char *)"", 0, 0, 0);
359 fp
->rlimit
= fp
->buf
;
363 /* If an error occurs, do not try to read this file again. */
364 if (read_include_file (pfile
, inc
))
366 _cpp_never_reread (inc
);
375 /* We don't want MI guard advice for the main file. */
376 inc
->include_count
++;
379 fp
= cpp_push_buffer (pfile
, inc
->buffer
, inc
->st
.st_size
,
380 /* from_stage3 */ CPP_OPTION (pfile
, preprocessed
), 0);
384 /* Initialise controlling macro state. */
385 pfile
->mi_valid
= true;
386 pfile
->mi_cmacro
= 0;
388 /* Generate the call back. */
389 filename
= inc
->name
;
390 if (*filename
== '\0')
391 filename
= _("<stdin>");
392 _cpp_do_file_change (pfile
, LC_ENTER
, filename
, 1, sysp
);
397 /* Read the file referenced by INC into the file cache.
399 If fd points to a plain file, we might be able to mmap it; we can
400 definitely allocate the buffer all at once. If fd is a pipe or
401 terminal, we can't do either. If fd is something weird, like a
402 block device, we don't want to read it at all.
404 Unfortunately, different systems use different st.st_mode values
405 for pipes: some have S_ISFIFO, some S_ISSOCK, some are buggy and
406 zero the entire struct stat except a couple fields. Hence we don't
407 even try to figure out what something is, except for plain files
410 FIXME: Flush file cache and try again if we run out of memory. */
413 read_include_file (pfile
, inc
)
415 struct include_file
*inc
;
417 ssize_t size
, offset
, count
;
420 static int pagesize
= -1;
423 if (S_ISREG (inc
->st
.st_mode
))
425 /* off_t might have a wider range than ssize_t - in other words,
426 the max size of a file might be bigger than the address
427 space. We can't handle a file that large. (Anyone with
428 a single source file bigger than 2GB needs to rethink
429 their coding style.) Some systems (e.g. AIX 4.1) define
430 SSIZE_MAX to be much smaller than the actual range of the
431 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
433 if (inc
->st
.st_size
> INTTYPE_MAXIMUM (ssize_t
))
435 cpp_error (pfile
, "%s is too large", inc
->name
);
438 size
= inc
->st
.st_size
;
443 pagesize
= getpagesize ();
445 if (size
/ pagesize
>= MMAP_THRESHOLD
)
447 buf
= (U_CHAR
*) mmap (0, size
, PROT_READ
, MAP_PRIVATE
, inc
->fd
, 0);
448 if (buf
== (U_CHAR
*)-1)
455 buf
= (U_CHAR
*) xmalloc (size
);
457 while (offset
< size
)
459 count
= read (inc
->fd
, buf
+ offset
, size
- offset
);
464 cpp_warning (pfile
, "%s is shorter than expected", inc
->name
);
471 else if (S_ISBLK (inc
->st
.st_mode
))
473 cpp_error (pfile
, "%s is a block device", inc
->name
);
478 /* 8 kilobytes is a sensible starting size. It ought to be
479 bigger than the kernel pipe buffer, and it's definitely
480 bigger than the majority of C source files. */
483 buf
= (U_CHAR
*) xmalloc (size
);
485 while ((count
= read (inc
->fd
, buf
+ offset
, size
- offset
)) > 0)
489 buf
= xrealloc (buf
, (size
*= 2));
495 buf
= xrealloc (buf
, offset
);
496 inc
->st
.st_size
= offset
;
503 cpp_error_from_errno (pfile
, inc
->name
);
510 struct include_file
*inc
;
516 munmap ((PTR
) inc
->buffer
, inc
->st
.st_size
);
519 free ((PTR
) inc
->buffer
);
524 /* Return 1 if the file named by FNAME has been included before in
525 any context, 0 otherwise. */
527 cpp_included (pfile
, fname
)
531 struct search_path
*path
;
535 if (IS_ABSOLUTE_PATHNAME (fname
))
537 /* Just look it up. */
538 nd
= splay_tree_lookup (pfile
->all_include_files
, (splay_tree_key
) fname
);
539 return (nd
&& nd
->value
);
542 /* Search directory path for the file. */
543 name
= (char *) alloca (strlen (fname
) + pfile
->max_include_len
+ 2);
544 for (path
= CPP_OPTION (pfile
, quote_include
); path
; path
= path
->next
)
546 memcpy (name
, path
->name
, path
->len
);
547 name
[path
->len
] = '/';
548 strcpy (&name
[path
->len
+ 1], fname
);
549 if (CPP_OPTION (pfile
, remap
))
550 n
= remap_filename (pfile
, name
, path
);
554 nd
= splay_tree_lookup (pfile
->all_include_files
, (splay_tree_key
) n
);
561 /* Search for HEADER. Return 0 if there is no such file (or it's
562 un-openable), in which case an error code will be in errno. If
563 there is no include path to use it returns NO_INCLUDE_PATH,
564 otherwise an include_file structure. If this request originates
565 from a #include_next directive, set INCLUDE_NEXT to true. */
567 static struct include_file
*
568 find_include_file (pfile
, header
, type
)
570 const cpp_token
*header
;
571 enum include_type type
;
573 const char *fname
= (const char *) header
->val
.str
.text
;
574 struct search_path
*path
;
575 struct include_file
*file
;
578 if (IS_ABSOLUTE_PATHNAME (fname
))
579 return open_file_pch (pfile
, fname
);
581 /* For #include_next, skip in the search path past the dir in which
582 the current file was found, but if it was found via an absolute
583 path use the normal search logic. */
584 if (type
== IT_INCLUDE_NEXT
&& pfile
->buffer
->inc
->foundhere
)
585 path
= pfile
->buffer
->inc
->foundhere
->next
;
586 else if (header
->type
== CPP_HEADER_NAME
)
587 path
= CPP_OPTION (pfile
, bracket_include
);
589 path
= search_from (pfile
, type
);
593 cpp_error (pfile
, "No include path in which to find %s", fname
);
594 return NO_INCLUDE_PATH
;
597 /* Search directory path for the file. */
598 name
= (char *) alloca (strlen (fname
) + pfile
->max_include_len
+ 2);
599 for (; path
; path
= path
->next
)
601 memcpy (name
, path
->name
, path
->len
);
602 name
[path
->len
] = '/';
603 strcpy (&name
[path
->len
+ 1], fname
);
604 if (CPP_OPTION (pfile
, remap
))
605 n
= remap_filename (pfile
, name
, path
);
609 file
= open_file_pch (pfile
, n
);
612 file
->foundhere
= path
;
620 /* Not everyone who wants to set system-header-ness on a buffer can
621 see the details of a buffer. This is an exported interface because
622 fix-header needs it. */
624 cpp_make_system_header (pfile
, syshdr
, externc
)
630 /* 1 = system header, 2 = system header to be treated as C. */
632 flags
= 1 + (externc
!= 0);
633 _cpp_do_file_change (pfile
, LC_RENAME
, pfile
->map
->to_file
,
634 SOURCE_LINE (pfile
->map
, pfile
->line
), flags
);
637 /* Report on all files that might benefit from a multiple include guard.
640 _cpp_report_missing_guards (pfile
)
644 splay_tree_foreach (pfile
->all_include_files
, report_missing_guard
,
649 report_missing_guard (n
, b
)
653 struct include_file
*f
= (struct include_file
*) n
->value
;
654 int *bannerp
= (int *)b
;
656 if (f
&& f
->cmacro
== 0 && f
->include_count
== 1)
660 fputs (_("Multiple include guards may be useful for:\n"), stderr
);
663 fputs (f
->name
, stderr
);
669 /* Create a dependency, or issue an error message as appropriate. */
671 handle_missing_header (pfile
, fname
, angle_brackets
)
676 int print_dep
= CPP_PRINT_DEPS(pfile
) > (angle_brackets
|| pfile
->map
->sysp
);
678 if (CPP_OPTION (pfile
, print_deps_missing_files
) && print_dep
)
680 if (!angle_brackets
|| IS_ABSOLUTE_PATHNAME (fname
))
681 deps_add_dep (pfile
->deps
, fname
);
684 /* If requested as a system header, assume it belongs in
685 the first system header directory. */
686 struct search_path
*ptr
= CPP_OPTION (pfile
, bracket_include
);
688 int len
= 0, fname_len
= strlen (fname
);
693 p
= (char *) alloca (len
+ fname_len
+ 2);
696 memcpy (p
, ptr
->name
, len
);
699 memcpy (p
+ len
, fname
, fname_len
+ 1);
700 deps_add_dep (pfile
->deps
, p
);
703 /* If -M was specified, then don't count this as an error, because
704 we can still produce correct output. Otherwise, we can't produce
705 correct output, because there may be dependencies we need inside
706 the missing file, and we don't know what directory this missing
707 file exists in. FIXME: Use a future cpp_diagnotic_with_errno ()
708 for both of these cases. */
709 else if (CPP_PRINT_DEPS (pfile
) && ! print_dep
)
710 cpp_warning (pfile
, "%s: %s", fname
, xstrerror (errno
));
712 cpp_error_from_errno (pfile
, fname
);
715 /* Handles #include-family directives, and the command line -imacros
716 and -include. Returns true if a buffer was stacked. */
718 _cpp_execute_include (pfile
, header
, type
)
720 const cpp_token
*header
;
721 enum include_type type
;
723 bool stacked
= false;
724 struct include_file
*inc
= find_include_file (pfile
, header
, type
);
727 handle_missing_header (pfile
, (const char *) header
->val
.str
.text
,
728 header
->type
== CPP_HEADER_NAME
);
729 else if (inc
!= NO_INCLUDE_PATH
)
731 stacked
= stack_include_file (pfile
, inc
);
733 if (type
== IT_IMPORT
)
734 _cpp_never_reread (inc
);
740 /* Locate HEADER, and determine whether it is newer than the current
741 file. If it cannot be located or dated, return -1, if it is newer
742 newer, return 1, otherwise 0. */
744 _cpp_compare_file_date (pfile
, header
)
746 const cpp_token
*header
;
748 struct include_file
*inc
= find_include_file (pfile
, header
, 0);
750 if (inc
== NULL
|| inc
== NO_INCLUDE_PATH
)
759 return inc
->st
.st_mtime
> pfile
->buffer
->inc
->st
.st_mtime
;
763 /* Push an input buffer and load it up with the contents of FNAME. If
764 FNAME is "", read standard input. Return true if a buffer was
767 _cpp_read_file (pfile
, fname
)
771 struct include_file
*f
= open_file_pch (pfile
, fname
);
772 bool stacked
= false;
775 cpp_error_from_errno (pfile
, fname
);
777 stacked
= stack_include_file (pfile
, f
);
782 /* Do appropriate cleanup when a file buffer is popped off the input
783 stack. Push the next -include file, if any remain. */
785 _cpp_pop_file_buffer (pfile
, inc
)
787 struct include_file
*inc
;
789 /* Record the inclusion-preventing macro, which could be NULL
790 meaning no controlling macro. */
791 if (pfile
->mi_valid
&& inc
->cmacro
== NULL
)
792 inc
->cmacro
= pfile
->mi_cmacro
;
794 /* Invalidate control macros in the #including file. */
795 pfile
->mi_valid
= false;
798 if (inc
->refcnt
== 0 && DO_NOT_REREAD (inc
))
801 /* Don't generate a callback for popping the main file. */
804 _cpp_do_file_change (pfile
, LC_LEAVE
, 0, 0, 0);
806 /* Finally, push the next -included file, if any. */
807 if (!pfile
->buffer
->prev
)
808 _cpp_push_next_buffer (pfile
);
812 /* Returns the first place in the include chain to start searching for
813 "" includes. This involves stripping away the basename of the
814 current file, unless -I- was specified.
816 If we're handling -include or -imacros, use the "" chain, but with
817 the preprocessor's cwd prepended. */
818 static struct search_path
*
819 search_from (pfile
, type
)
821 enum include_type type
;
823 cpp_buffer
*buffer
= pfile
->buffer
;
826 /* Command line uses the cwd, and does not cache the result. */
827 if (type
== IT_CMDLINE
)
830 /* Ignore the current file's directory if -I- was given. */
831 if (CPP_OPTION (pfile
, ignore_srcdir
))
832 return CPP_OPTION (pfile
, quote_include
);
834 if (! buffer
->search_cached
)
836 buffer
->search_cached
= 1;
838 dlen
= lbasename (buffer
->inc
->name
) - buffer
->inc
->name
;
842 /* We don't guarantee NAME is null-terminated. This saves
843 allocating and freeing memory. Drop a trailing '/'. */
844 buffer
->dir
.name
= buffer
->inc
->name
;
851 buffer
->dir
.name
= ".";
855 if (dlen
> pfile
->max_include_len
)
856 pfile
->max_include_len
= dlen
;
858 buffer
->dir
.len
= dlen
;
859 buffer
->dir
.next
= CPP_OPTION (pfile
, quote_include
);
860 buffer
->dir
.sysp
= pfile
->map
->sysp
;
866 /* The file_name_map structure holds a mapping of file names for a
867 particular directory. This mapping is read from the file named
868 FILE_NAME_MAP_FILE in that directory. Such a file can be used to
869 map filenames on a file system with severe filename restrictions,
870 such as DOS. The format of the file name map file is just a series
871 of lines with two tokens on each line. The first token is the name
872 to map, and the second token is the actual name to use. */
876 struct file_name_map
*map_next
;
881 #define FILE_NAME_MAP_FILE "header.gcc"
883 /* Read a space delimited string of unlimited length from a stdio
887 read_filename_string (ch
, f
)
895 set
= alloc
= xmalloc (len
+ 1);
899 while ((ch
= getc (f
)) != EOF
&& ! is_space(ch
))
901 if (set
- alloc
== len
)
904 alloc
= xrealloc (alloc
, len
+ 1);
905 set
= alloc
+ len
/ 2;
915 /* This structure holds a linked list of file name maps, one per directory. */
917 struct file_name_map_list
919 struct file_name_map_list
*map_list_next
;
921 struct file_name_map
*map_list_map
;
924 /* Read the file name map file for DIRNAME. */
926 static struct file_name_map
*
927 read_name_map (pfile
, dirname
)
931 register struct file_name_map_list
*map_list_ptr
;
935 /* Check the cache of directories, and mappings in their remap file. */
936 for (map_list_ptr
= CPP_OPTION (pfile
, map_list
); map_list_ptr
;
937 map_list_ptr
= map_list_ptr
->map_list_next
)
938 if (! strcmp (map_list_ptr
->map_list_name
, dirname
))
939 return map_list_ptr
->map_list_map
;
941 map_list_ptr
= ((struct file_name_map_list
*)
942 xmalloc (sizeof (struct file_name_map_list
)));
943 map_list_ptr
->map_list_name
= xstrdup (dirname
);
945 /* The end of the list ends in NULL. */
946 map_list_ptr
->map_list_map
= NULL
;
948 name
= (char *) alloca (strlen (dirname
) + strlen (FILE_NAME_MAP_FILE
) + 2);
949 strcpy (name
, dirname
);
952 strcat (name
, FILE_NAME_MAP_FILE
);
953 f
= fopen (name
, "r");
955 /* Silently return NULL if we cannot open. */
959 int dirlen
= strlen (dirname
);
961 while ((ch
= getc (f
)) != EOF
)
964 struct file_name_map
*ptr
;
968 from
= read_filename_string (ch
, f
);
969 while ((ch
= getc (f
)) != EOF
&& is_hspace(ch
))
971 to
= read_filename_string (ch
, f
);
973 ptr
= ((struct file_name_map
*)
974 xmalloc (sizeof (struct file_name_map
)));
975 ptr
->map_from
= from
;
977 /* Make the real filename absolute. */
978 if (IS_ABSOLUTE_PATHNAME (to
))
982 ptr
->map_to
= xmalloc (dirlen
+ strlen (to
) + 2);
983 strcpy (ptr
->map_to
, dirname
);
984 ptr
->map_to
[dirlen
] = '/';
985 strcpy (ptr
->map_to
+ dirlen
+ 1, to
);
989 ptr
->map_next
= map_list_ptr
->map_list_map
;
990 map_list_ptr
->map_list_map
= ptr
;
992 while ((ch
= getc (f
)) != '\n')
999 /* Add this information to the cache. */
1000 map_list_ptr
->map_list_next
= CPP_OPTION (pfile
, map_list
);
1001 CPP_OPTION (pfile
, map_list
) = map_list_ptr
;
1003 return map_list_ptr
->map_list_map
;
1006 /* Remap an unsimplified path NAME based on the file_name_map (if any)
1009 remap_filename (pfile
, name
, loc
)
1012 struct search_path
*loc
;
1014 struct file_name_map
*map
;
1015 const char *from
, *p
;
1018 if (! loc
->name_map
)
1020 /* Get a null-terminated path. */
1021 char *dname
= alloca (loc
->len
+ 1);
1022 memcpy (dname
, loc
->name
, loc
->len
);
1023 dname
[loc
->len
] = '\0';
1025 loc
->name_map
= read_name_map (pfile
, dname
);
1026 if (! loc
->name_map
)
1030 /* This works since NAME has not been simplified yet. */
1031 from
= name
+ loc
->len
+ 1;
1033 for (map
= loc
->name_map
; map
; map
= map
->map_next
)
1034 if (!strcmp (map
->map_from
, from
))
1037 /* Try to find a mapping file for the particular directory we are
1038 looking in. Thus #include <sys/types.h> will look up sys/types.h
1039 in /usr/include/header.gcc and look up types.h in
1040 /usr/include/sys/header.gcc. */
1041 p
= strrchr (name
, '/');
1045 /* We know p != name as absolute paths don't call remap_filename. */
1047 cpp_ice (pfile
, "absolute file name in remap_filename");
1049 dir
= (char *) alloca (p
- name
+ 1);
1050 memcpy (dir
, name
, p
- name
);
1051 dir
[p
- name
] = '\0';
1054 for (map
= read_name_map (pfile
, dir
); map
; map
= map
->map_next
)
1055 if (! strcmp (map
->map_from
, from
))
1061 /* Returns true if it is safe to remove the final component of path,
1062 when it is followed by a ".." component. We use lstat to avoid
1063 symlinks if we have it. If not, we can still catch errors with
1066 remove_component_p (path
)
1073 result
= lstat (path
, &s
);
1075 result
= stat (path
, &s
);
1078 /* There's no guarantee that errno will be unchanged, even on
1079 success. Cygwin's lstat(), for example, will often set errno to
1080 ENOSYS. In case of success, reset errno to zero. */
1084 return result
== 0 && S_ISDIR (s
.st_mode
);
1087 /* Simplify a path name in place, deleting redundant components. This
1088 reduces OS overhead and guarantees that equivalent paths compare
1089 the same (modulo symlinks).
1092 foo/bar/../quux foo/quux
1096 //quux //quux (POSIX allows leading // as a namespace escape)
1098 Guarantees no trailing slashes. All transforms reduce the length
1099 of the string. Returns PATH. errno is 0 if no error occurred;
1100 nonzero if an error occurred when using stat () or lstat (). */
1103 _cpp_simplify_pathname (path
)
1108 char *base
, *orig_base
;
1112 /* Don't overflow the empty path by putting a '.' in it below. */
1116 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
1117 /* Convert all backslashes to slashes. */
1118 for (from
= path
; *from
; from
++)
1119 if (*from
== '\\') *from
= '/';
1121 /* Skip over leading drive letter if present. */
1122 if (ISALPHA (path
[0]) && path
[1] == ':')
1123 from
= to
= &path
[2];
1130 /* Remove redundant leading /s. */
1139 /* 3 or more initial /s are equivalent to 1 /. */
1140 while (*++from
== '/');
1142 /* On some hosts // differs from /; Posix allows this. */
1147 base
= orig_base
= to
;
1152 while (*from
== '/')
1160 if (from
[1] == '\0')
1167 else if (from
[1] == '.' && (from
[2] == '/' || from
[2] == '\0'))
1169 /* Don't simplify if there was no previous component. */
1170 if (absolute
&& orig_base
== to
)
1175 /* Don't simplify if the previous component was "../",
1176 or if an error has already occurred with (l)stat. */
1177 if (base
!= to
&& errno
== 0)
1179 /* We don't back up if it's a symlink. */
1181 if (remove_component_p (path
))
1183 while (to
> base
&& *to
!= '/')
1193 /* Add the component separator. */
1197 /* Copy this component until the trailing null or '/'. */
1198 while (*from
!= '\0' && *from
!= '/')
1205 /* Change the empty string to "." so that it is not treated as stdin.