1 /* Part of CPP library. (include file handling)
2 Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1998,
3 1999, 2000 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 #ifndef INCLUDE_LEN_FUDGE
47 # define INCLUDE_LEN_FUDGE 0
50 /* If errno is inspected immediately after a system call fails, it will be
51 nonzero, and no error number will ever be zero. */
62 /* Suppress warning about function macros used w/o arguments in traditional
63 C. It is unlikely that glibc's strcmp macro helps this file at all. */
66 static struct file_name_map
*read_name_map
67 PARAMS ((cpp_reader
*, const char *));
68 static char *read_filename_string
PARAMS ((int, FILE *));
69 static char *remap_filename
PARAMS ((cpp_reader
*, char *,
70 struct file_name_list
*));
71 static struct file_name_list
*actual_directory
72 PARAMS ((cpp_reader
*, const char *));
73 static struct include_file
*find_include_file
74 PARAMS ((cpp_reader
*, const char *,
75 struct file_name_list
*));
76 static struct include_file
*open_file
PARAMS ((cpp_reader
*, const char *));
77 static int read_include_file
PARAMS ((cpp_reader
*, struct include_file
*));
78 static int stack_include_file
PARAMS ((cpp_reader
*, struct include_file
*));
79 static void purge_cache
PARAMS ((struct include_file
*));
80 static void destroy_include_file_node
PARAMS ((splay_tree_value
));
81 static int report_missing_guard
PARAMS ((splay_tree_node
, void *));
84 static void hack_vms_include_specification
PARAMS ((char *));
87 /* We use a splay tree to store information about all the include
88 files seen in this compilation. The key of each tree node is the
89 physical path to the file. The value is 0 if the file does not
90 exist, or a struct include_file pointer. */
93 destroy_include_file_node (v
)
96 struct include_file
*f
= (struct include_file
*)v
;
100 free (f
); /* The tree is registered with free to free f->name. */
105 _cpp_init_includes (pfile
)
108 pfile
->all_include_files
109 = splay_tree_new ((splay_tree_compare_fn
) strcmp
,
110 (splay_tree_delete_key_fn
) free
,
111 destroy_include_file_node
);
115 _cpp_cleanup_includes (pfile
)
118 splay_tree_delete (pfile
->all_include_files
);
121 /* Given a file name, look it up in the cache; if there is no entry,
122 create one with a non-NULL value (regardless of success in opening
123 the file). If the file doesn't exist or is inaccessible, this
124 entry is flagged so we don't attempt to open it again in the
125 future. If the file isn't open, open it.
127 Returns an include_file structure with an open file descriptor on
128 success, or NULL on failure. */
130 static struct include_file
*
131 open_file (pfile
, filename
)
133 const char *filename
;
136 struct include_file
*file
;
138 nd
= splay_tree_lookup (pfile
->all_include_files
, (splay_tree_key
) filename
);
142 file
= (struct include_file
*) nd
->value
;
144 /* Don't retry opening if we failed previously. */
148 /* Don't reopen an idempotent file. */
149 if (DO_NOT_REREAD (file
))
152 /* Don't reopen one which is already loaded. */
153 if (file
->buffer
!= NULL
)
158 file
= xcnew (struct include_file
);
159 file
->name
= xstrdup (filename
);
160 splay_tree_insert (pfile
->all_include_files
,
161 (splay_tree_key
) file
->name
,
162 (splay_tree_value
) file
);
165 /* We used to open files in nonblocking mode, but that caused more
166 problems than it solved. Do take care not to acquire a
167 controlling terminal by mistake (this can't happen on sane
168 systems, but paranoia is a virtue).
170 Use the three-argument form of open even though we aren't
171 specifying O_CREAT, to defend against broken system headers.
173 O_BINARY tells some runtime libraries (notably DJGPP) not to do
174 newline translation; we can handle DOS line breaks just fine
177 Special case: the empty string is translated to stdin. */
179 if (filename
[0] == '\0')
182 file
->fd
= open (filename
, O_RDONLY
| O_NOCTTY
| O_BINARY
, 0666);
184 if (file
->fd
!= -1 && fstat (file
->fd
, &file
->st
) == 0)
186 /* Mark a regular, zero-length file never-reread now. */
187 if (S_ISREG (file
->st
.st_mode
) && file
->st
.st_size
== 0)
189 file
->cmacro
= NEVER_REREAD
;
197 /* Don't issue an error message if the file doesn't exist. */
198 if (errno
!= ENOENT
&& errno
!= ENOTDIR
)
199 cpp_error_from_errno (pfile
, filename
);
201 /* Create a negative node for this path, and return null. */
207 /* Place the file referenced by INC into a new buffer on PFILE's stack.
208 Return 1 if successful, 0 if not. */
211 stack_include_file (pfile
, inc
)
213 struct include_file
*inc
;
217 if (pfile
->context
->prev
)
218 cpp_ice (pfile
, "attempt to push file buffer with contexts stacked");
220 if (DO_NOT_REREAD (inc
))
223 if (inc
->buffer
== NULL
)
224 if (read_include_file (pfile
, inc
) == 0)
227 fp
= cpp_push_buffer (pfile
, NULL
, 0);
231 /* Initialise controlling macro state. */
232 pfile
->mi_state
= MI_OUTSIDE
;
233 pfile
->mi_cmacro
= 0;
236 fp
->nominal_fname
= inc
->name
;
237 fp
->buf
= inc
->buffer
;
238 fp
->rlimit
= fp
->buf
+ inc
->st
.st_size
;
241 fp
->line_base
= fp
->buf
;
243 /* The ->actual_dir field is only used when ignore_srcdir is not in effect;
245 if (!CPP_OPTION (pfile
, ignore_srcdir
))
246 fp
->actual_dir
= actual_directory (pfile
, inc
->name
);
249 pfile
->include_depth
++;
250 pfile
->input_stack_listing_current
= 0;
252 if (pfile
->cb
.enter_file
)
253 (*pfile
->cb
.enter_file
) (pfile
);
258 /* Read the file referenced by INC into the file cache.
260 If fd points to a plain file, we might be able to mmap it; we can
261 definitely allocate the buffer all at once. If fd is a pipe or
262 terminal, we can't do either. If fd is something weird, like a
263 block device or a directory, we don't want to read it at all.
265 Unfortunately, different systems use different st.st_mode values
266 for pipes: some have S_ISFIFO, some S_ISSOCK, some are buggy and
267 zero the entire struct stat except a couple fields. Hence we don't
268 even try to figure out what something is, except for plain files,
269 directories, and block devices.
271 FIXME: Flush file cache and try again if we run out of memory. */
274 read_include_file (pfile
, inc
)
276 struct include_file
*inc
;
278 ssize_t size
, offset
, count
;
281 static int pagesize
= -1;
284 if (S_ISREG (inc
->st
.st_mode
))
286 /* off_t might have a wider range than ssize_t - in other words,
287 the max size of a file might be bigger than the address
288 space. We can't handle a file that large. (Anyone with
289 a single source file bigger than 2GB needs to rethink
290 their coding style.) Some systems (e.g. AIX 4.1) define
291 SSIZE_MAX to be much smaller than the actual range of the
292 type. Use INTTYPE_MAXIMUM unconditionally to ensure this
294 if (inc
->st
.st_size
> INTTYPE_MAXIMUM (ssize_t
))
296 cpp_error (pfile
, "%s is too large", inc
->name
);
299 size
= inc
->st
.st_size
;
304 pagesize
= getpagesize ();
306 if (size
/ pagesize
>= MMAP_THRESHOLD
)
308 buf
= (U_CHAR
*) mmap (0, size
, PROT_READ
, MAP_PRIVATE
, inc
->fd
, 0);
309 if (buf
== (U_CHAR
*)-1)
316 buf
= (U_CHAR
*) xmalloc (size
);
318 while (offset
< size
)
320 count
= read (inc
->fd
, buf
+ offset
, size
- offset
);
325 cpp_warning (pfile
, "%s is shorter than expected", inc
->name
);
332 else if (S_ISBLK (inc
->st
.st_mode
))
334 cpp_error (pfile
, "%s is a block device", inc
->name
);
337 else if (S_ISDIR (inc
->st
.st_mode
))
339 cpp_error (pfile
, "%s is a directory", inc
->name
);
344 /* 8 kilobytes is a sensible starting size. It ought to be
345 bigger than the kernel pipe buffer, and it's definitely
346 bigger than the majority of C source files. */
349 buf
= (U_CHAR
*) xmalloc (size
);
351 while ((count
= read (inc
->fd
, buf
+ offset
, size
- offset
)) > 0)
355 buf
= xrealloc (buf
, (size
*= 2));
361 buf
= xrealloc (buf
, offset
);
362 inc
->st
.st_size
= offset
;
371 cpp_error_from_errno (pfile
, inc
->name
);
373 /* Do not try to read this file again. */
376 inc
->cmacro
= NEVER_REREAD
;
382 struct include_file
*inc
;
388 munmap ((PTR
) inc
->buffer
, inc
->st
.st_size
);
391 free ((PTR
) inc
->buffer
);
396 /* Return 1 if the file named by FNAME has been included before in
397 any context, 0 otherwise. */
399 cpp_included (pfile
, fname
)
403 struct file_name_list
*path
;
409 /* Just look it up. */
410 nd
= splay_tree_lookup (pfile
->all_include_files
, (splay_tree_key
) fname
);
411 return (nd
&& nd
->value
);
414 /* Search directory path for the file. */
415 name
= (char *) alloca (strlen (fname
) + pfile
->max_include_len
416 + 2 + INCLUDE_LEN_FUDGE
);
417 for (path
= CPP_OPTION (pfile
, quote_include
); path
; path
= path
->next
)
419 memcpy (name
, path
->name
, path
->nlen
);
420 name
[path
->nlen
] = '/';
421 strcpy (&name
[path
->nlen
+1], fname
);
422 _cpp_simplify_pathname (name
);
423 if (CPP_OPTION (pfile
, remap
))
424 name
= remap_filename (pfile
, name
, path
);
426 nd
= splay_tree_lookup (pfile
->all_include_files
, (splay_tree_key
) name
);
433 /* Search for include file FNAME in the include chain starting at
434 SEARCH_START. Return 0 if there is no such file (or it's un-openable),
435 otherwise an include_file structure. */
437 static struct include_file
*
438 find_include_file (pfile
, fname
, search_start
)
441 struct file_name_list
*search_start
;
443 struct file_name_list
*path
;
445 struct include_file
*file
;
448 return open_file (pfile
, fname
);
450 /* Search directory path for the file. */
451 name
= (char *) alloca (strlen (fname
) + pfile
->max_include_len
452 + 2 + INCLUDE_LEN_FUDGE
);
453 for (path
= search_start
; path
; path
= path
->next
)
455 memcpy (name
, path
->name
, path
->nlen
);
456 name
[path
->nlen
] = '/';
457 strcpy (&name
[path
->nlen
+1], fname
);
458 _cpp_simplify_pathname (name
);
459 if (CPP_OPTION (pfile
, remap
))
460 name
= remap_filename (pfile
, name
, path
);
462 file
= open_file (pfile
, name
);
465 file
->sysp
= path
->sysp
;
466 file
->foundhere
= path
;
473 /* #line uses this to save artificial file names. We have to stat the
474 file because an all_include_files entry is always either + or -,
475 there's no 'I don't know' value. */
477 _cpp_fake_include (pfile
, fname
)
482 struct include_file
*file
;
485 file
= find_include_file (pfile
, fname
, CPP_OPTION (pfile
, quote_include
));
496 name
= xstrdup (fname
);
497 _cpp_simplify_pathname (name
);
499 /* We cannot just blindly insert a node, because there's still the
500 chance that the node already exists but isn't on the search path. */
501 nd
= splay_tree_lookup (pfile
->all_include_files
, (splay_tree_key
) name
);
505 return (const char *) nd
->key
;
508 file
= xcnew (struct include_file
);
511 splay_tree_insert (pfile
->all_include_files
, (splay_tree_key
) name
,
512 (splay_tree_value
) file
);
517 /* Not everyone who wants to set system-header-ness on a buffer can
518 see the details of struct include_file. This is an exported interface
519 because fix-header needs it. */
521 cpp_make_system_header (pfile
, pbuf
, flag
)
526 if (flag
< 0 || flag
> 2)
527 cpp_ice (pfile
, "cpp_make_system_header: bad flag %d\n", flag
);
529 cpp_ice (pfile
, "cpp_make_system_header called on non-file buffer");
531 pbuf
->inc
->sysp
= flag
;
535 cpp_syshdr_flags (pfile
, pbuf
)
536 cpp_reader
*pfile ATTRIBUTE_UNUSED
;
539 #ifndef NO_IMPLICIT_EXTERN_C
540 if (CPP_OPTION (pfile
, cplusplus
) && pbuf
->inc
->sysp
== 2)
548 /* Report on all files that might benefit from a multiple include guard.
551 _cpp_report_missing_guards (pfile
)
555 splay_tree_foreach (pfile
->all_include_files
, report_missing_guard
,
560 report_missing_guard (n
, b
)
564 struct include_file
*f
= (struct include_file
*) n
->value
;
565 int *bannerp
= (int *)b
;
567 if (f
&& f
->cmacro
== 0 && f
->include_count
== 1)
571 fputs (_("Multiple include guards may be useful for:\n"), stderr
);
574 fputs (f
->name
, stderr
);
580 #define PRINT_THIS_DEP(p, b) (CPP_PRINT_DEPS(p) > (b||p->system_include_depth))
582 _cpp_execute_include (pfile
, header
, no_reinclude
, search_start
)
584 const cpp_token
*header
;
586 struct file_name_list
*search_start
;
588 unsigned int len
= header
->val
.str
.len
;
589 unsigned int angle_brackets
= header
->type
== CPP_HEADER_NAME
;
590 struct include_file
*inc
;
593 fname
= alloca (len
+ 1);
594 memcpy (fname
, header
->val
.str
.text
, len
);
600 search_start
= CPP_OPTION (pfile
, bracket_include
);
601 else if (CPP_OPTION (pfile
, ignore_srcdir
))
602 search_start
= CPP_OPTION (pfile
, quote_include
);
604 search_start
= CPP_BUFFER (pfile
)->actual_dir
;
608 cpp_error (pfile
, "No include path in which to find %s", fname
);
613 inc
= find_include_file (pfile
, fname
, search_start
);
617 /* For -M, add the file to the dependencies on its first inclusion. */
618 if (!inc
->include_count
&& PRINT_THIS_DEP (pfile
, angle_brackets
))
619 deps_add_dep (pfile
->deps
, inc
->name
);
620 inc
->include_count
++;
622 /* Actually process the file. */
623 if (stack_include_file (pfile
, inc
))
626 pfile
->system_include_depth
++;
629 inc
->cmacro
= NEVER_REREAD
;
631 /* Handle -H option. */
632 if (CPP_OPTION (pfile
, print_include_names
))
634 cpp_buffer
*fp
= CPP_BUFFER (pfile
);
635 while ((fp
= CPP_PREV_BUFFER (fp
)) != NULL
)
637 fprintf (stderr
, " %s\n", inc
->name
);
643 if (CPP_OPTION (pfile
, print_deps_missing_files
)
644 && PRINT_THIS_DEP (pfile
, angle_brackets
))
647 deps_add_dep (pfile
->deps
, fname
);
651 struct file_name_list
*ptr
;
652 /* If requested as a system header, assume it belongs in
653 the first system header directory. */
654 if (CPP_OPTION (pfile
, bracket_include
))
655 ptr
= CPP_OPTION (pfile
, bracket_include
);
657 ptr
= CPP_OPTION (pfile
, quote_include
);
659 p
= (char *) alloca (strlen (ptr
->name
)
660 + strlen (fname
) + 2);
661 if (*ptr
->name
!= '\0')
663 strcpy (p
, ptr
->name
);
667 _cpp_simplify_pathname (p
);
668 deps_add_dep (pfile
->deps
, p
);
671 /* If -M was specified, and this header file won't be added to
672 the dependency list, then don't count this as an error,
673 because we can still produce correct output. Otherwise, we
674 can't produce correct output, because there may be
675 dependencies we need inside the missing file, and we don't
676 know what directory this missing file exists in. */
677 else if (CPP_PRINT_DEPS (pfile
)
678 && ! PRINT_THIS_DEP (pfile
, angle_brackets
))
679 cpp_warning (pfile
, "No include path in which to find %s", fname
);
681 cpp_error_from_errno (pfile
, fname
);
684 /* Locate file F, and determine whether it is newer than PFILE. Return -1,
685 if F cannot be located or dated, 1, if it is newer and 0 if older. */
687 _cpp_compare_file_date (pfile
, f
)
691 unsigned int len
= f
->val
.str
.len
;
693 struct file_name_list
*search_start
;
694 struct include_file
*inc
;
696 if (f
->type
== CPP_HEADER_NAME
)
697 search_start
= CPP_OPTION (pfile
, bracket_include
);
698 else if (CPP_OPTION (pfile
, ignore_srcdir
))
699 search_start
= CPP_OPTION (pfile
, quote_include
);
701 search_start
= CPP_BUFFER (pfile
)->actual_dir
;
703 fname
= alloca (len
+ 1);
704 memcpy (fname
, f
->val
.str
.text
, len
);
706 inc
= find_include_file (pfile
, fname
, search_start
);
716 return inc
->st
.st_mtime
> CPP_BUFFER (pfile
)->inc
->st
.st_mtime
;
720 /* Push an input buffer and load it up with the contents of FNAME.
721 If FNAME is "" or NULL, read standard input. */
723 cpp_read_file (pfile
, fname
)
727 struct include_file
*f
;
732 f
= open_file (pfile
, fname
);
736 cpp_error_from_errno (pfile
, fname
);
740 /* Return success for zero-length files. */
741 if (DO_NOT_REREAD (f
))
744 return stack_include_file (pfile
, f
);
747 /* Do appropriate cleanup when a file buffer is popped off the input
750 _cpp_pop_file_buffer (pfile
, buf
)
754 struct include_file
*inc
= buf
->inc
;
756 if (pfile
->system_include_depth
)
757 pfile
->system_include_depth
--;
758 if (pfile
->include_depth
)
759 pfile
->include_depth
--;
760 pfile
->input_stack_listing_current
= 0;
762 /* Record the inclusion-preventing macro and its definedness. */
763 if (pfile
->mi_state
== MI_OUTSIDE
&& inc
->cmacro
!= NEVER_REREAD
)
765 /* This could be NULL meaning no controlling macro. */
766 inc
->cmacro
= pfile
->mi_cmacro
;
770 /* Invalidate control macros in the #including file. */
771 pfile
->mi_state
= MI_FAILED
;
774 if (inc
->refcnt
== 0 && DO_NOT_REREAD (inc
))
778 /* The file_name_map structure holds a mapping of file names for a
779 particular directory. This mapping is read from the file named
780 FILE_NAME_MAP_FILE in that directory. Such a file can be used to
781 map filenames on a file system with severe filename restrictions,
782 such as DOS. The format of the file name map file is just a series
783 of lines with two tokens on each line. The first token is the name
784 to map, and the second token is the actual name to use. */
788 struct file_name_map
*map_next
;
793 #define FILE_NAME_MAP_FILE "header.gcc"
795 /* Read a space delimited string of unlimited length from a stdio
799 read_filename_string (ch
, f
)
807 set
= alloc
= xmalloc (len
+ 1);
811 while ((ch
= getc (f
)) != EOF
&& ! is_space(ch
))
813 if (set
- alloc
== len
)
816 alloc
= xrealloc (alloc
, len
+ 1);
817 set
= alloc
+ len
/ 2;
827 /* This structure holds a linked list of file name maps, one per directory. */
829 struct file_name_map_list
831 struct file_name_map_list
*map_list_next
;
833 struct file_name_map
*map_list_map
;
836 /* Read the file name map file for DIRNAME. */
838 static struct file_name_map
*
839 read_name_map (pfile
, dirname
)
843 register struct file_name_map_list
*map_list_ptr
;
847 for (map_list_ptr
= CPP_OPTION (pfile
, map_list
); map_list_ptr
;
848 map_list_ptr
= map_list_ptr
->map_list_next
)
849 if (! strcmp (map_list_ptr
->map_list_name
, dirname
))
850 return map_list_ptr
->map_list_map
;
852 map_list_ptr
= ((struct file_name_map_list
*)
853 xmalloc (sizeof (struct file_name_map_list
)));
854 map_list_ptr
->map_list_name
= xstrdup (dirname
);
855 map_list_ptr
->map_list_map
= NULL
;
857 name
= (char *) alloca (strlen (dirname
) + strlen (FILE_NAME_MAP_FILE
) + 2);
858 strcpy (name
, dirname
);
861 strcat (name
, FILE_NAME_MAP_FILE
);
862 f
= fopen (name
, "r");
864 map_list_ptr
->map_list_map
= (struct file_name_map
*)-1;
868 int dirlen
= strlen (dirname
);
870 while ((ch
= getc (f
)) != EOF
)
873 struct file_name_map
*ptr
;
877 from
= read_filename_string (ch
, f
);
878 while ((ch
= getc (f
)) != EOF
&& is_hspace(ch
))
880 to
= read_filename_string (ch
, f
);
882 ptr
= ((struct file_name_map
*)
883 xmalloc (sizeof (struct file_name_map
)));
884 ptr
->map_from
= from
;
886 /* Make the real filename absolute. */
891 ptr
->map_to
= xmalloc (dirlen
+ strlen (to
) + 2);
892 strcpy (ptr
->map_to
, dirname
);
893 ptr
->map_to
[dirlen
] = '/';
894 strcpy (ptr
->map_to
+ dirlen
+ 1, to
);
898 ptr
->map_next
= map_list_ptr
->map_list_map
;
899 map_list_ptr
->map_list_map
= ptr
;
901 while ((ch
= getc (f
)) != '\n')
908 map_list_ptr
->map_list_next
= CPP_OPTION (pfile
, map_list
);
909 CPP_OPTION (pfile
, map_list
) = map_list_ptr
;
911 return map_list_ptr
->map_list_map
;
914 /* Remap NAME based on the file_name_map (if any) for LOC. */
917 remap_filename (pfile
, name
, loc
)
920 struct file_name_list
*loc
;
922 struct file_name_map
*map
;
923 const char *from
, *p
, *dir
;
926 loc
->name_map
= read_name_map (pfile
,
930 if (loc
->name_map
== (struct file_name_map
*)-1)
933 from
= name
+ strlen (loc
->name
) + 1;
935 for (map
= loc
->name_map
; map
; map
= map
->map_next
)
936 if (!strcmp (map
->map_from
, from
))
939 /* Try to find a mapping file for the particular directory we are
940 looking in. Thus #include <sys/types.h> will look up sys/types.h
941 in /usr/include/header.gcc and look up types.h in
942 /usr/include/sys/header.gcc. */
943 p
= strrchr (name
, '/');
947 && strlen (loc
->name
) == (size_t) (p
- name
)
948 && !strncmp (loc
->name
, name
, p
- name
))
949 /* FILENAME is in SEARCHPTR, which we've already checked. */
959 char * newdir
= (char *) alloca (p
- name
+ 1);
960 memcpy (newdir
, name
, p
- name
);
961 newdir
[p
- name
] = '\0';
966 for (map
= read_name_map (pfile
, dir
); map
; map
= map
->map_next
)
967 if (! strcmp (map
->map_from
, name
))
973 /* Given a path FNAME, extract the directory component and place it
974 onto the actual_dirs list. Return a pointer to the allocated
975 file_name_list structure. These structures are used to implement
976 current-directory "" include searching. */
978 static struct file_name_list
*
979 actual_directory (pfile
, fname
)
983 char *last_slash
, *dir
;
985 struct file_name_list
*x
;
987 dir
= xstrdup (fname
);
988 last_slash
= strrchr (dir
, '/');
991 if (last_slash
== dir
)
994 last_slash
[1] = '\0';
998 dlen
= last_slash
- dir
;
1005 dir
= xstrdup (".");
1009 if (dlen
> pfile
->max_include_len
)
1010 pfile
->max_include_len
= dlen
;
1012 for (x
= pfile
->actual_dirs
; x
; x
= x
->alloc
)
1013 if (!strcmp (x
->name
, dir
))
1019 /* Not found, make a new one. */
1020 x
= (struct file_name_list
*) xmalloc (sizeof (struct file_name_list
));
1023 x
->next
= CPP_OPTION (pfile
, quote_include
);
1024 x
->alloc
= pfile
->actual_dirs
;
1025 x
->sysp
= CPP_BUFFER (pfile
)->inc
->sysp
;
1028 pfile
->actual_dirs
= x
;
1032 /* Simplify a path name in place, deleting redundant components. This
1033 reduces OS overhead and guarantees that equivalent paths compare
1034 the same (modulo symlinks).
1037 foo/bar/../quux foo/quux
1041 //quux //quux (POSIX allows leading // as a namespace escape)
1043 Guarantees no trailing slashes. All transforms reduce the length
1047 _cpp_simplify_pathname (path
)
1054 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
1055 /* Convert all backslashes to slashes. */
1056 for (from
= path
; *from
; from
++)
1057 if (*from
== '\\') *from
= '/';
1059 /* Skip over leading drive letter if present. */
1060 if (ISALPHA (path
[0]) && path
[1] == ':')
1061 from
= to
= &path
[2];
1068 /* Remove redundant initial /s. */
1077 /* 3 or more initial /s are equivalent to 1 /. */
1078 while (*++from
== '/');
1080 /* On some hosts // differs from /; Posix allows this. */
1088 while (*from
== '/')
1091 if (from
[0] == '.' && from
[1] == '/')
1093 else if (from
[0] == '.' && from
[1] == '\0')
1095 else if (from
[0] == '.' && from
[1] == '.' && from
[2] == '/')
1112 while (to
> base
&& *to
!= '/') to
--;
1118 else if (from
[0] == '.' && from
[1] == '.' && from
[2] == '\0')
1131 while (to
> base
&& *to
!= '/') to
--;
1138 /* Copy this component and trailing /, if any. */
1139 while ((*to
++ = *from
++) != '/')
1151 /* Trim trailing slash */
1152 if (to
[0] == '/' && (!absolute
|| to
> path
+1))
1155 /* Change the empty string to "." so that stat() on the result
1156 will always work. */
1165 /* It is not clear when this should be used if at all, so I've
1166 disabled it until someone who understands VMS can look at it. */
1169 /* Under VMS we need to fix up the "include" specification filename.
1171 Rules for possible conversions
1173 fullname tried paths
1176 ./dir/name [.dir]name
1178 /name [000000]name, name
1179 dir/name dir:[000000]name, dir:name, dir/name
1180 dir1/dir2/name dir1:[dir2]name, dir1:[000000.dir2]name
1181 path:/name path:[000000]name, path:name
1182 path:/dir/name path:[000000.dir]name, path:[dir]name
1183 path:dir/name path:[dir]name
1184 [path]:[dir]name [path.dir]name
1185 path/[dir]name [path.dir]name
1187 The path:/name input is constructed when expanding <> includes. */
1191 hack_vms_include_specification (fullname
)
1194 register char *basename
, *unixname
, *local_ptr
, *first_slash
;
1195 int f
, check_filename_before_returning
, must_revert
;
1198 check_filename_before_returning
= 0;
1200 /* See if we can find a 1st slash. If not, there's no path information. */
1201 first_slash
= strchr (fullname
, '/');
1202 if (first_slash
== 0)
1203 return 0; /* Nothing to do!!! */
1205 /* construct device spec if none given. */
1207 if (strchr (fullname
, ':') == 0)
1210 /* If fullname has a slash, take it as device spec. */
1212 if (first_slash
== fullname
)
1214 first_slash
= strchr (fullname
+ 1, '/'); /* 2nd slash ? */
1216 *first_slash
= ':'; /* make device spec */
1217 for (basename
= fullname
; *basename
!= 0; basename
++)
1218 *basename
= *(basename
+1); /* remove leading slash */
1220 else if ((first_slash
[-1] != '.') /* keep ':/', './' */
1221 && (first_slash
[-1] != ':')
1222 && (first_slash
[-1] != ']')) /* or a vms path */
1226 else if ((first_slash
[1] == '[') /* skip './' in './[dir' */
1227 && (first_slash
[-1] == '.'))
1231 /* Get part after first ':' (basename[-1] == ':')
1232 or last '/' (basename[-1] == '/'). */
1234 basename
= base_name (fullname
);
1236 local_ptr
= Local
; /* initialize */
1238 /* We are trying to do a number of things here. First of all, we are
1239 trying to hammer the filenames into a standard format, such that later
1240 processing can handle them.
1242 If the file name contains something like [dir.], then it recognizes this
1243 as a root, and strips the ".]". Later processing will add whatever is
1244 needed to get things working properly.
1246 If no device is specified, then the first directory name is taken to be
1247 a device name (or a rooted logical). */
1249 /* Point to the UNIX filename part (which needs to be fixed!)
1250 but skip vms path information.
1251 [basename != fullname since first_slash != 0]. */
1253 if ((basename
[-1] == ':') /* vms path spec. */
1254 || (basename
[-1] == ']')
1255 || (basename
[-1] == '>'))
1256 unixname
= basename
;
1258 unixname
= fullname
;
1260 if (*unixname
== '/')
1263 /* If the directory spec is not rooted, we can just copy
1264 the UNIX filename part and we are done. */
1266 if (((basename
- fullname
) > 1)
1267 && ( (basename
[-1] == ']')
1268 || (basename
[-1] == '>')))
1270 if (basename
[-2] != '.')
1273 /* The VMS part ends in a `]', and the preceding character is not a `.'.
1274 -> PATH]:/name (basename = '/name', unixname = 'name')
1275 We strip the `]', and then splice the two parts of the name in the
1276 usual way. Given the default locations for include files,
1277 we will only use this code if the user specifies alternate locations
1278 with the /include (-I) switch on the command line. */
1280 basename
-= 1; /* Strip "]" */
1281 unixname
--; /* backspace */
1286 /* The VMS part has a ".]" at the end, and this will not do. Later
1287 processing will add a second directory spec, and this would be a syntax
1288 error. Thus we strip the ".]", and thus merge the directory specs.
1289 We also backspace unixname, so that it points to a '/'. This inhibits the
1290 generation of the 000000 root directory spec (which does not belong here
1293 basename
-= 2; /* Strip ".]" */
1294 unixname
--; /* backspace */
1302 /* We drop in here if there is no VMS style directory specification yet.
1303 If there is no device specification either, we make the first dir a
1304 device and try that. If we do not do this, then we will be essentially
1305 searching the users default directory (as if they did a #include "asdf.h").
1307 Then all we need to do is to push a '[' into the output string. Later
1308 processing will fill this in, and close the bracket. */
1310 if ((unixname
!= fullname
) /* vms path spec found. */
1311 && (basename
[-1] != ':'))
1312 *local_ptr
++ = ':'; /* dev not in spec. take first dir */
1314 *local_ptr
++ = '['; /* Open the directory specification */
1317 if (unixname
== fullname
) /* no vms dir spec. */
1320 if ((first_slash
!= 0) /* unix dir spec. */
1321 && (*unixname
!= '/') /* not beginning with '/' */
1322 && (*unixname
!= '.')) /* or './' or '../' */
1323 *local_ptr
++ = '.'; /* dir is local ! */
1326 /* at this point we assume that we have the device spec, and (at least
1327 the opening "[" for a directory specification. We may have directories
1330 If there are no other slashes then the filename will be
1331 in the "root" directory. Otherwise, we need to add
1332 directory specifications. */
1334 if (strchr (unixname
, '/') == 0)
1336 /* if no directories specified yet and none are following. */
1337 if (local_ptr
[-1] == '[')
1339 /* Just add "000000]" as the directory string */
1340 strcpy (local_ptr
, "000000]");
1341 local_ptr
+= strlen (local_ptr
);
1342 check_filename_before_returning
= 1; /* we might need to fool with this later */
1348 /* As long as there are still subdirectories to add, do them. */
1349 while (strchr (unixname
, '/') != 0)
1351 /* If this token is "." we can ignore it
1352 if it's not at the beginning of a path. */
1353 if ((unixname
[0] == '.') && (unixname
[1] == '/'))
1355 /* remove it at beginning of path. */
1356 if ( ((unixname
== fullname
) /* no device spec */
1357 && (fullname
+2 != basename
)) /* starts with ./ */
1359 || ((basename
[-1] == ':') /* device spec */
1360 && (unixname
-1 == basename
))) /* and ./ afterwards */
1361 *local_ptr
++ = '.'; /* make '[.' start of path. */
1366 /* Add a subdirectory spec. Do not duplicate "." */
1367 if ( local_ptr
[-1] != '.'
1368 && local_ptr
[-1] != '['
1369 && local_ptr
[-1] != '<')
1372 /* If this is ".." then the spec becomes "-" */
1373 if ( (unixname
[0] == '.')
1374 && (unixname
[1] == '.')
1375 && (unixname
[2] == '/'))
1377 /* Add "-" and skip the ".." */
1378 if ((local_ptr
[-1] == '.')
1379 && (local_ptr
[-2] == '['))
1380 local_ptr
--; /* prevent [.- */
1386 /* Copy the subdirectory */
1387 while (*unixname
!= '/')
1388 *local_ptr
++= *unixname
++;
1390 unixname
++; /* Skip the "/" */
1393 /* Close the directory specification */
1394 if (local_ptr
[-1] == '.') /* no trailing periods */
1397 if (local_ptr
[-1] == '[') /* no dir needed */
1403 /* Now add the filename. */
1406 *local_ptr
++ = *unixname
++;
1409 /* Now append it to the original VMS spec. */
1411 strcpy ((must_revert
==1)?fullname
:basename
, Local
);
1413 /* If we put a [000000] in the filename, try to open it first. If this fails,
1414 remove the [000000], and return that name. This provides flexibility
1415 to the user in that they can use both rooted and non-rooted logical names
1416 to point to the location of the file. */
1418 if (check_filename_before_returning
)
1420 f
= open (fullname
, O_RDONLY
|O_NONBLOCK
);
1423 /* The file name is OK as it is, so return it as is. */
1428 /* The filename did not work. Try to remove the [000000] from the name,
1431 basename
= strchr (fullname
, '[');
1432 local_ptr
= strchr (fullname
, ']') + 1;
1433 strcpy (basename
, local_ptr
); /* this gets rid of it */