1 /* Part of CPP library. (include file handling)
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1998,
3 1999, 2000, 2001, 2002, 2003 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. */
26 #include "coretypes.h"
32 #include "splay-tree.h"
38 /* If errno is inspected immediately after a system call fails, it will be
39 nonzero, and no error number will ever be zero. */
47 /* Suppress warning about function macros used w/o arguments in traditional
48 C. It is unlikely that glibc's strcmp macro helps this file at all. */
51 /* This structure is used for the table of all includes. */
53 const char *name
; /* actual path name of file */
54 const char *header_name
; /* the original header found */
55 const cpp_hashnode
*cmacro
; /* macro, if any, preventing reinclusion. */
56 const struct cpp_path
*foundhere
;
57 /* location in search path where file was
58 found, for #include_next and sysp. */
59 const unsigned char *buffer
; /* pointer to cached file contents */
60 struct stat st
; /* copy of stat(2) data for file */
61 int fd
; /* fd open on file (short term storage only) */
62 int err_no
; /* errno obtained if opening a file failed */
63 unsigned short include_count
; /* number of times file has been read */
64 unsigned char pch
; /* 0: file not known to be a PCH.
66 (on return from find_include_file).
67 2: file is not and never will be a valid
69 3: file is always a valid precompiled
73 /* Variable length record files on VMS will have a stat size that includes
74 record control characters that won't be included in the read size. */
76 # define FAB_C_VAR 2 /* variable length records (see Starlet fabdef.h) */
77 # define STAT_SIZE_TOO_BIG(ST) ((ST).st_fab_rfm == FAB_C_VAR)
79 # define STAT_SIZE_TOO_BIG(ST) 0
82 /* The cmacro works like this: If it's NULL, the file is to be
83 included again. If it's NEVER_REREAD, the file is never to be
84 included again. Otherwise it is a macro hashnode, and the file is
85 to be included again if the macro is defined. */
86 #define NEVER_REREAD ((const cpp_hashnode *) -1)
87 #define DO_NOT_REREAD(inc) \
88 ((inc)->cmacro && ((inc)->cmacro == NEVER_REREAD \
89 || (inc)->cmacro->type == NT_MACRO))
90 #define NO_INCLUDE_PATH ((struct include_file *) -1)
91 #define INCLUDE_PCH_P(F) (((F)->pch & 1) != 0)
93 static struct file_name_map
*read_name_map
94 PARAMS ((cpp_reader
*, const char *));
95 static char *read_filename_string
PARAMS ((int, FILE *));
96 static char *remap_filename
PARAMS ((cpp_reader
*, char *,
98 static struct cpp_path
*search_from
PARAMS ((cpp_reader
*,
100 static struct include_file
*
101 find_include_file
PARAMS ((cpp_reader
*, const cpp_token
*,
103 static struct include_file
*open_file
PARAMS ((cpp_reader
*, const char *));
104 static struct include_file
*validate_pch
PARAMS ((cpp_reader
*,
107 static struct include_file
*open_file_pch
PARAMS ((cpp_reader
*,
109 static int read_include_file
PARAMS ((cpp_reader
*, struct include_file
*));
110 static bool stack_include_file
PARAMS ((cpp_reader
*, struct include_file
*));
111 static void purge_cache
PARAMS ((struct include_file
*));
112 static void destroy_node
PARAMS ((splay_tree_value
));
113 static int report_missing_guard
PARAMS ((splay_tree_node
, void *));
114 static splay_tree_node find_or_create_entry
PARAMS ((cpp_reader
*,
116 static void handle_missing_header
PARAMS ((cpp_reader
*, const char *, int));
117 static int remove_component_p
PARAMS ((const char *));
119 /* Set up the splay tree we use to store information about all the
120 file names seen in this compilation. We also have entries for each
121 file we tried to open but failed; this saves system calls since we
122 don't try to open it again in future.
124 The key of each node is the file name, after processing by
125 cpp_simplify_path. The path name may or may not be absolute.
126 The path string has been malloced, as is automatically freed by
127 registering free () as the splay tree key deletion function.
129 A node's value is a pointer to a struct include_file, and is never
132 _cpp_init_includes (pfile
)
135 pfile
->all_include_files
136 = splay_tree_new ((splay_tree_compare_fn
) strcmp
,
137 (splay_tree_delete_key_fn
) free
,
141 /* Tear down the splay tree. */
143 _cpp_cleanup_includes (pfile
)
146 splay_tree_delete (pfile
->all_include_files
);
149 /* Free a node. The path string is automatically freed. */
154 struct include_file
*f
= (struct include_file
*) v
;
163 /* Mark a file to not be reread (e.g. #import, read failure). */
165 _cpp_never_reread (file
)
166 struct include_file
*file
;
168 file
->cmacro
= NEVER_REREAD
;
171 /* Lookup a filename, which is simplified after making a copy, and
172 create an entry if none exists. */
173 static splay_tree_node
174 find_or_create_entry (pfile
, fname
)
178 splay_tree_node node
;
179 struct include_file
*file
;
180 char *name
= xstrdup (fname
);
182 cpp_simplify_path (name
);
183 node
= splay_tree_lookup (pfile
->all_include_files
, (splay_tree_key
) name
);
188 file
= xcnew (struct include_file
);
190 file
->header_name
= name
;
191 file
->err_no
= errno
;
192 node
= splay_tree_insert (pfile
->all_include_files
,
193 (splay_tree_key
) file
->name
,
194 (splay_tree_value
) file
);
200 /* Enter a file name in the splay tree, for the sake of cpp_included. */
202 _cpp_fake_include (pfile
, fname
)
206 find_or_create_entry (pfile
, fname
);
209 /* Given a file name, look it up in the cache; if there is no entry,
210 create one with a non-NULL value (regardless of success in opening
211 the file). If the file doesn't exist or is inaccessible, this
212 entry is flagged so we don't attempt to open it again in the
213 future. If the file isn't open, open it. The empty string is
214 interpreted as stdin.
216 Returns an include_file structure with an open file descriptor on
217 success, or NULL on failure. */
218 static struct include_file
*
219 open_file (pfile
, filename
)
221 const char *filename
;
223 splay_tree_node nd
= find_or_create_entry (pfile
, filename
);
224 struct include_file
*file
= (struct include_file
*) nd
->value
;
228 /* Ugh. handle_missing_header () needs errno to be set. */
229 errno
= file
->err_no
;
233 /* Don't reopen an idempotent file. */
234 if (DO_NOT_REREAD (file
))
237 /* Don't reopen one which is already loaded. */
238 if (0 && file
->buffer
!= NULL
)
241 /* We used to open files in nonblocking mode, but that caused more
242 problems than it solved. Do take care not to acquire a
243 controlling terminal by mistake (this can't happen on sane
244 systems, but paranoia is a virtue).
246 Use the three-argument form of open even though we aren't
247 specifying O_CREAT, to defend against broken system headers.
249 O_BINARY tells some runtime libraries (notably DJGPP) not to do
250 newline translation; we can handle DOS line breaks just fine
253 Special case: the empty string is translated to stdin. */
255 if (filename
[0] == '\0')
259 /* For DJGPP redirected input is opened in text mode. Change it
261 if (! isatty (file
->fd
))
262 setmode (file
->fd
, O_BINARY
);
266 file
->fd
= open (file
->name
, O_RDONLY
| O_NOCTTY
| O_BINARY
, 0666);
268 if (file
->fd
!= -1 && fstat (file
->fd
, &file
->st
) == 0)
270 if (!S_ISDIR (file
->st
.st_mode
))
273 /* If it's a directory, we return null and continue the search
274 as the file we're looking for may appear elsewhere in the
281 file
->err_no
= errno
;
285 static struct include_file
*
286 validate_pch (pfile
, filename
, pchname
)
288 const char *filename
;
291 struct include_file
* file
;
293 file
= open_file (pfile
, pchname
);
296 if ((file
->pch
& 2) == 0)
297 file
->pch
= pfile
->cb
.valid_pch (pfile
, pchname
, file
->fd
);
298 if (INCLUDE_PCH_P (file
))
300 char *f
= xstrdup (filename
);
301 cpp_simplify_path (f
);
302 file
->header_name
= f
;
311 /* Like open_file, but also look for a precompiled header if (a) one exists
312 and (b) it is valid. */
313 static struct include_file
*
314 open_file_pch (pfile
, filename
)
316 const char *filename
;
318 if (filename
[0] != '\0'
319 && pfile
->cb
.valid_pch
!= NULL
)
321 size_t namelen
= strlen (filename
);
322 char *pchname
= alloca (namelen
+ 5);
323 struct include_file
* file
;
326 memcpy (pchname
, filename
, namelen
);
327 memcpy (pchname
+ namelen
, ".gch", 5);
329 nd
= find_or_create_entry (pfile
, pchname
);
330 file
= (struct include_file
*) nd
->value
;
334 if (stat (file
->name
, &file
->st
) == 0 && S_ISDIR (file
->st
.st_mode
))
338 size_t subname_len
= namelen
+ 64;
339 char *subname
= xmalloc (subname_len
);
341 thedir
= opendir (pchname
);
344 memcpy (subname
, pchname
, namelen
+ 4);
345 subname
[namelen
+4] = '/';
346 while ((d
= readdir (thedir
)) != NULL
)
348 if (strlen (d
->d_name
) + namelen
+ 7 > subname_len
)
350 subname_len
= strlen (d
->d_name
) + namelen
+ 64;
351 subname
= xrealloc (subname
, subname_len
);
353 strcpy (subname
+ namelen
+ 5, d
->d_name
);
354 file
= validate_pch (pfile
, filename
, subname
);
362 file
= validate_pch (pfile
, filename
, pchname
);
367 return open_file (pfile
, filename
);
370 /* Place the file referenced by INC into a new buffer on the buffer
371 stack, unless there are errors, or the file is not re-included
372 because of e.g. multiple-include guards. Returns true if a buffer
375 stack_include_file (pfile
, inc
)
377 struct include_file
*inc
;
381 const char *filename
;
383 if (DO_NOT_REREAD (inc
))
386 sysp
= MAX ((pfile
->map
? pfile
->map
->sysp
: 0),
387 (inc
->foundhere
? inc
->foundhere
->sysp
: 0));
389 /* Add the file to the dependencies on its first inclusion. */
390 if (CPP_OPTION (pfile
, deps
.style
) > !!sysp
&& !inc
->include_count
)
392 if (pfile
->buffer
|| CPP_OPTION (pfile
, deps
.ignore_main_file
) == 0)
393 deps_add_dep (pfile
->deps
, inc
->name
);
396 /* PCH files get dealt with immediately. */
397 if (INCLUDE_PCH_P (inc
))
399 pfile
->cb
.read_pch (pfile
, inc
->name
, inc
->fd
, inc
->header_name
);
406 if (1 || ! inc
->buffer
)
408 if (read_include_file (pfile
, inc
))
410 /* If an error occurs, do not try to read this file again. */
411 _cpp_never_reread (inc
);
414 /* Mark a regular, zero-length file never-reread. We read it,
415 NUL-terminate it, and stack it once, so preprocessing a main
416 file of zero length does not raise an error. */
417 if (S_ISREG (inc
->st
.st_mode
) && inc
->st
.st_size
== 0)
418 _cpp_never_reread (inc
);
424 /* We don't want MI guard advice for the main file. */
425 inc
->include_count
++;
428 fp
= cpp_push_buffer (pfile
, inc
->buffer
, inc
->st
.st_size
,
429 /* from_stage3 */ CPP_OPTION (pfile
, preprocessed
), 0);
432 /* Initialize controlling macro state. */
433 pfile
->mi_valid
= true;
434 pfile
->mi_cmacro
= 0;
436 /* Generate the call back. */
437 filename
= inc
->name
;
438 if (*filename
== '\0')
439 filename
= "<stdin>";
440 _cpp_do_file_change (pfile
, LC_ENTER
, filename
, 1, sysp
);
445 /* Read the file referenced by INC into the file cache.
447 If fd points to a plain file, we might be able to mmap it; we can
448 definitely allocate the buffer all at once. If fd is a pipe or
449 terminal, we can't do either. If fd is something weird, like a
450 block device, we don't want to read it at all.
452 Unfortunately, different systems use different st.st_mode values
453 for pipes: some have S_ISFIFO, some S_ISSOCK, some are buggy and
454 zero the entire struct stat except a couple fields. Hence we don't
455 even try to figure out what something is, except for plain files
458 FIXME: Flush file cache and try again if we run out of memory. */
460 read_include_file (pfile
, inc
)
462 struct include_file
*inc
;
464 ssize_t size
, offset
, count
;
467 if (S_ISREG (inc
->st
.st_mode
))
469 /* off_t might have a wider range than ssize_t - in other words,
470 the max size of a file might be bigger than the address
471 space. We can't handle a file that large. (Anyone with
472 a single source file bigger than 2GB needs to rethink
473 their coding style.) Some systems (e.g. AIX 4.1) define
474 SSIZE_MAX to be much smaller than the actual range of the
475 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
477 if (inc
->st
.st_size
> INTTYPE_MAXIMUM (ssize_t
))
479 cpp_error (pfile
, DL_ERROR
, "%s is too large", inc
->name
);
482 size
= inc
->st
.st_size
;
485 buf
= (uchar
*) xmalloc (size
+ 1);
487 while (offset
< size
)
489 count
= read (inc
->fd
, buf
+ offset
, size
- offset
);
494 if (!STAT_SIZE_TOO_BIG (inc
->st
))
495 cpp_error (pfile
, DL_WARNING
,
496 "%s is shorter than expected", inc
->name
);
498 buf
= xrealloc (buf
, size
+ 1);
499 inc
->st
.st_size
= size
;
504 /* The lexer requires that the buffer be \n-terminated. */
508 else if (S_ISBLK (inc
->st
.st_mode
))
510 cpp_error (pfile
, DL_ERROR
, "%s is a block device", inc
->name
);
515 /* 8 kilobytes is a sensible starting size. It ought to be
516 bigger than the kernel pipe buffer, and it's definitely
517 bigger than the majority of C source files. */
520 buf
= (uchar
*) xmalloc (size
+ 1);
522 while ((count
= read (inc
->fd
, buf
+ offset
, size
- offset
)) > 0)
528 buf
= xrealloc (buf
, size
+ 1);
534 if (offset
+ 1 < size
)
535 buf
= xrealloc (buf
, offset
+ 1);
537 /* The lexer requires that the buffer be \n-terminated. */
539 inc
->st
.st_size
= offset
;
546 cpp_errno (pfile
, DL_ERROR
, inc
->name
);
551 /* Drop INC's buffer from memory. */
554 struct include_file
*inc
;
558 free ((PTR
) inc
->buffer
);
563 /* Return 1 if the file named by FNAME has been included before in
564 any context, 0 otherwise. */
566 cpp_included (pfile
, fname
)
570 struct cpp_path
*path
;
574 if (IS_ABSOLUTE_PATHNAME (fname
))
576 /* Just look it up. */
577 nd
= splay_tree_lookup (pfile
->all_include_files
, (splay_tree_key
) fname
);
578 return (nd
&& nd
->value
);
581 /* Search directory path for the file. */
582 name
= (char *) alloca (strlen (fname
) + pfile
->max_include_len
+ 2);
583 for (path
= pfile
->quote_include
; path
; path
= path
->next
)
585 memcpy (name
, path
->name
, path
->len
);
586 name
[path
->len
] = '/';
587 strcpy (&name
[path
->len
+ 1], fname
);
588 if (CPP_OPTION (pfile
, remap
))
589 n
= remap_filename (pfile
, name
, path
);
593 nd
= splay_tree_lookup (pfile
->all_include_files
, (splay_tree_key
) n
);
600 /* Search for HEADER. Return 0 if there is no such file (or it's
601 un-openable), in which case an error code will be in errno. If
602 there is no include path to use it returns NO_INCLUDE_PATH,
603 otherwise an include_file structure. If this request originates
604 from a directive of TYPE #include_next, set INCLUDE_NEXT to true. */
605 static struct include_file
*
606 find_include_file (pfile
, header
, type
)
608 const cpp_token
*header
;
609 enum include_type type
;
611 const char *fname
= (const char *) header
->val
.str
.text
;
612 struct cpp_path
*path
;
613 struct include_file
*file
;
616 if (IS_ABSOLUTE_PATHNAME (fname
))
617 return open_file_pch (pfile
, fname
);
619 /* For #include_next, skip in the search path past the dir in which
620 the current file was found, but if it was found via an absolute
621 path use the normal search logic. */
622 if (type
== IT_INCLUDE_NEXT
&& pfile
->buffer
->inc
->foundhere
)
623 path
= pfile
->buffer
->inc
->foundhere
->next
;
624 else if (header
->type
== CPP_HEADER_NAME
)
625 path
= pfile
->bracket_include
;
627 path
= search_from (pfile
, type
);
631 cpp_error (pfile
, DL_ERROR
, "no include path in which to find %s",
633 return NO_INCLUDE_PATH
;
636 /* Search directory path for the file. */
637 name
= (char *) alloca (strlen (fname
) + pfile
->max_include_len
+ 2);
638 for (; path
; path
= path
->next
)
641 memcpy (name
, path
->name
, len
);
642 /* Don't turn / into // or // into ///; // may be a namespace
644 if (name
[len
-1] == '/')
647 strcpy (&name
[len
+ 1], fname
);
648 if (CPP_OPTION (pfile
, remap
))
649 n
= remap_filename (pfile
, name
, path
);
653 file
= open_file_pch (pfile
, n
);
656 file
->foundhere
= path
;
664 /* Not everyone who wants to set system-header-ness on a buffer can
665 see the details of a buffer. This is an exported interface because
666 fix-header needs it. */
668 cpp_make_system_header (pfile
, syshdr
, externc
)
674 /* 1 = system header, 2 = system header to be treated as C. */
676 flags
= 1 + (externc
!= 0);
677 _cpp_do_file_change (pfile
, LC_RENAME
, pfile
->map
->to_file
,
678 SOURCE_LINE (pfile
->map
, pfile
->line
), flags
);
681 /* Allow the client to change the current file. Used by the front end
682 to achieve pseudo-file names like <built-in>.
683 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
685 cpp_change_file (pfile
, reason
, new_name
)
687 enum lc_reason reason
;
688 const char *new_name
;
690 _cpp_do_file_change (pfile
, reason
, new_name
, 1, 0);
693 /* Report on all files that might benefit from a multiple include guard.
696 _cpp_report_missing_guards (pfile
)
700 splay_tree_foreach (pfile
->all_include_files
, report_missing_guard
,
704 /* Callback function for splay_tree_foreach(). */
706 report_missing_guard (n
, b
)
710 struct include_file
*f
= (struct include_file
*) n
->value
;
711 int *bannerp
= (int *) b
;
713 if (f
&& f
->cmacro
== 0 && f
->include_count
== 1)
717 fputs (_("Multiple include guards may be useful for:\n"), stderr
);
720 fputs (f
->name
, stderr
);
726 /* Create a dependency for file FNAME, or issue an error message as
727 appropriate. ANGLE_BRACKETS is nonzero if the file was bracketed
730 handle_missing_header (pfile
, fname
, angle_brackets
)
736 = CPP_OPTION (pfile
, deps
.style
) > (angle_brackets
|| pfile
->map
->sysp
);
738 if (CPP_OPTION (pfile
, deps
.missing_files
) && print_dep
)
739 deps_add_dep (pfile
->deps
, fname
);
740 /* If -M was specified, then don't count this as an error, because
741 we can still produce correct output. Otherwise, we can't produce
742 correct output, because there may be dependencies we need inside
743 the missing file, and we don't know what directory this missing
746 cpp_errno (pfile
, CPP_OPTION (pfile
, deps
.style
) && ! print_dep
747 ? DL_WARNING
: DL_ERROR
, fname
);
750 /* Handles #include-family directives (distinguished by TYPE),
751 including HEADER, and the command line -imacros and -include.
752 Returns true if a buffer was stacked. */
754 _cpp_execute_include (pfile
, header
, type
)
756 const cpp_token
*header
;
757 enum include_type type
;
759 bool stacked
= false;
760 struct include_file
*inc
= find_include_file (pfile
, header
, type
);
763 handle_missing_header (pfile
, (const char *) header
->val
.str
.text
,
764 header
->type
== CPP_HEADER_NAME
);
765 else if (inc
!= NO_INCLUDE_PATH
)
767 stacked
= stack_include_file (pfile
, inc
);
769 if (type
== IT_IMPORT
)
770 _cpp_never_reread (inc
);
776 /* Locate HEADER, and determine whether it is newer than the current
777 file. If it cannot be located or dated, return -1, if it is newer
778 newer, return 1, otherwise 0. */
780 _cpp_compare_file_date (pfile
, header
)
782 const cpp_token
*header
;
784 struct include_file
*inc
= find_include_file (pfile
, header
, 0);
786 if (inc
== NULL
|| inc
== NO_INCLUDE_PATH
)
795 return inc
->st
.st_mtime
> pfile
->buffer
->inc
->st
.st_mtime
;
799 /* Push an input buffer and load it up with the contents of FNAME. If
800 FNAME is "", read standard input. Return true if a buffer was
803 _cpp_read_file (pfile
, fname
)
807 /* This uses open_file, because we don't allow a PCH to be used as
808 the toplevel compilation (that would prevent re-compiling an
809 existing PCH without deleting it first). */
810 struct include_file
*f
= open_file (pfile
, fname
);
814 cpp_errno (pfile
, DL_ERROR
, fname
);
818 return stack_include_file (pfile
, f
);
821 /* Pushes the given file onto the buffer stack. Returns nonzero if
824 cpp_push_include (pfile
, filename
)
826 const char *filename
;
830 header
.type
= CPP_STRING
;
831 header
.val
.str
.text
= (const unsigned char *) filename
;
832 header
.val
.str
.len
= strlen (filename
);
833 /* Make the command line directive take up a line. */
836 return _cpp_execute_include (pfile
, &header
, IT_CMDLINE
);
839 /* Do appropriate cleanup when a file INC's buffer is popped off the
842 _cpp_pop_file_buffer (pfile
, inc
)
844 struct include_file
*inc
;
846 /* Record the inclusion-preventing macro, which could be NULL
847 meaning no controlling macro. */
848 if (pfile
->mi_valid
&& inc
->cmacro
== NULL
)
849 inc
->cmacro
= pfile
->mi_cmacro
;
851 /* Invalidate control macros in the #including file. */
852 pfile
->mi_valid
= false;
857 /* Returns the first place in the include chain to start searching for
858 "" includes. This involves stripping away the basename of the
859 current file, unless -I- was specified.
861 If we're handling -include or -imacros, use the "" chain, but with
862 the preprocessor's cwd prepended. */
863 static struct cpp_path
*
864 search_from (pfile
, type
)
866 enum include_type type
;
868 cpp_buffer
*buffer
= pfile
->buffer
;
871 /* Command line uses the cwd, and does not cache the result. */
872 if (type
== IT_CMDLINE
)
875 /* Ignore the current file's directory? */
876 if (pfile
->quote_ignores_source_dir
)
877 return pfile
->quote_include
;
879 if (! buffer
->search_cached
)
881 buffer
->search_cached
= 1;
883 dlen
= lbasename (buffer
->inc
->name
) - buffer
->inc
->name
;
887 /* We don't guarantee NAME is null-terminated. This saves
888 allocating and freeing memory. Drop a trailing '/'. */
889 buffer
->dir
.name
= (char *) buffer
->inc
->name
;
896 buffer
->dir
.name
= (char *) ".";
900 if (dlen
> pfile
->max_include_len
)
901 pfile
->max_include_len
= dlen
;
903 buffer
->dir
.len
= dlen
;
904 buffer
->dir
.next
= pfile
->quote_include
;
905 buffer
->dir
.sysp
= pfile
->map
->sysp
;
911 /* The file_name_map structure holds a mapping of file names for a
912 particular directory. This mapping is read from the file named
913 FILE_NAME_MAP_FILE in that directory. Such a file can be used to
914 map filenames on a file system with severe filename restrictions,
915 such as DOS. The format of the file name map file is just a series
916 of lines with two tokens on each line. The first token is the name
917 to map, and the second token is the actual name to use. */
918 struct file_name_map
{
919 struct file_name_map
*map_next
;
924 #define FILE_NAME_MAP_FILE "header.gcc"
926 /* Read a space delimited string of unlimited length from a stdio
929 read_filename_string (ch
, f
)
937 set
= alloc
= xmalloc (len
+ 1);
941 while ((ch
= getc (f
)) != EOF
&& ! is_space (ch
))
943 if (set
- alloc
== len
)
946 alloc
= xrealloc (alloc
, len
+ 1);
947 set
= alloc
+ len
/ 2;
957 /* This structure holds a linked list of file name maps, one per directory. */
958 struct file_name_map_list
{
959 struct file_name_map_list
*map_list_next
;
961 struct file_name_map
*map_list_map
;
964 /* Read the file name map file for DIRNAME. */
965 static struct file_name_map
*
966 read_name_map (pfile
, dirname
)
970 struct file_name_map_list
*map_list_ptr
;
974 /* Check the cache of directories, and mappings in their remap file. */
975 for (map_list_ptr
= CPP_OPTION (pfile
, map_list
); map_list_ptr
;
976 map_list_ptr
= map_list_ptr
->map_list_next
)
977 if (! strcmp (map_list_ptr
->map_list_name
, dirname
))
978 return map_list_ptr
->map_list_map
;
980 map_list_ptr
= ((struct file_name_map_list
*)
981 xmalloc (sizeof (struct file_name_map_list
)));
982 map_list_ptr
->map_list_name
= xstrdup (dirname
);
984 /* The end of the list ends in NULL. */
985 map_list_ptr
->map_list_map
= NULL
;
987 name
= (char *) alloca (strlen (dirname
) + strlen (FILE_NAME_MAP_FILE
) + 2);
988 strcpy (name
, dirname
);
991 strcat (name
, FILE_NAME_MAP_FILE
);
992 f
= fopen (name
, "r");
994 /* Silently return NULL if we cannot open. */
999 while ((ch
= getc (f
)) != EOF
)
1002 struct file_name_map
*ptr
;
1006 from
= read_filename_string (ch
, f
);
1007 while ((ch
= getc (f
)) != EOF
&& is_hspace (ch
))
1009 to
= read_filename_string (ch
, f
);
1011 ptr
= ((struct file_name_map
*)
1012 xmalloc (sizeof (struct file_name_map
)));
1013 ptr
->map_from
= from
;
1015 /* Make the real filename absolute. */
1016 if (IS_ABSOLUTE_PATHNAME (to
))
1020 ptr
->map_to
= concat (dirname
, "/", to
, NULL
);
1024 ptr
->map_next
= map_list_ptr
->map_list_map
;
1025 map_list_ptr
->map_list_map
= ptr
;
1027 while ((ch
= getc (f
)) != '\n')
1034 /* Add this information to the cache. */
1035 map_list_ptr
->map_list_next
= CPP_OPTION (pfile
, map_list
);
1036 CPP_OPTION (pfile
, map_list
) = map_list_ptr
;
1038 return map_list_ptr
->map_list_map
;
1041 /* Remap an unsimplified path NAME based on the file_name_map (if any)
1044 remap_filename (pfile
, name
, loc
)
1047 struct cpp_path
*loc
;
1049 struct file_name_map
*map
;
1050 const char *from
, *p
;
1053 if (! loc
->name_map
)
1055 /* Get a null-terminated path. */
1056 char *dname
= alloca (loc
->len
+ 1);
1057 memcpy (dname
, loc
->name
, loc
->len
);
1058 dname
[loc
->len
] = '\0';
1060 loc
->name_map
= read_name_map (pfile
, dname
);
1061 if (! loc
->name_map
)
1065 /* This works since NAME has not been simplified yet. */
1066 from
= name
+ loc
->len
+ 1;
1068 for (map
= loc
->name_map
; map
; map
= map
->map_next
)
1069 if (!strcmp (map
->map_from
, from
))
1072 /* Try to find a mapping file for the particular directory we are
1073 looking in. Thus #include <sys/types.h> will look up sys/types.h
1074 in /usr/include/header.gcc and look up types.h in
1075 /usr/include/sys/header.gcc. */
1076 p
= strrchr (name
, '/');
1080 /* We know p != name as absolute paths don't call remap_filename. */
1082 cpp_error (pfile
, DL_ICE
, "absolute file name in remap_filename");
1084 dir
= (char *) alloca (p
- name
+ 1);
1085 memcpy (dir
, name
, p
- name
);
1086 dir
[p
- name
] = '\0';
1089 for (map
= read_name_map (pfile
, dir
); map
; map
= map
->map_next
)
1090 if (! strcmp (map
->map_from
, from
))
1096 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1097 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1098 directory of the including file.
1100 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1102 cpp_set_include_chains (pfile
, quote
, bracket
, quote_ignores_source_dir
)
1104 cpp_path
*quote
, *bracket
;
1105 int quote_ignores_source_dir
;
1107 pfile
->quote_include
= quote
;
1108 pfile
->bracket_include
= quote
;
1109 pfile
->quote_ignores_source_dir
= quote_ignores_source_dir
;
1110 pfile
->max_include_len
= 0;
1112 for (; quote
; quote
= quote
->next
)
1114 quote
->name_map
= NULL
;
1115 quote
->len
= strlen (quote
->name
);
1116 if (quote
->len
> pfile
->max_include_len
)
1117 pfile
->max_include_len
= quote
->len
;
1118 if (quote
== bracket
)
1119 pfile
->bracket_include
= bracket
;
1123 /* Returns true if it is safe to remove the final component of path,
1124 when it is followed by a ".." component. We use lstat to avoid
1125 symlinks if we have it. If not, we can still catch errors with
1128 remove_component_p (path
)
1135 result
= lstat (path
, &s
);
1137 result
= stat (path
, &s
);
1140 /* There's no guarantee that errno will be unchanged, even on
1141 success. Cygwin's lstat(), for example, will often set errno to
1142 ENOSYS. In case of success, reset errno to zero. */
1146 return result
== 0 && S_ISDIR (s
.st_mode
);
1149 /* Simplify a path name in place, deleting redundant components. This
1150 reduces OS overhead and guarantees that equivalent paths compare
1151 the same (modulo symlinks).
1154 foo/bar/../quux foo/quux
1158 //quux //quux (POSIX allows leading // as a namespace escape)
1160 Guarantees no trailing slashes. All transforms reduce the length
1161 of the string. Returns PATH. errno is 0 if no error occurred;
1162 nonzero if an error occurred when using stat () or lstat (). */
1164 cpp_simplify_path (path
)
1165 char *path ATTRIBUTE_UNUSED
;
1169 char *base
, *orig_base
;
1173 /* Don't overflow the empty path by putting a '.' in it below. */
1177 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
1178 /* Convert all backslashes to slashes. */
1179 for (from
= path
; *from
; from
++)
1180 if (*from
== '\\') *from
= '/';
1182 /* Skip over leading drive letter if present. */
1183 if (ISALPHA (path
[0]) && path
[1] == ':')
1184 from
= to
= &path
[2];
1191 /* Remove redundant leading /s. */
1200 /* 3 or more initial /s are equivalent to 1 /. */
1201 while (*++from
== '/');
1203 /* On some hosts // differs from /; Posix allows this. */
1208 base
= orig_base
= to
;
1213 while (*from
== '/')
1221 if (from
[1] == '\0')
1228 else if (from
[1] == '.' && (from
[2] == '/' || from
[2] == '\0'))
1230 /* Don't simplify if there was no previous component. */
1231 if (absolute
&& orig_base
== to
)
1236 /* Don't simplify if the previous component was "../",
1237 or if an error has already occurred with (l)stat. */
1238 if (base
!= to
&& errno
== 0)
1240 /* We don't back up if it's a symlink. */
1242 if (remove_component_p (path
))
1244 while (to
> base
&& *to
!= '/')
1254 /* Add the component separator. */
1258 /* Copy this component until the trailing null or '/'. */
1259 while (*from
!= '\0' && *from
!= '/')
1266 /* Change the empty string to "." so that it is not treated as stdin.