1 /* Part of CPP library. (include file handling)
2 Copyright (C) 1986, 87, 89, 92 - 95, 98, 1999 Free Software Foundation, Inc.
3 Written by Per Bothner, 1994.
4 Based on CCCP program by Paul Rubin, June 1986
5 Adapted to ANSI C, Richard Stallman, Jan 1987
6 Split out of cpplib.c, Zack Weinberg, Oct 1998
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 In other words, you are welcome to use, share and improve this program.
23 You are forbidden to forbid anyone else to use, share and improve
24 what you give them. Help stamp out software-hoarding! */
30 /* The entry points to this file are: find_include_file, finclude,
31 include_hash, append_include_chain, deps_output, and file_cleanup.
32 file_cleanup is only called through CPP_BUFFER(pfile)->cleanup,
33 so it's static anyway. */
35 static struct include_hash
*redundant_include_p
37 struct include_hash
*,
38 struct file_name_list
*));
39 static struct file_name_map
*read_name_map
PROTO ((cpp_reader
*,
41 static char *read_filename_string
PROTO ((int, FILE *));
42 static char *remap_filename
PROTO ((cpp_reader
*, char *,
43 struct file_name_list
*));
44 static long read_and_prescan
PROTO ((cpp_reader
*, cpp_buffer
*,
46 static struct file_name_list
*actual_directory
PROTO ((cpp_reader
*, char *));
49 static void hack_vms_include_specification
PROTO ((char *));
52 /* Windows does not natively support inodes, and neither does MSDOS.
53 VMS has non-numeric inodes. */
55 #define INO_T_EQ(a, b) (!bcmp((char *) &(a), (char *) &(b), sizeof (a)))
56 #elif (defined _WIN32 && !defined CYGWIN && ! defined (_UWIN)) \
58 #define INO_T_EQ(a, b) 0
60 #define INO_T_EQ(a, b) ((a) == (b))
63 /* Merge the four include chains together in the order quote, bracket,
64 system, after. Remove duplicate dirs (as determined by
65 INO_T_EQ()). The system_include and after_include chains are never
66 referred to again after this function; all access is through the
69 For the future: Check if the directory is empty (but
70 how?) and possibly preload the include hash. */
73 merge_include_chains (opts
)
74 struct cpp_options
*opts
;
76 struct file_name_list
*prev
, *cur
, *other
;
77 struct file_name_list
*quote
, *brack
, *systm
, *after
;
78 struct file_name_list
*qtail
, *btail
, *stail
, *atail
;
80 qtail
= opts
->pending
->quote_tail
;
81 btail
= opts
->pending
->brack_tail
;
82 stail
= opts
->pending
->systm_tail
;
83 atail
= opts
->pending
->after_tail
;
85 quote
= opts
->pending
->quote_head
;
86 brack
= opts
->pending
->brack_head
;
87 systm
= opts
->pending
->systm_head
;
88 after
= opts
->pending
->after_head
;
90 /* Paste together bracket, system, and after include chains. */
100 /* This is a bit tricky.
101 First we drop dupes from the quote-include list.
102 Then we drop dupes from the bracket-include list.
103 Finally, if qtail and brack are the same directory,
106 We can't just merge the lists and then uniquify them because
107 then we may lose directories from the <> search path that should
108 be there; consider -Ifoo -Ibar -I- -Ifoo -Iquux. It is however
109 safe to treat -Ibar -Ifoo -I- -Ifoo -Iquux as if written
110 -Ibar -I- -Ifoo -Iquux.
112 Note that this algorithm is quadratic in the number of -I switches,
113 which is acceptable since there aren't usually that many of them. */
115 for (cur
= quote
; cur
; cur
= cur
->next
)
117 for (other
= quote
; other
!= cur
; other
= other
->next
)
118 if (INO_T_EQ (cur
->ino
, other
->ino
)
119 && cur
->dev
== other
->dev
)
122 cpp_notice ("ignoring duplicate directory `%s'\n", cur
->name
);
124 prev
->next
= cur
->next
;
134 for (cur
= brack
; cur
; cur
= cur
->next
)
136 for (other
= brack
; other
!= cur
; other
= other
->next
)
137 if (INO_T_EQ (cur
->ino
, other
->ino
)
138 && cur
->dev
== other
->dev
)
141 cpp_notice ("ignoring duplicate directory `%s'\n", cur
->name
);
143 prev
->next
= cur
->next
;
154 if (INO_T_EQ (qtail
->ino
, brack
->ino
) && qtail
->dev
== brack
->dev
)
159 cpp_notice ("ignoring duplicate directory `%s'\n",
169 while (cur
->next
!= qtail
)
173 cpp_notice ("ignoring duplicate directory `%s'\n",
186 opts
->quote_include
= quote
;
187 opts
->bracket_include
= brack
;
190 /* Look up or add an entry to the table of all includes. This table
191 is indexed by the name as it appears in the #include line. The
192 ->next_this_file chain stores all different files with the same
193 #include name (there are at least three ways this can happen). The
194 hash function could probably be improved a bit. */
196 struct include_hash
*
197 include_hash (pfile
, fname
, add
)
202 unsigned int hash
= 0;
203 struct include_hash
*l
, *m
;
209 l
= pfile
->all_include_files
[hash
% ALL_INCLUDE_HASHSIZE
];
211 for (; l
; m
= l
, l
= l
->next
)
212 if (!strcmp (l
->nshort
, fname
))
218 l
= (struct include_hash
*) xmalloc (sizeof (struct include_hash
));
220 l
->next_this_file
= NULL
;
227 pfile
->all_include_files
[hash
% ALL_INCLUDE_HASHSIZE
] = l
;
232 /* Return 0 if the file pointed to by IHASH has never been included before,
233 -1 if it has been included before and need not be again,
234 or a pointer to an IHASH entry which is the file to be reread.
235 "Never before" is with respect to the position in ILIST.
237 This will not detect redundancies involving odd uses of the
238 `current directory' rule for "" includes. They aren't quite
239 pathological, but I think they are rare enough not to worry about.
240 The simplest example is:
249 and the problem is that for `current directory' includes,
250 ihash->foundhere is not on any of the global include chains,
251 so the test below (i->foundhere == l) may be false even when
252 the directories are in fact the same. */
254 static struct include_hash
*
255 redundant_include_p (pfile
, ihash
, ilist
)
257 struct include_hash
*ihash
;
258 struct file_name_list
*ilist
;
260 struct file_name_list
*l
;
261 struct include_hash
*i
;
263 if (! ihash
->foundhere
)
266 for (i
= ihash
; i
; i
= i
->next_this_file
)
267 for (l
= ilist
; l
; l
= l
->next
)
268 if (i
->foundhere
== l
)
269 /* The control_macro works like this: If it's NULL, the file
270 is to be included again. If it's "", the file is never to
271 be included again. If it's a string, the file is not to be
272 included again if the string is the name of a defined macro. */
273 return (i
->control_macro
274 && (i
->control_macro
[0] == '\0'
275 || cpp_lookup (pfile
, i
->control_macro
, -1, -1)))
276 ? (struct include_hash
*)-1 : i
;
282 file_cleanup (pbuf
, pfile
)
291 if (pfile
->system_include_depth
)
292 pfile
->system_include_depth
--;
296 /* Search for include file FNAME in the include chain starting at
297 SEARCH_START. Return -2 if this file doesn't need to be included
298 (because it was included already and it's marked idempotent),
299 -1 if an error occurred, or a file descriptor open on the file.
300 *IHASH is set to point to the include hash entry for this file, and
301 *BEFORE is 1 if the file was included before (but needs to be read
304 find_include_file (pfile
, fname
, search_start
, ihash
, before
)
307 struct file_name_list
*search_start
;
308 struct include_hash
**ihash
;
311 struct file_name_list
*l
;
312 struct include_hash
*ih
, *jh
;
316 ih
= include_hash (pfile
, fname
, 1);
317 jh
= redundant_include_p (pfile
, ih
,
318 fname
[0] == '/' ? ABSOLUTE_PATH
: search_start
);
325 if (jh
== (struct include_hash
*)-1)
328 return open (jh
->name
, O_RDONLY
, 0666);
332 /* A file is already known by this name, but it's not the same file.
333 Allocate another include_hash block and add it to the next_this_file
336 jh
= (struct include_hash
*)xmalloc (sizeof (struct include_hash
));
337 while (ih
->next_this_file
) ih
= ih
->next_this_file
;
339 ih
->next_this_file
= jh
;
341 ih
= ih
->next_this_file
;
344 ih
->next_this_file
= NULL
;
350 ih
->nshort
= xstrdup (fname
);
351 ih
->control_macro
= NULL
;
353 /* If the pathname is absolute, just open it. */
356 ih
->foundhere
= ABSOLUTE_PATH
;
357 ih
->name
= ih
->nshort
;
358 return open (ih
->name
, O_RDONLY
, 0666);
361 /* Search directory path, trying to open the file. */
363 len
= strlen (fname
);
364 name
= xmalloc (len
+ pfile
->max_include_len
+ 2 + INCLUDE_LEN_FUDGE
);
366 for (l
= search_start
; l
; l
= l
->next
)
368 bcopy (l
->name
, name
, l
->nlen
);
370 strcpy (&name
[l
->nlen
+1], fname
);
371 simplify_pathname (name
);
372 if (CPP_OPTIONS (pfile
)->remap
)
373 name
= remap_filename (pfile
, name
, l
);
375 f
= open (name
, O_RDONLY
|O_NONBLOCK
|O_NOCTTY
, 0666);
377 if (f
== -1 && errno
== EACCES
)
379 cpp_error(pfile
, "included file `%s' exists but is not readable",
388 ih
->name
= xrealloc (name
, strlen (name
)+1);
395 jh
->next_this_file
= NULL
;
399 *ihash
= (struct include_hash
*)-1;
403 /* The file_name_map structure holds a mapping of file names for a
404 particular directory. This mapping is read from the file named
405 FILE_NAME_MAP_FILE in that directory. Such a file can be used to
406 map filenames on a file system with severe filename restrictions,
407 such as DOS. The format of the file name map file is just a series
408 of lines with two tokens on each line. The first token is the name
409 to map, and the second token is the actual name to use. */
413 struct file_name_map
*map_next
;
418 #define FILE_NAME_MAP_FILE "header.gcc"
420 /* Read a space delimited string of unlimited length from a stdio
424 read_filename_string (ch
, f
)
432 set
= alloc
= xmalloc (len
+ 1);
436 while ((ch
= getc (f
)) != EOF
&& ! is_space
[ch
])
438 if (set
- alloc
== len
)
441 alloc
= xrealloc (alloc
, len
+ 1);
442 set
= alloc
+ len
/ 2;
452 /* This structure holds a linked list of file name maps, one per directory. */
454 struct file_name_map_list
456 struct file_name_map_list
*map_list_next
;
458 struct file_name_map
*map_list_map
;
461 /* Read the file name map file for DIRNAME. */
463 static struct file_name_map
*
464 read_name_map (pfile
, dirname
)
468 register struct file_name_map_list
*map_list_ptr
;
472 for (map_list_ptr
= CPP_OPTIONS (pfile
)->map_list
; map_list_ptr
;
473 map_list_ptr
= map_list_ptr
->map_list_next
)
474 if (! strcmp (map_list_ptr
->map_list_name
, dirname
))
475 return map_list_ptr
->map_list_map
;
477 map_list_ptr
= ((struct file_name_map_list
*)
478 xmalloc (sizeof (struct file_name_map_list
)));
479 map_list_ptr
->map_list_name
= xstrdup (dirname
);
481 name
= (char *) alloca (strlen (dirname
) + strlen (FILE_NAME_MAP_FILE
) + 2);
482 strcpy (name
, dirname
);
485 strcat (name
, FILE_NAME_MAP_FILE
);
486 f
= fopen (name
, "r");
488 map_list_ptr
->map_list_map
= (struct file_name_map
*)-1;
492 int dirlen
= strlen (dirname
);
494 while ((ch
= getc (f
)) != EOF
)
497 struct file_name_map
*ptr
;
501 from
= read_filename_string (ch
, f
);
502 while ((ch
= getc (f
)) != EOF
&& is_hor_space
[ch
])
504 to
= read_filename_string (ch
, f
);
506 ptr
= ((struct file_name_map
*)
507 xmalloc (sizeof (struct file_name_map
)));
508 ptr
->map_from
= from
;
510 /* Make the real filename absolute. */
515 ptr
->map_to
= xmalloc (dirlen
+ strlen (to
) + 2);
516 strcpy (ptr
->map_to
, dirname
);
517 ptr
->map_to
[dirlen
] = '/';
518 strcpy (ptr
->map_to
+ dirlen
+ 1, to
);
522 ptr
->map_next
= map_list_ptr
->map_list_map
;
523 map_list_ptr
->map_list_map
= ptr
;
525 while ((ch
= getc (f
)) != '\n')
532 map_list_ptr
->map_list_next
= CPP_OPTIONS (pfile
)->map_list
;
533 CPP_OPTIONS (pfile
)->map_list
= map_list_ptr
;
535 return map_list_ptr
->map_list_map
;
538 /* Remap NAME based on the file_name_map (if any) for LOC. */
541 remap_filename (pfile
, name
, loc
)
544 struct file_name_list
*loc
;
546 struct file_name_map
*map
;
547 const char *from
, *p
, *dir
;
550 loc
->name_map
= read_name_map (pfile
,
554 if (loc
->name_map
== (struct file_name_map
*)-1)
557 from
= name
+ strlen (loc
->name
) + 1;
559 for (map
= loc
->name_map
; map
; map
= map
->map_next
)
560 if (!strcmp (map
->map_from
, from
))
563 /* Try to find a mapping file for the particular directory we are
564 looking in. Thus #include <sys/types.h> will look up sys/types.h
565 in /usr/include/header.gcc and look up types.h in
566 /usr/include/sys/header.gcc. */
567 p
= rindex (name
, '/');
571 && strlen (loc
->name
) == (size_t) (p
- name
)
572 && !strncmp (loc
->name
, name
, p
- name
))
573 /* FILENAME is in SEARCHPTR, which we've already checked. */
583 char * newdir
= (char *) alloca (p
- name
+ 1);
584 bcopy (name
, newdir
, p
- name
);
585 newdir
[p
- name
] = '\0';
590 for (map
= read_name_map (pfile
, dir
); map
; map
= map
->map_next
)
591 if (! strcmp (map
->map_from
, name
))
597 /* Read the contents of FD into the buffer on the top of PFILE's stack.
598 IHASH points to the include hash entry for the file associated with
601 The caller is responsible for the cpp_push_buffer. */
604 finclude (pfile
, fd
, ihash
)
607 struct include_hash
*ihash
;
614 if (fstat (fd
, &st
) < 0)
616 if (fcntl (fd
, F_SETFL
, 0) == -1) /* turn off nonblocking mode */
619 fp
= CPP_BUFFER (pfile
);
621 /* If fd points to a plain file, we know how big it is, so we can
622 allocate the buffer all at once. If fd is a pipe or terminal, we
623 can't. Most C source files are 4k or less, so we guess that. If
624 fd is something weird, like a block device or a directory, we
625 don't want to read it at all.
627 Unfortunately, different systems use different st.st_mode values
628 for pipes: some have S_ISFIFO, some S_ISSOCK, some are buggy and
629 zero the entire struct stat except a couple fields. Hence the
632 In all cases, read_and_prescan will resize the buffer if it
633 turns out there's more data than we thought. */
635 if (S_ISREG (st
.st_mode
))
637 /* off_t might have a wider range than size_t - in other words,
638 the max size of a file might be bigger than the address
639 space. We can't handle a file that large. (Anyone with
640 a single source file bigger than 4GB needs to rethink
641 their coding style.) */
642 st_size
= (size_t) st
.st_size
;
643 if ((unsigned HOST_WIDEST_INT
) st_size
644 != (unsigned HOST_WIDEST_INT
) st
.st_size
)
646 cpp_error (pfile
, "file `%s' is too large", ihash
->name
);
650 else if (S_ISFIFO (st
.st_mode
) || S_ISSOCK (st
.st_mode
)
651 /* Some 4.x (x<4) derivatives have a bug that makes fstat() of a
652 socket or pipe return a stat struct with most fields zeroed. */
653 || (st
.st_mode
== 0 && st
.st_nlink
== 0 && st
.st_size
== 0)
654 || (S_ISCHR (st
.st_mode
) && isatty (fd
)))
656 /* Cannot get its file size before reading. 4k is a decent
662 cpp_error (pfile
, "`%s' is not a file, pipe, or tty", ihash
->name
);
666 /* Read the file, converting end-of-line characters and trigraphs
669 fp
->nominal_fname
= fp
->fname
= ihash
->name
;
670 length
= read_and_prescan (pfile
, fp
, fd
, st_size
);
674 ihash
->control_macro
= ""; /* never re-include */
677 fp
->rlimit
= fp
->alimit
= fp
->buf
+ length
;
679 if (ihash
->foundhere
!= ABSOLUTE_PATH
)
680 fp
->system_header_p
= ihash
->foundhere
->sysp
;
683 fp
->cleanup
= file_cleanup
;
685 /* The ->actual_dir field is only used when ignore_srcdir is not in effect;
687 if (!CPP_OPTIONS (pfile
)->ignore_srcdir
)
688 fp
->actual_dir
= actual_directory (pfile
, fp
->fname
);
690 pfile
->input_stack_listing_current
= 0;
694 cpp_error_from_errno (pfile
, ihash
->name
);
696 cpp_pop_buffer (pfile
);
701 /* Given a path FNAME, extract the directory component and place it
702 onto the actual_dirs list. Return a pointer to the allocated
703 file_name_list structure. These structures are used to implement
704 current-directory "" include searching. */
706 static struct file_name_list
*
707 actual_directory (pfile
, fname
)
711 char *last_slash
, *dir
;
713 struct file_name_list
*x
;
715 dir
= xstrdup (fname
);
716 last_slash
= rindex (dir
, '/');
719 if (last_slash
== dir
)
722 last_slash
[1] = '\0';
726 dlen
= last_slash
- dir
;
737 if (dlen
> pfile
->max_include_len
)
738 pfile
->max_include_len
= dlen
;
740 for (x
= pfile
->actual_dirs
; x
; x
= x
->alloc
)
741 if (!strcmp (x
->name
, dir
))
747 /* Not found, make a new one. */
748 x
= (struct file_name_list
*) xmalloc (sizeof (struct file_name_list
));
751 x
->next
= CPP_OPTIONS (pfile
)->quote_include
;
752 x
->alloc
= pfile
->actual_dirs
;
753 x
->sysp
= CPP_BUFFER (pfile
)->system_header_p
;
756 pfile
->actual_dirs
= x
;
760 /* Almost but not quite the same as adjust_position in cpplib.c.
761 Used only by read_and_prescan. */
763 find_position (start
, limit
, linep
, colp
)
769 long line
= *linep
, col
= 0;
770 while (start
< limit
)
772 U_CHAR ch
= *start
++;
773 if (ch
== '\n' || ch
== '\r')
778 *linep
= line
, *colp
= col
;
781 /* Read the entire contents of file DESC into buffer BUF. LEN is how
782 much memory to allocate initially; more will be allocated if
783 necessary. Convert end-of-line markers (\n, \r, \r\n, \n\r) to
784 canonical form (\n). If enabled, convert and/or warn about
785 trigraphs. Convert backslash-newline to a one-character escape
786 (\r) and remove it from "embarrassing" places (i.e. the middle of a
787 token). If there is no newline at the end of the file, add one and
788 warn. Returns -1 on failure, or the actual length of the data to
791 This function does a lot of work, and can be a serious performance
792 bottleneck. It has been tuned heavily; make sure you understand it
793 before hacking. The common case - no trigraphs, Unix style line
794 breaks, backslash-newline set off by whitespace, newline at EOF -
795 has been optimized at the expense of the others. The performance
796 penalty for DOS style line breaks (\r\n) is about 15%.
798 Warnings lose particularly heavily since we have to determine the
799 line number, which involves scanning from the beginning of the file
800 or from the last warning. The penalty for the absence of a newline
801 at the end of reload1.c is about 60%. (reload1.c is 329k.)
803 If your file has more than one kind of end-of-line marker, you
804 will get messed-up line numbering. */
807 read_and_prescan (pfile
, fp
, desc
, len
)
813 U_CHAR
*buf
= xmalloc (len
);
814 U_CHAR
*ip
, *op
, *line_base
;
816 unsigned int line
, deferred_newlines
;
819 /* PIPE_BUF bytes of buffer proper, 2 to detect running off the end
820 without address arithmetic all the time, and 2 for pushback in
821 the case there's a potential trigraph or end-of-line digraph at
822 the end of a block. */
823 U_CHAR intermed
[PIPE_BUF
+ 2 + 2];
825 /* Table of characters that can't be handled in the inner loop.
826 Keep these contiguous to optimize the performance of the code generated
827 for the switch that uses them. */
828 #define SPECCASE_EMPTY 0
829 #define SPECCASE_NUL 1
830 #define SPECCASE_CR 2
831 #define SPECCASE_BACKSLASH 3
832 #define SPECCASE_QUESTION 4
833 U_CHAR speccase
[256];
839 ibase
= intermed
+ 2;
840 deferred_newlines
= 0;
842 memset (speccase
, SPECCASE_EMPTY
, sizeof (speccase
));
843 speccase
['\0'] = SPECCASE_NUL
;
844 speccase
['\r'] = SPECCASE_CR
;
845 speccase
['\\'] = SPECCASE_BACKSLASH
;
846 if (CPP_OPTIONS (pfile
)->trigraphs
|| CPP_OPTIONS (pfile
)->warn_trigraphs
)
847 speccase
['?'] = SPECCASE_QUESTION
;
853 count
= read (desc
, intermed
+ 2, PIPE_BUF
);
861 ibase
= intermed
+ 2;
862 ibase
[count
] = ibase
[count
+1] = '\0';
867 size_t delta_line_base
;
871 This could happen if the file is larger than half the
872 maximum address space of the machine. */
876 delta_line_base
= line_base
- buf
;
877 buf
= (U_CHAR
*) xrealloc (buf
, len
);
879 line_base
= buf
+ delta_line_base
;
884 unsigned int span
= 0;
886 /* Deal with \-newline in the middle of a token. */
887 if (deferred_newlines
)
889 while (speccase
[ip
[span
]] == SPECCASE_EMPTY
894 memcpy (op
, ip
, span
);
897 if (*ip
== '\n' || *ip
== '\t'
898 || *ip
== ' ' || *ip
== ' ')
899 while (deferred_newlines
)
900 deferred_newlines
--, *op
++ = '\r';
904 /* Copy as much as we can without special treatment. */
905 while (speccase
[ip
[span
]] == SPECCASE_EMPTY
) span
++;
906 memcpy (op
, ip
, span
);
910 switch (speccase
[*ip
++])
912 case SPECCASE_NUL
: /* \0 */
916 case SPECCASE_CR
: /* \r */
919 else if (*ip
== '\0')
925 else if (ip
[-2] == '\n')
930 case SPECCASE_BACKSLASH
: /* \ */
933 /* If we're at the end of the intermediate buffer,
934 we have to shift the backslash down to the start
935 and come back next pass. */
942 else if (*ip
== '\n')
945 if (*ip
== '\r') ip
++;
946 if (*ip
== '\n' || *ip
== '\t' || *ip
== ' ')
948 else if (op
[-1] == '\t' || op
[-1] == ' '
949 || op
[-1] == '\r' || op
[-1] == '\n')
956 else if (*ip
== '\r')
959 if (*ip
== '\n') ip
++;
960 else if (*ip
== '\0')
967 else if (*ip
== '\r' || *ip
== '\t' || *ip
== ' ')
979 case SPECCASE_QUESTION
: /* ? */
982 /* If we're at the end of the intermediate buffer,
983 we have to shift the ?'s down to the start and
984 come back next pass. */
1001 intermed
[0] = intermed
[1] = '?';
1004 if (!trigraph_table
[d
])
1010 if (CPP_OPTIONS (pfile
)->warn_trigraphs
)
1013 find_position (line_base
, op
, &line
, &col
);
1014 line_base
= op
- col
;
1015 cpp_warning_with_line (pfile
, line
, col
,
1016 "trigraph ??%c encountered", d
);
1018 if (CPP_OPTIONS (pfile
)->trigraphs
)
1020 if (trigraph_table
[d
] == '\\')
1023 *op
++ = trigraph_table
[d
];
1040 /* Deal with pushed-back chars at true EOF.
1041 This may be any of: ?? ? \ \r \n \\r \\n.
1042 \r must become \n, \\r or \\n must become \r.
1043 We know we have space already. */
1044 if (ibase
== intermed
)
1054 else if (ibase
== intermed
+ 1)
1065 find_position (line_base
, op
, &line
, &col
);
1066 cpp_warning_with_line (pfile
, line
, col
, "no newline at end of file\n");
1067 if (offset
+ 1 > len
)
1070 if (offset
+ 1 > len
)
1072 buf
= (U_CHAR
*) xrealloc (buf
, len
);
1078 fp
->buf
= ((len
- offset
< 20) ? buf
: (U_CHAR
*)xrealloc (buf
, op
- buf
));
1082 cpp_error (pfile
, "file is too large (>%lu bytes)\n", (unsigned long)offset
);
1087 cpp_error_from_errno (pfile
, fp
->fname
);
1092 /* Add output to `deps_buffer' for the -M switch.
1093 STRING points to the text to be output.
1094 SPACER is ':' for targets, ' ' for dependencies, zero for text
1095 to be inserted literally. */
1098 deps_output (pfile
, string
, spacer
)
1109 size
= strlen (string
);
1111 #ifndef MAX_OUTPUT_COLUMNS
1112 #define MAX_OUTPUT_COLUMNS 72
1114 if (pfile
->deps_column
> 0
1115 && (pfile
->deps_column
+ size
) > MAX_OUTPUT_COLUMNS
)
1118 pfile
->deps_column
= 0;
1121 if (pfile
->deps_size
+ size
+ cr
+ 8 > pfile
->deps_allocated_size
)
1123 pfile
->deps_allocated_size
= (pfile
->deps_size
+ size
+ 50) * 2;
1124 pfile
->deps_buffer
= (char *) xrealloc (pfile
->deps_buffer
,
1125 pfile
->deps_allocated_size
);
1130 bcopy (" \\\n ", &pfile
->deps_buffer
[pfile
->deps_size
], 5);
1131 pfile
->deps_size
+= 5;
1134 if (spacer
== ' ' && pfile
->deps_column
> 0)
1135 pfile
->deps_buffer
[pfile
->deps_size
++] = ' ';
1136 bcopy (string
, &pfile
->deps_buffer
[pfile
->deps_size
], size
);
1137 pfile
->deps_size
+= size
;
1138 pfile
->deps_column
+= size
;
1140 pfile
->deps_buffer
[pfile
->deps_size
++] = ':';
1141 pfile
->deps_buffer
[pfile
->deps_size
] = 0;
1144 /* Simplify a path name in place, deleting redundant components. This
1145 reduces OS overhead and guarantees that equivalent paths compare
1146 the same (modulo symlinks).
1149 foo/bar/../quux foo/quux
1153 //quux //quux (POSIX allows leading // as a namespace escape)
1155 Guarantees no trailing slashes. All transforms reduce the length
1159 simplify_pathname (path
)
1166 #if defined _WIN32 || defined __MSDOS__
1167 /* Convert all backslashes to slashes. */
1168 for (from
= path
; *from
; from
++)
1169 if (*from
== '\\') *from
= '/';
1171 /* Skip over leading drive letter if present. */
1172 if (ISALPHA (path
[0]) && path
[1] == ':')
1173 from
= to
= &path
[2];
1180 /* Remove redundant initial /s. */
1189 /* 3 or more initial /s are equivalent to 1 /. */
1190 while (*++from
== '/');
1192 /* On some hosts // differs from /; Posix allows this. */
1200 while (*from
== '/')
1203 if (from
[0] == '.' && from
[1] == '/')
1205 else if (from
[0] == '.' && from
[1] == '\0')
1207 else if (from
[0] == '.' && from
[1] == '.' && from
[2] == '/')
1224 while (to
> base
&& *to
!= '/') to
--;
1230 else if (from
[0] == '.' && from
[1] == '.' && from
[2] == '\0')
1243 while (to
> base
&& *to
!= '/') to
--;
1250 /* Copy this component and trailing /, if any. */
1251 while ((*to
++ = *from
++) != '/')
1263 /* Trim trailing slash */
1264 if (to
[0] == '/' && (!absolute
|| to
> path
+1))
1267 /* Change the empty string to "." so that stat() on the result
1268 will always work. */
1277 /* It is not clear when this should be used if at all, so I've
1278 disabled it until someone who understands VMS can look at it. */
1281 /* Under VMS we need to fix up the "include" specification filename.
1283 Rules for possible conversions
1285 fullname tried paths
1288 ./dir/name [.dir]name
1290 /name [000000]name, name
1291 dir/name dir:[000000]name, dir:name, dir/name
1292 dir1/dir2/name dir1:[dir2]name, dir1:[000000.dir2]name
1293 path:/name path:[000000]name, path:name
1294 path:/dir/name path:[000000.dir]name, path:[dir]name
1295 path:dir/name path:[dir]name
1296 [path]:[dir]name [path.dir]name
1297 path/[dir]name [path.dir]name
1299 The path:/name input is constructed when expanding <> includes. */
1303 hack_vms_include_specification (fullname
)
1306 register char *basename
, *unixname
, *local_ptr
, *first_slash
;
1307 int f
, check_filename_before_returning
, must_revert
;
1310 check_filename_before_returning
= 0;
1312 /* See if we can find a 1st slash. If not, there's no path information. */
1313 first_slash
= index (fullname
, '/');
1314 if (first_slash
== 0)
1315 return 0; /* Nothing to do!!! */
1317 /* construct device spec if none given. */
1319 if (index (fullname
, ':') == 0)
1322 /* If fullname has a slash, take it as device spec. */
1324 if (first_slash
== fullname
)
1326 first_slash
= index (fullname
+1, '/'); /* 2nd slash ? */
1328 *first_slash
= ':'; /* make device spec */
1329 for (basename
= fullname
; *basename
!= 0; basename
++)
1330 *basename
= *(basename
+1); /* remove leading slash */
1332 else if ((first_slash
[-1] != '.') /* keep ':/', './' */
1333 && (first_slash
[-1] != ':')
1334 && (first_slash
[-1] != ']')) /* or a vms path */
1338 else if ((first_slash
[1] == '[') /* skip './' in './[dir' */
1339 && (first_slash
[-1] == '.'))
1343 /* Get part after first ':' (basename[-1] == ':')
1344 or last '/' (basename[-1] == '/'). */
1346 basename
= base_name (fullname
);
1348 local_ptr
= Local
; /* initialize */
1350 /* We are trying to do a number of things here. First of all, we are
1351 trying to hammer the filenames into a standard format, such that later
1352 processing can handle them.
1354 If the file name contains something like [dir.], then it recognizes this
1355 as a root, and strips the ".]". Later processing will add whatever is
1356 needed to get things working properly.
1358 If no device is specified, then the first directory name is taken to be
1359 a device name (or a rooted logical). */
1361 /* Point to the UNIX filename part (which needs to be fixed!)
1362 but skip vms path information.
1363 [basename != fullname since first_slash != 0]. */
1365 if ((basename
[-1] == ':') /* vms path spec. */
1366 || (basename
[-1] == ']')
1367 || (basename
[-1] == '>'))
1368 unixname
= basename
;
1370 unixname
= fullname
;
1372 if (*unixname
== '/')
1375 /* If the directory spec is not rooted, we can just copy
1376 the UNIX filename part and we are done. */
1378 if (((basename
- fullname
) > 1)
1379 && ( (basename
[-1] == ']')
1380 || (basename
[-1] == '>')))
1382 if (basename
[-2] != '.')
1385 /* The VMS part ends in a `]', and the preceding character is not a `.'.
1386 -> PATH]:/name (basename = '/name', unixname = 'name')
1387 We strip the `]', and then splice the two parts of the name in the
1388 usual way. Given the default locations for include files in cccp.c,
1389 we will only use this code if the user specifies alternate locations
1390 with the /include (-I) switch on the command line. */
1392 basename
-= 1; /* Strip "]" */
1393 unixname
--; /* backspace */
1398 /* The VMS part has a ".]" at the end, and this will not do. Later
1399 processing will add a second directory spec, and this would be a syntax
1400 error. Thus we strip the ".]", and thus merge the directory specs.
1401 We also backspace unixname, so that it points to a '/'. This inhibits the
1402 generation of the 000000 root directory spec (which does not belong here
1405 basename
-= 2; /* Strip ".]" */
1406 unixname
--; /* backspace */
1414 /* We drop in here if there is no VMS style directory specification yet.
1415 If there is no device specification either, we make the first dir a
1416 device and try that. If we do not do this, then we will be essentially
1417 searching the users default directory (as if they did a #include "asdf.h").
1419 Then all we need to do is to push a '[' into the output string. Later
1420 processing will fill this in, and close the bracket. */
1422 if ((unixname
!= fullname
) /* vms path spec found. */
1423 && (basename
[-1] != ':'))
1424 *local_ptr
++ = ':'; /* dev not in spec. take first dir */
1426 *local_ptr
++ = '['; /* Open the directory specification */
1429 if (unixname
== fullname
) /* no vms dir spec. */
1432 if ((first_slash
!= 0) /* unix dir spec. */
1433 && (*unixname
!= '/') /* not beginning with '/' */
1434 && (*unixname
!= '.')) /* or './' or '../' */
1435 *local_ptr
++ = '.'; /* dir is local ! */
1438 /* at this point we assume that we have the device spec, and (at least
1439 the opening "[" for a directory specification. We may have directories
1442 If there are no other slashes then the filename will be
1443 in the "root" directory. Otherwise, we need to add
1444 directory specifications. */
1446 if (index (unixname
, '/') == 0)
1448 /* if no directories specified yet and none are following. */
1449 if (local_ptr
[-1] == '[')
1451 /* Just add "000000]" as the directory string */
1452 strcpy (local_ptr
, "000000]");
1453 local_ptr
+= strlen (local_ptr
);
1454 check_filename_before_returning
= 1; /* we might need to fool with this later */
1460 /* As long as there are still subdirectories to add, do them. */
1461 while (index (unixname
, '/') != 0)
1463 /* If this token is "." we can ignore it
1464 if it's not at the beginning of a path. */
1465 if ((unixname
[0] == '.') && (unixname
[1] == '/'))
1467 /* remove it at beginning of path. */
1468 if ( ((unixname
== fullname
) /* no device spec */
1469 && (fullname
+2 != basename
)) /* starts with ./ */
1471 || ((basename
[-1] == ':') /* device spec */
1472 && (unixname
-1 == basename
))) /* and ./ afterwards */
1473 *local_ptr
++ = '.'; /* make '[.' start of path. */
1478 /* Add a subdirectory spec. Do not duplicate "." */
1479 if ( local_ptr
[-1] != '.'
1480 && local_ptr
[-1] != '['
1481 && local_ptr
[-1] != '<')
1484 /* If this is ".." then the spec becomes "-" */
1485 if ( (unixname
[0] == '.')
1486 && (unixname
[1] == '.')
1487 && (unixname
[2] == '/'))
1489 /* Add "-" and skip the ".." */
1490 if ((local_ptr
[-1] == '.')
1491 && (local_ptr
[-2] == '['))
1492 local_ptr
--; /* prevent [.- */
1498 /* Copy the subdirectory */
1499 while (*unixname
!= '/')
1500 *local_ptr
++= *unixname
++;
1502 unixname
++; /* Skip the "/" */
1505 /* Close the directory specification */
1506 if (local_ptr
[-1] == '.') /* no trailing periods */
1509 if (local_ptr
[-1] == '[') /* no dir needed */
1515 /* Now add the filename. */
1518 *local_ptr
++ = *unixname
++;
1521 /* Now append it to the original VMS spec. */
1523 strcpy ((must_revert
==1)?fullname
:basename
, Local
);
1525 /* If we put a [000000] in the filename, try to open it first. If this fails,
1526 remove the [000000], and return that name. This provides flexibility
1527 to the user in that they can use both rooted and non-rooted logical names
1528 to point to the location of the file. */
1530 if (check_filename_before_returning
)
1532 f
= open (fullname
, O_RDONLY
, 0666);
1535 /* The file name is OK as it is, so return it as is. */
1540 /* The filename did not work. Try to remove the [000000] from the name,
1543 basename
= index (fullname
, '[');
1544 local_ptr
= index (fullname
, ']') + 1;
1545 strcpy (basename
, local_ptr
); /* this gets rid of it */