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 /* This structure is used for the table of all includes. */
49 const char *name; /* actual path name of file */
50 const char *header_name; /* the original header found */
51 const cpp_hashnode *cmacro; /* macro, if any, preventing reinclusion. */
52 const struct cpp_path *foundhere;
53 /* location in search path where file was
54 found, for #include_next and sysp. */
55 const unsigned char *buffer; /* pointer to cached file contents */
56 struct stat st; /* copy of stat(2) data for file */
57 int fd; /* fd open on file (short term storage only) */
58 int err_no; /* errno obtained if opening a file failed */
59 unsigned short include_count; /* number of times file has been read */
60 unsigned char pch; /* 0: file not known to be a PCH.
62 (on return from find_include_file).
63 2: file is not and never will be a valid
65 3: file is always a valid precompiled
69 /* Variable length record files on VMS will have a stat size that includes
70 record control characters that won't be included in the read size. */
72 # define FAB_C_VAR 2 /* variable length records (see Starlet fabdef.h) */
73 # define STAT_SIZE_TOO_BIG(ST) ((ST).st_fab_rfm == FAB_C_VAR)
75 # define STAT_SIZE_TOO_BIG(ST) 0
78 /* The cmacro works like this: If it's NULL, the file is to be
79 included again. If it's NEVER_REREAD, the file is never to be
80 included again. Otherwise it is a macro hashnode, and the file is
81 to be included again if the macro is defined. */
82 #define NEVER_REREAD ((const cpp_hashnode *) -1)
83 #define DO_NOT_REREAD(inc) \
84 ((inc)->cmacro && ((inc)->cmacro == NEVER_REREAD \
85 || (inc)->cmacro->type == NT_MACRO))
86 #define NO_INCLUDE_PATH ((struct include_file *) -1)
87 #define INCLUDE_PCH_P(F) (((F)->pch & 1) != 0)
89 static struct file_name_map *read_name_map
90 PARAMS ((cpp_reader *, const char *));
91 static char *read_filename_string PARAMS ((int, FILE *));
92 static char *remap_filename PARAMS ((cpp_reader *, char *,
94 static struct cpp_path *search_from PARAMS ((cpp_reader *,
96 static struct include_file *
97 find_include_file PARAMS ((cpp_reader *, const char *, int,
99 static struct include_file *open_file PARAMS ((cpp_reader *, const char *));
100 static struct include_file *validate_pch PARAMS ((cpp_reader *,
103 static struct include_file *open_file_pch PARAMS ((cpp_reader *,
105 static int read_include_file PARAMS ((cpp_reader *, struct include_file *));
106 static bool stack_include_file PARAMS ((cpp_reader *, struct include_file *));
107 static void purge_cache PARAMS ((struct include_file *));
108 static void destroy_node PARAMS ((splay_tree_value));
109 static int report_missing_guard PARAMS ((splay_tree_node, void *));
110 static splay_tree_node find_or_create_entry PARAMS ((cpp_reader *,
112 static void handle_missing_header PARAMS ((cpp_reader *, const char *, int));
113 static int remove_component_p PARAMS ((const char *));
115 /* Set up the splay tree we use to store information about all the
116 file names seen in this compilation. We also have entries for each
117 file we tried to open but failed; this saves system calls since we
118 don't try to open it again in future.
120 The key of each node is the file name, after processing by
121 cpp_simplify_path. The path name may or may not be absolute.
122 The path string has been malloced, as is automatically freed by
123 registering free () as the splay tree key deletion function.
125 A node's value is a pointer to a struct include_file, and is never
128 _cpp_init_includes (pfile)
131 pfile->all_include_files
132 = splay_tree_new ((splay_tree_compare_fn) strcmp,
133 (splay_tree_delete_key_fn) free,
137 /* Tear down the splay tree. */
139 _cpp_cleanup_includes (pfile)
142 splay_tree_delete (pfile->all_include_files);
145 /* Free a node. The path string is automatically freed. */
150 struct include_file *f = (struct include_file *) v;
159 /* Mark a file to not be reread (e.g. #import, read failure). */
161 _cpp_never_reread (file)
162 struct include_file *file;
164 file->cmacro = NEVER_REREAD;
167 /* Lookup a filename, which is simplified after making a copy, and
168 create an entry if none exists. */
169 static splay_tree_node
170 find_or_create_entry (pfile, fname)
174 splay_tree_node node;
175 struct include_file *file;
176 char *name = xstrdup (fname);
179 cpp_simplify_path (name);
181 node = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) name);
186 file = xcnew (struct include_file);
188 file->header_name = name;
189 file->err_no = saved_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. */
216 static struct include_file *
217 open_file (pfile, filename)
219 const char *filename;
221 splay_tree_node nd = find_or_create_entry (pfile, filename);
222 struct include_file *file = (struct include_file *) nd->value;
226 /* Ugh. handle_missing_header () needs errno to be set. */
227 errno = file->err_no;
231 /* Don't reopen an idempotent file. */
232 if (DO_NOT_REREAD (file))
235 /* Don't reopen one which is already loaded. */
236 if (0 && file->buffer != NULL)
239 /* We used to open files in nonblocking mode, but that caused more
240 problems than it solved. Do take care not to acquire a
241 controlling terminal by mistake (this can't happen on sane
242 systems, but paranoia is a virtue).
244 Use the three-argument form of open even though we aren't
245 specifying O_CREAT, to defend against broken system headers.
247 O_BINARY tells some runtime libraries (notably DJGPP) not to do
248 newline translation; we can handle DOS line breaks just fine
251 Special case: the empty string is translated to stdin. */
253 if (filename[0] == '\0')
257 /* For DJGPP redirected input is opened in text mode. Change it
259 if (! isatty (file->fd))
260 setmode (file->fd, O_BINARY);
264 file->fd = open (file->name, O_RDONLY | O_NOCTTY | O_BINARY, 0666);
266 if (file->fd != -1 && fstat (file->fd, &file->st) == 0)
268 if (!S_ISDIR (file->st.st_mode))
271 /* If it's a directory, we return null and continue the search
272 as the file we're looking for may appear elsewhere in the
279 file->err_no = errno;
283 static struct include_file *
284 validate_pch (pfile, filename, pchname)
286 const char *filename;
289 struct include_file * file;
291 file = open_file (pfile, pchname);
294 if ((file->pch & 2) == 0)
295 file->pch = pfile->cb.valid_pch (pfile, pchname, file->fd);
296 if (CPP_OPTION (pfile, print_include_names))
299 for (i = 1; i < pfile->line_maps.depth; i++)
301 fprintf (stderr, "%c %s\n", INCLUDE_PCH_P (file) ? '!' : 'x', pchname);
303 if (INCLUDE_PCH_P (file))
305 char *f = xstrdup (filename);
306 cpp_simplify_path (f);
307 file->header_name = f;
316 /* Like open_file, but also look for a precompiled header if (a) one exists
317 and (b) it is valid. */
318 static struct include_file *
319 open_file_pch (pfile, filename)
321 const char *filename;
323 if (filename[0] != '\0'
324 && pfile->cb.valid_pch != NULL)
326 size_t namelen = strlen (filename);
327 char *pchname = alloca (namelen + 5);
328 struct include_file * file;
331 memcpy (pchname, filename, namelen);
332 memcpy (pchname + namelen, ".gch", 5);
334 nd = find_or_create_entry (pfile, pchname);
335 file = (struct include_file *) nd->value;
339 if (stat (file->name, &file->st) == 0 && S_ISDIR (file->st.st_mode))
343 size_t subname_len = namelen + 64;
344 char *subname = xmalloc (subname_len);
346 thedir = opendir (pchname);
349 memcpy (subname, pchname, namelen + 4);
350 subname[namelen+4] = '/';
351 while ((d = readdir (thedir)) != NULL)
353 if (strlen (d->d_name) + namelen + 7 > subname_len)
355 subname_len = strlen (d->d_name) + namelen + 64;
356 subname = xrealloc (subname, subname_len);
358 strcpy (subname + namelen + 5, d->d_name);
359 file = validate_pch (pfile, filename, subname);
367 file = validate_pch (pfile, filename, pchname);
372 return open_file (pfile, filename);
375 /* Place the file referenced by INC into a new buffer on the buffer
376 stack, unless there are errors, or the file is not re-included
377 because of e.g. multiple-include guards. Returns true if a buffer
380 stack_include_file (pfile, inc)
382 struct include_file *inc;
386 const char *filename;
388 if (DO_NOT_REREAD (inc))
391 sysp = MAX ((pfile->map ? pfile->map->sysp : 0),
392 (inc->foundhere ? inc->foundhere->sysp : 0));
394 /* Add the file to the dependencies on its first inclusion. */
395 if (CPP_OPTION (pfile, deps.style) > !!sysp && !inc->include_count)
397 if (pfile->buffer || CPP_OPTION (pfile, deps.ignore_main_file) == 0)
398 deps_add_dep (pfile->deps, inc->name);
401 /* PCH files get dealt with immediately. */
402 if (INCLUDE_PCH_P (inc))
404 pfile->cb.read_pch (pfile, inc->name, inc->fd, inc->header_name);
411 if (1 || ! inc->buffer)
413 if (read_include_file (pfile, inc))
415 /* If an error occurs, do not try to read this file again. */
416 _cpp_never_reread (inc);
419 /* Mark a regular, zero-length file never-reread. We read it,
420 NUL-terminate it, and stack it once, so preprocessing a main
421 file of zero length does not raise an error. */
422 if (S_ISREG (inc->st.st_mode) && inc->st.st_size == 0)
423 _cpp_never_reread (inc);
429 /* We don't want MI guard advice for the main file. */
430 inc->include_count++;
433 fp = cpp_push_buffer (pfile, inc->buffer, inc->st.st_size,
434 /* from_stage3 */ CPP_OPTION (pfile, preprocessed), 0);
437 /* Initialize controlling macro state. */
438 pfile->mi_valid = true;
439 pfile->mi_cmacro = 0;
441 /* Generate the call back. */
442 filename = inc->name;
443 if (*filename == '\0')
444 filename = "<stdin>";
445 _cpp_do_file_change (pfile, LC_ENTER, filename, 1, sysp);
450 /* Read the file referenced by INC into the file cache.
452 If fd points to a plain file, we might be able to mmap it; we can
453 definitely allocate the buffer all at once. If fd is a pipe or
454 terminal, we can't do either. If fd is something weird, like a
455 block device, we don't want to read it at all.
457 Unfortunately, different systems use different st.st_mode values
458 for pipes: some have S_ISFIFO, some S_ISSOCK, some are buggy and
459 zero the entire struct stat except a couple fields. Hence we don't
460 even try to figure out what something is, except for plain files
463 FIXME: Flush file cache and try again if we run out of memory. */
465 read_include_file (pfile, inc)
467 struct include_file *inc;
469 ssize_t size, offset, count;
472 if (S_ISREG (inc->st.st_mode))
474 /* off_t might have a wider range than ssize_t - in other words,
475 the max size of a file might be bigger than the address
476 space. We can't handle a file that large. (Anyone with
477 a single source file bigger than 2GB needs to rethink
478 their coding style.) Some systems (e.g. AIX 4.1) define
479 SSIZE_MAX to be much smaller than the actual range of the
480 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
482 if (inc->st.st_size > INTTYPE_MAXIMUM (ssize_t))
484 cpp_error (pfile, DL_ERROR, "%s is too large", inc->name);
487 size = inc->st.st_size;
490 buf = (uchar *) xmalloc (size + 1);
492 while (offset < size)
494 count = read (inc->fd, buf + offset, size - offset);
499 if (!STAT_SIZE_TOO_BIG (inc->st))
500 cpp_error (pfile, DL_WARNING,
501 "%s is shorter than expected", inc->name);
503 buf = xrealloc (buf, size + 1);
504 inc->st.st_size = size;
509 /* The lexer requires that the buffer be \n-terminated. */
513 else if (S_ISBLK (inc->st.st_mode))
515 cpp_error (pfile, DL_ERROR, "%s is a block device", inc->name);
520 /* 8 kilobytes is a sensible starting size. It ought to be
521 bigger than the kernel pipe buffer, and it's definitely
522 bigger than the majority of C source files. */
525 buf = (uchar *) xmalloc (size + 1);
527 while ((count = read (inc->fd, buf + offset, size - offset)) > 0)
533 buf = xrealloc (buf, size + 1);
539 if (offset + 1 < size)
540 buf = xrealloc (buf, offset + 1);
542 /* The lexer requires that the buffer be \n-terminated. */
544 inc->st.st_size = offset;
551 cpp_errno (pfile, DL_ERROR, inc->name);
556 /* Drop INC's buffer from memory. */
559 struct include_file *inc;
563 free ((void *) inc->buffer);
568 /* Return 1 if the file named by FNAME has been included before in
569 any context, 0 otherwise. */
571 cpp_included (pfile, fname)
575 struct cpp_path *path;
579 if (IS_ABSOLUTE_PATHNAME (fname))
581 /* Just look it up. */
582 nd = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) fname);
583 return (nd && nd->value);
586 /* Search directory path for the file. */
587 name = (char *) alloca (strlen (fname) + pfile->max_include_len + 2);
588 for (path = pfile->quote_include; path; path = path->next)
590 memcpy (name, path->name, path->len);
591 name[path->len] = '/';
592 strcpy (&name[path->len + 1], fname);
593 if (CPP_OPTION (pfile, remap))
594 n = remap_filename (pfile, name, path);
598 nd = splay_tree_lookup (pfile->all_include_files, (splay_tree_key) n);
605 /* Search for FNAME. Return 0 if there is no such file (or it's
606 un-openable), in which case an error code will be in errno. If
607 there is no include path to use it returns NO_INCLUDE_PATH,
608 otherwise an include_file structure. If this request originates
609 from a directive of TYPE #include_next, set INCLUDE_NEXT to true. */
610 static struct include_file *
611 find_include_file (pfile, fname, angle_brackets, type)
615 enum include_type type;
617 struct cpp_path *path;
618 struct include_file *file;
623 cpp_error (pfile, DL_ERROR, "empty file name");
624 return NO_INCLUDE_PATH;
627 if (IS_ABSOLUTE_PATHNAME (fname))
628 return open_file_pch (pfile, fname);
630 /* For #include_next, skip in the search path past the dir in which
631 the current file was found, but if it was found via an absolute
632 path use the normal search logic. */
633 if (type == IT_INCLUDE_NEXT && pfile->buffer->inc->foundhere)
634 path = pfile->buffer->inc->foundhere->next;
635 else if (angle_brackets)
636 path = pfile->bracket_include;
638 path = search_from (pfile, type);
642 cpp_error (pfile, DL_ERROR, "no include path in which to find %s",
644 return NO_INCLUDE_PATH;
647 /* Search directory path for the file. */
648 name = (char *) alloca (strlen (fname) + pfile->max_include_len + 2);
649 for (; path; path = path->next)
652 memcpy (name, path->name, len);
653 /* Don't turn / into // or // into ///; // may be a namespace
655 if (name[len-1] == '/')
658 strcpy (&name[len + 1], fname);
659 if (CPP_OPTION (pfile, remap))
660 n = remap_filename (pfile, name, path);
664 file = open_file_pch (pfile, n);
667 file->foundhere = path;
675 /* Not everyone who wants to set system-header-ness on a buffer can
676 see the details of a buffer. This is an exported interface because
677 fix-header needs it. */
679 cpp_make_system_header (pfile, syshdr, externc)
685 /* 1 = system header, 2 = system header to be treated as C. */
687 flags = 1 + (externc != 0);
688 _cpp_do_file_change (pfile, LC_RENAME, pfile->map->to_file,
689 SOURCE_LINE (pfile->map, pfile->line), flags);
692 /* Allow the client to change the current file. Used by the front end
693 to achieve pseudo-file names like <built-in>.
694 If REASON is LC_LEAVE, then NEW_NAME must be NULL. */
696 cpp_change_file (pfile, reason, new_name)
698 enum lc_reason reason;
699 const char *new_name;
701 _cpp_do_file_change (pfile, reason, new_name, 1, 0);
704 /* Report on all files that might benefit from a multiple include guard.
707 _cpp_report_missing_guards (pfile)
711 splay_tree_foreach (pfile->all_include_files, report_missing_guard, &banner);
714 /* Callback function for splay_tree_foreach(). */
716 report_missing_guard (n, b)
720 struct include_file *f = (struct include_file *) n->value;
721 int *bannerp = (int *) b;
723 if (f && f->cmacro == 0 && f->include_count == 1)
727 fputs (_("Multiple include guards may be useful for:\n"), stderr);
730 fputs (f->name, stderr);
736 /* Create a dependency for file FNAME, or issue an error message as
737 appropriate. ANGLE_BRACKETS is nonzero if the file was bracketed
740 handle_missing_header (pfile, fname, angle_brackets)
746 = CPP_OPTION (pfile, deps.style) > (angle_brackets || pfile->map->sysp);
748 if (CPP_OPTION (pfile, deps.missing_files) && print_dep)
749 deps_add_dep (pfile->deps, fname);
750 /* If -M was specified, then don't count this as an error, because
751 we can still produce correct output. Otherwise, we can't produce
752 correct output, because there may be dependencies we need inside
753 the missing file, and we don't know what directory this missing
756 cpp_errno (pfile, CPP_OPTION (pfile, deps.style) && ! print_dep
757 ? DL_WARNING: DL_ERROR, fname);
760 /* Handles #include-family directives (distinguished by TYPE),
761 including HEADER, and the command line -imacros and -include.
762 Returns true if a buffer was stacked. */
764 _cpp_execute_include (pfile, fname, angle_brackets, type)
768 enum include_type type;
770 bool stacked = false;
771 struct include_file *inc;
773 inc = find_include_file (pfile, fname, angle_brackets, type);
775 handle_missing_header (pfile, fname, angle_brackets);
776 else if (inc != NO_INCLUDE_PATH)
778 stacked = stack_include_file (pfile, inc);
780 if (type == IT_IMPORT)
781 _cpp_never_reread (inc);
787 /* Locate HEADER, and determine whether it is newer than the current
788 file. If it cannot be located or dated, return -1, if it is newer
789 newer, return 1, otherwise 0. */
791 _cpp_compare_file_date (pfile, fname, angle_brackets)
796 struct include_file *inc;
798 inc = find_include_file (pfile, fname, angle_brackets, IT_INCLUDE);
799 if (inc == NULL || inc == NO_INCLUDE_PATH)
808 return inc->st.st_mtime > pfile->buffer->inc->st.st_mtime;
812 /* Push an input buffer and load it up with the contents of FNAME. If
813 FNAME is "", read standard input. Return true if a buffer was
816 _cpp_read_file (pfile, fname)
820 /* This uses open_file, because we don't allow a PCH to be used as
821 the toplevel compilation (that would prevent re-compiling an
822 existing PCH without deleting it first). */
823 struct include_file *f = open_file (pfile, fname);
827 cpp_errno (pfile, DL_ERROR, fname);
831 return stack_include_file (pfile, f);
834 /* Pushes the given file onto the buffer stack. Returns nonzero if
837 cpp_push_include (pfile, filename)
839 const char *filename;
841 /* Make the command line directive take up a line. */
843 return _cpp_execute_include (pfile, filename, false, IT_CMDLINE);
846 /* Do appropriate cleanup when a file INC's buffer is popped off the
849 _cpp_pop_file_buffer (pfile, inc)
851 struct include_file *inc;
853 /* Record the inclusion-preventing macro, which could be NULL
854 meaning no controlling macro. */
855 if (pfile->mi_valid && inc->cmacro == NULL)
856 inc->cmacro = pfile->mi_cmacro;
858 /* Invalidate control macros in the #including file. */
859 pfile->mi_valid = false;
864 /* Returns the first place in the include chain to start searching for
865 "" includes. This involves stripping away the basename of the
866 current file, unless -I- was specified.
868 If we're handling -include or -imacros, use the "" chain, but with
869 the preprocessor's cwd prepended. */
870 static struct cpp_path *
871 search_from (pfile, type)
873 enum include_type type;
875 cpp_buffer *buffer = pfile->buffer;
878 /* Command line uses the cwd, and does not cache the result. */
879 if (type == IT_CMDLINE)
882 /* Ignore the current file's directory? */
883 if (pfile->quote_ignores_source_dir)
884 return pfile->quote_include;
886 if (! buffer->search_cached)
888 buffer->search_cached = 1;
890 dlen = lbasename (buffer->inc->name) - buffer->inc->name;
894 /* We don't guarantee NAME is null-terminated. This saves
895 allocating and freeing memory. Drop a trailing '/'. */
896 buffer->dir.name = (char *) buffer->inc->name;
903 buffer->dir.name = (char *) ".";
907 if (dlen > pfile->max_include_len)
908 pfile->max_include_len = dlen;
910 buffer->dir.len = dlen;
911 buffer->dir.next = pfile->quote_include;
912 buffer->dir.sysp = pfile->map->sysp;
918 /* The file_name_map structure holds a mapping of file names for a
919 particular directory. This mapping is read from the file named
920 FILE_NAME_MAP_FILE in that directory. Such a file can be used to
921 map filenames on a file system with severe filename restrictions,
922 such as DOS. The format of the file name map file is just a series
923 of lines with two tokens on each line. The first token is the name
924 to map, and the second token is the actual name to use. */
925 struct file_name_map {
926 struct file_name_map *map_next;
931 #define FILE_NAME_MAP_FILE "header.gcc"
933 /* Read a space delimited string of unlimited length from a stdio
936 read_filename_string (ch, f)
944 set = alloc = xmalloc (len + 1);
948 while ((ch = getc (f)) != EOF && ! is_space (ch))
950 if (set - alloc == len)
953 alloc = xrealloc (alloc, len + 1);
954 set = alloc + len / 2;
964 /* This structure holds a linked list of file name maps, one per directory. */
965 struct file_name_map_list {
966 struct file_name_map_list *map_list_next;
968 struct file_name_map *map_list_map;
971 /* Read the file name map file for DIRNAME. */
972 static struct file_name_map *
973 read_name_map (pfile, dirname)
977 struct file_name_map_list *map_list_ptr;
981 /* Check the cache of directories, and mappings in their remap file. */
982 for (map_list_ptr = CPP_OPTION (pfile, map_list); map_list_ptr;
983 map_list_ptr = map_list_ptr->map_list_next)
984 if (! strcmp (map_list_ptr->map_list_name, dirname))
985 return map_list_ptr->map_list_map;
987 map_list_ptr = ((struct file_name_map_list *)
988 xmalloc (sizeof (struct file_name_map_list)));
989 map_list_ptr->map_list_name = xstrdup (dirname);
991 /* The end of the list ends in NULL. */
992 map_list_ptr->map_list_map = NULL;
994 name = (char *) alloca (strlen (dirname) + strlen (FILE_NAME_MAP_FILE) + 2);
995 strcpy (name, dirname);
998 strcat (name, FILE_NAME_MAP_FILE);
999 f = fopen (name, "r");
1001 /* Silently return NULL if we cannot open. */
1006 while ((ch = getc (f)) != EOF)
1009 struct file_name_map *ptr;
1013 from = read_filename_string (ch, f);
1014 while ((ch = getc (f)) != EOF && is_hspace (ch))
1016 to = read_filename_string (ch, f);
1018 ptr = ((struct file_name_map *)
1019 xmalloc (sizeof (struct file_name_map)));
1020 ptr->map_from = from;
1022 /* Make the real filename absolute. */
1023 if (IS_ABSOLUTE_PATHNAME (to))
1027 ptr->map_to = concat (dirname, "/", to, NULL);
1031 ptr->map_next = map_list_ptr->map_list_map;
1032 map_list_ptr->map_list_map = ptr;
1034 while ((ch = getc (f)) != '\n')
1041 /* Add this information to the cache. */
1042 map_list_ptr->map_list_next = CPP_OPTION (pfile, map_list);
1043 CPP_OPTION (pfile, map_list) = map_list_ptr;
1045 return map_list_ptr->map_list_map;
1048 /* Remap an unsimplified path NAME based on the file_name_map (if any)
1051 remap_filename (pfile, name, loc)
1054 struct cpp_path *loc;
1056 struct file_name_map *map;
1057 const char *from, *p;
1060 if (! loc->name_map)
1062 /* Get a null-terminated path. */
1063 char *dname = alloca (loc->len + 1);
1064 memcpy (dname, loc->name, loc->len);
1065 dname[loc->len] = '\0';
1067 loc->name_map = read_name_map (pfile, dname);
1068 if (! loc->name_map)
1072 /* This works since NAME has not been simplified yet. */
1073 from = name + loc->len + 1;
1075 for (map = loc->name_map; map; map = map->map_next)
1076 if (!strcmp (map->map_from, from))
1079 /* Try to find a mapping file for the particular directory we are
1080 looking in. Thus #include <sys/types.h> will look up sys/types.h
1081 in /usr/include/header.gcc and look up types.h in
1082 /usr/include/sys/header.gcc. */
1083 p = strrchr (name, '/');
1087 /* We know p != name as absolute paths don't call remap_filename. */
1089 cpp_error (pfile, DL_ICE, "absolute file name in remap_filename");
1091 dir = (char *) alloca (p - name + 1);
1092 memcpy (dir, name, p - name);
1093 dir[p - name] = '\0';
1096 for (map = read_name_map (pfile, dir); map; map = map->map_next)
1097 if (! strcmp (map->map_from, from))
1103 /* Set the include chain for "" to QUOTE, for <> to BRACKET. If
1104 QUOTE_IGNORES_SOURCE_DIR, then "" includes do not look in the
1105 directory of the including file.
1107 If BRACKET does not lie in the QUOTE chain, it is set to QUOTE. */
1109 cpp_set_include_chains (pfile, quote, bracket, quote_ignores_source_dir)
1111 cpp_path *quote, *bracket;
1112 int quote_ignores_source_dir;
1114 pfile->quote_include = quote;
1115 pfile->bracket_include = quote;
1116 pfile->quote_ignores_source_dir = quote_ignores_source_dir;
1117 pfile->max_include_len = 0;
1119 for (; quote; quote = quote->next)
1121 quote->name_map = NULL;
1122 quote->len = strlen (quote->name);
1123 if (quote->len > pfile->max_include_len)
1124 pfile->max_include_len = quote->len;
1125 if (quote == bracket)
1126 pfile->bracket_include = bracket;
1130 /* Returns true if it is safe to remove the final component of path,
1131 when it is followed by a ".." component. We use lstat to avoid
1132 symlinks if we have it. If not, we can still catch errors with
1135 remove_component_p (path)
1142 result = lstat (path, &s);
1144 result = stat (path, &s);
1147 /* There's no guarantee that errno will be unchanged, even on
1148 success. Cygwin's lstat(), for example, will often set errno to
1149 ENOSYS. In case of success, reset errno to zero. */
1153 return result == 0 && S_ISDIR (s.st_mode);
1156 /* Simplify a path name in place, deleting redundant components. This
1157 reduces OS overhead and guarantees that equivalent paths compare
1158 the same (modulo symlinks).
1161 foo/bar/../quux foo/quux
1165 //quux //quux (POSIX allows leading // as a namespace escape)
1167 Guarantees no trailing slashes. All transforms reduce the length
1168 of the string. Returns PATH. errno is 0 if no error occurred;
1169 nonzero if an error occurred when using stat () or lstat (). */
1171 cpp_simplify_path (path)
1172 char *path ATTRIBUTE_UNUSED;
1176 char *base, *orig_base;
1180 /* Don't overflow the empty path by putting a '.' in it below. */
1184 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
1185 /* Convert all backslashes to slashes. */
1186 for (from = path; *from; from++)
1187 if (*from == '\\') *from = '/';
1189 /* Skip over leading drive letter if present. */
1190 if (ISALPHA (path[0]) && path[1] == ':')
1191 from = to = &path[2];
1198 /* Remove redundant leading /s. */
1207 /* 3 or more initial /s are equivalent to 1 /. */
1208 while (*++from == '/');
1210 /* On some hosts // differs from /; Posix allows this. */
1215 base = orig_base = to;
1220 while (*from == '/')
1228 if (from[1] == '\0')
1235 else if (from[1] == '.' && (from[2] == '/' || from[2] == '\0'))
1237 /* Don't simplify if there was no previous component. */
1238 if (absolute && orig_base == to)
1243 /* Don't simplify if the previous component was "../",
1244 or if an error has already occurred with (l)stat. */
1245 if (base != to && errno == 0)
1247 /* We don't back up if it's a symlink. */
1249 if (remove_component_p (path))
1251 while (to > base && *to != '/')
1261 /* Add the component separator. */
1265 /* Copy this component until the trailing null or '/'. */
1266 while (*from != '\0' && *from != '/')
1273 /* Change the empty string to "." so that it is not treated as stdin.