1 /* Part of CPP library. (include file handling)
2 Copyright (C) 1986, 87, 89, 92-95, 98, 99, 2000 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! */
31 /* The entry points to this file are: find_include_file, finclude,
32 include_hash, append_include_chain, deps_output, and file_cleanup.
33 file_cleanup is only called through CPP_BUFFER(pfile)->cleanup,
34 so it's static anyway. */
36 static struct include_hash *redundant_include_p
37 PARAMS ((cpp_reader *,
38 struct include_hash *,
39 struct file_name_list *));
40 static struct file_name_map *read_name_map
41 PARAMS ((cpp_reader *, const char *));
42 static char *read_filename_string PARAMS ((int, FILE *));
43 static char *remap_filename PARAMS ((cpp_reader *, char *,
44 struct file_name_list *));
45 static long read_and_prescan PARAMS ((cpp_reader *, cpp_buffer *,
47 static struct file_name_list *actual_directory
48 PARAMS ((cpp_reader *, const char *));
49 static void initialize_input_buffer PARAMS ((cpp_reader *, int,
51 static int file_cleanup PARAMS ((cpp_buffer *, cpp_reader *));
52 static U_CHAR *find_position PARAMS ((U_CHAR *, U_CHAR *,
56 static void hack_vms_include_specification PARAMS ((char *));
59 /* Windows does not natively support inodes, and neither does MSDOS.
60 Cygwin's emulation can generate non-unique inodes, so don't use it.
61 VMS has non-numeric inodes. */
63 #define INO_T_EQ(a, b) (!bcmp((char *) &(a), (char *) &(b), sizeof (a)))
64 #elif (defined _WIN32 && ! defined (_UWIN)) \
66 #define INO_T_EQ(a, b) 0
68 #define INO_T_EQ(a, b) ((a) == (b))
71 #ifndef INCLUDE_LEN_FUDGE
72 #define INCLUDE_LEN_FUDGE 0
75 /* Merge the four include chains together in the order quote, bracket,
76 system, after. Remove duplicate dirs (as determined by
77 INO_T_EQ()). The system_include and after_include chains are never
78 referred to again after this function; all access is through the
81 For the future: Check if the directory is empty (but
82 how?) and possibly preload the include hash. */
85 merge_include_chains (opts)
86 struct cpp_options *opts;
88 struct file_name_list *prev, *cur, *other;
89 struct file_name_list *quote, *brack, *systm, *after;
90 struct file_name_list *qtail, *btail, *stail, *atail;
92 qtail = opts->pending->quote_tail;
93 btail = opts->pending->brack_tail;
94 stail = opts->pending->systm_tail;
95 atail = opts->pending->after_tail;
97 quote = opts->pending->quote_head;
98 brack = opts->pending->brack_head;
99 systm = opts->pending->systm_head;
100 after = opts->pending->after_head;
102 /* Paste together bracket, system, and after include chains. */
112 /* This is a bit tricky.
113 First we drop dupes from the quote-include list.
114 Then we drop dupes from the bracket-include list.
115 Finally, if qtail and brack are the same directory,
118 We can't just merge the lists and then uniquify them because
119 then we may lose directories from the <> search path that should
120 be there; consider -Ifoo -Ibar -I- -Ifoo -Iquux. It is however
121 safe to treat -Ibar -Ifoo -I- -Ifoo -Iquux as if written
122 -Ibar -I- -Ifoo -Iquux.
124 Note that this algorithm is quadratic in the number of -I switches,
125 which is acceptable since there aren't usually that many of them. */
127 for (cur = quote, prev = NULL; cur; cur = cur->next)
129 for (other = quote; other != cur; other = other->next)
130 if (INO_T_EQ (cur->ino, other->ino)
131 && cur->dev == other->dev)
134 fprintf (stderr, _("ignoring duplicate directory `%s'\n"),
137 prev->next = cur->next;
147 for (cur = brack; cur; cur = cur->next)
149 for (other = brack; other != cur; other = other->next)
150 if (INO_T_EQ (cur->ino, other->ino)
151 && cur->dev == other->dev)
154 fprintf (stderr, _("ignoring duplicate directory `%s'\n"),
157 prev->next = cur->next;
168 if (INO_T_EQ (qtail->ino, brack->ino) && qtail->dev == brack->dev)
173 fprintf (stderr, _("ignoring duplicate directory `%s'\n"),
183 while (cur->next != qtail)
187 fprintf (stderr, _("ignoring duplicate directory `%s'\n"),
200 opts->quote_include = quote;
201 opts->bracket_include = brack;
204 /* Look up or add an entry to the table of all includes. This table
205 is indexed by the name as it appears in the #include line. The
206 ->next_this_file chain stores all different files with the same
207 #include name (there are at least three ways this can happen). The
208 hash function could probably be improved a bit. */
210 struct include_hash *
211 include_hash (pfile, fname, add)
216 unsigned int hash = 0;
217 struct include_hash *l, *m;
218 const char *f = fname;
223 l = pfile->all_include_files[hash % ALL_INCLUDE_HASHSIZE];
225 for (; l; m = l, l = l->next)
226 if (!strcmp (l->nshort, fname))
232 l = (struct include_hash *) xmalloc (sizeof (struct include_hash));
234 l->next_this_file = NULL;
241 pfile->all_include_files[hash % ALL_INCLUDE_HASHSIZE] = l;
246 /* Return 0 if the file pointed to by IHASH has never been included before,
247 -1 if it has been included before and need not be again,
248 or a pointer to an IHASH entry which is the file to be reread.
249 "Never before" is with respect to the position in ILIST.
251 This will not detect redundancies involving odd uses of the
252 `current directory' rule for "" includes. They aren't quite
253 pathological, but I think they are rare enough not to worry about.
254 The simplest example is:
263 and the problem is that for `current directory' includes,
264 ihash->foundhere is not on any of the global include chains,
265 so the test below (i->foundhere == l) may be false even when
266 the directories are in fact the same. */
268 static struct include_hash *
269 redundant_include_p (pfile, ihash, ilist)
271 struct include_hash *ihash;
272 struct file_name_list *ilist;
274 struct file_name_list *l;
275 struct include_hash *i;
277 if (! ihash->foundhere)
280 for (i = ihash; i; i = i->next_this_file)
281 for (l = ilist; l; l = l->next)
282 if (i->foundhere == l)
283 /* The control_macro works like this: If it's NULL, the file
284 is to be included again. If it's "", the file is never to
285 be included again. If it's a string, the file is not to be
286 included again if the string is the name of a defined macro. */
287 return (i->control_macro
288 && (i->control_macro[0] == '\0'
289 || cpp_lookup (pfile, i->control_macro, -1)))
290 ? (struct include_hash *)-1 : i;
296 file_cleanup (pbuf, pfile)
305 if (pfile->system_include_depth)
306 pfile->system_include_depth--;
310 /* Search for include file FNAME in the include chain starting at
311 SEARCH_START. Return -2 if this file doesn't need to be included
312 (because it was included already and it's marked idempotent),
313 -1 if an error occurred, or a file descriptor open on the file.
314 *IHASH is set to point to the include hash entry for this file, and
315 *BEFORE is 1 if the file was included before (but needs to be read
318 find_include_file (pfile, fname, search_start, ihash, before)
321 struct file_name_list *search_start;
322 struct include_hash **ihash;
325 struct file_name_list *l;
326 struct include_hash *ih, *jh;
330 ih = include_hash (pfile, fname, 1);
331 jh = redundant_include_p (pfile, ih,
332 fname[0] == '/' ? ABSOLUTE_PATH : search_start);
339 if (jh == (struct include_hash *)-1)
342 return open (jh->name, O_RDONLY, 0666);
346 /* A file is already known by this name, but it's not the same file.
347 Allocate another include_hash block and add it to the next_this_file
350 jh = (struct include_hash *)xmalloc (sizeof (struct include_hash));
351 while (ih->next_this_file) ih = ih->next_this_file;
353 ih->next_this_file = jh;
355 ih = ih->next_this_file;
358 ih->next_this_file = NULL;
364 ih->nshort = xstrdup (fname);
365 ih->control_macro = NULL;
367 /* If the pathname is absolute, just open it. */
370 ih->foundhere = ABSOLUTE_PATH;
371 ih->name = ih->nshort;
372 return open (ih->name, O_RDONLY, 0666);
375 /* Search directory path, trying to open the file. */
377 len = strlen (fname);
378 name = xmalloc (len + pfile->max_include_len + 2 + INCLUDE_LEN_FUDGE);
380 for (l = search_start; l; l = l->next)
382 bcopy (l->name, name, l->nlen);
384 strcpy (&name[l->nlen+1], fname);
385 simplify_pathname (name);
386 if (CPP_OPTIONS (pfile)->remap)
387 name = remap_filename (pfile, name, l);
389 f = open (name, O_RDONLY|O_NONBLOCK|O_NOCTTY, 0666);
391 if (f == -1 && errno == EACCES)
393 cpp_error(pfile, "included file `%s' exists but is not readable",
402 ih->name = xrealloc (name, strlen (name)+1);
409 jh->next_this_file = NULL;
413 *ihash = (struct include_hash *)-1;
417 /* The file_name_map structure holds a mapping of file names for a
418 particular directory. This mapping is read from the file named
419 FILE_NAME_MAP_FILE in that directory. Such a file can be used to
420 map filenames on a file system with severe filename restrictions,
421 such as DOS. The format of the file name map file is just a series
422 of lines with two tokens on each line. The first token is the name
423 to map, and the second token is the actual name to use. */
427 struct file_name_map *map_next;
432 #define FILE_NAME_MAP_FILE "header.gcc"
434 /* Read a space delimited string of unlimited length from a stdio
438 read_filename_string (ch, f)
446 set = alloc = xmalloc (len + 1);
450 while ((ch = getc (f)) != EOF && ! is_space(ch))
452 if (set - alloc == len)
455 alloc = xrealloc (alloc, len + 1);
456 set = alloc + len / 2;
466 /* This structure holds a linked list of file name maps, one per directory. */
468 struct file_name_map_list
470 struct file_name_map_list *map_list_next;
472 struct file_name_map *map_list_map;
475 /* Read the file name map file for DIRNAME. */
477 static struct file_name_map *
478 read_name_map (pfile, dirname)
482 register struct file_name_map_list *map_list_ptr;
486 for (map_list_ptr = CPP_OPTIONS (pfile)->map_list; map_list_ptr;
487 map_list_ptr = map_list_ptr->map_list_next)
488 if (! strcmp (map_list_ptr->map_list_name, dirname))
489 return map_list_ptr->map_list_map;
491 map_list_ptr = ((struct file_name_map_list *)
492 xmalloc (sizeof (struct file_name_map_list)));
493 map_list_ptr->map_list_name = xstrdup (dirname);
495 name = (char *) alloca (strlen (dirname) + strlen (FILE_NAME_MAP_FILE) + 2);
496 strcpy (name, dirname);
499 strcat (name, FILE_NAME_MAP_FILE);
500 f = fopen (name, "r");
502 map_list_ptr->map_list_map = (struct file_name_map *)-1;
506 int dirlen = strlen (dirname);
508 while ((ch = getc (f)) != EOF)
511 struct file_name_map *ptr;
515 from = read_filename_string (ch, f);
516 while ((ch = getc (f)) != EOF && is_hspace(ch))
518 to = read_filename_string (ch, f);
520 ptr = ((struct file_name_map *)
521 xmalloc (sizeof (struct file_name_map)));
522 ptr->map_from = from;
524 /* Make the real filename absolute. */
529 ptr->map_to = xmalloc (dirlen + strlen (to) + 2);
530 strcpy (ptr->map_to, dirname);
531 ptr->map_to[dirlen] = '/';
532 strcpy (ptr->map_to + dirlen + 1, to);
536 ptr->map_next = map_list_ptr->map_list_map;
537 map_list_ptr->map_list_map = ptr;
539 while ((ch = getc (f)) != '\n')
546 map_list_ptr->map_list_next = CPP_OPTIONS (pfile)->map_list;
547 CPP_OPTIONS (pfile)->map_list = map_list_ptr;
549 return map_list_ptr->map_list_map;
552 /* Remap NAME based on the file_name_map (if any) for LOC. */
555 remap_filename (pfile, name, loc)
558 struct file_name_list *loc;
560 struct file_name_map *map;
561 const char *from, *p, *dir;
564 loc->name_map = read_name_map (pfile,
568 if (loc->name_map == (struct file_name_map *)-1)
571 from = name + strlen (loc->name) + 1;
573 for (map = loc->name_map; map; map = map->map_next)
574 if (!strcmp (map->map_from, from))
577 /* Try to find a mapping file for the particular directory we are
578 looking in. Thus #include <sys/types.h> will look up sys/types.h
579 in /usr/include/header.gcc and look up types.h in
580 /usr/include/sys/header.gcc. */
581 p = rindex (name, '/');
585 && strlen (loc->name) == (size_t) (p - name)
586 && !strncmp (loc->name, name, p - name))
587 /* FILENAME is in SEARCHPTR, which we've already checked. */
597 char * newdir = (char *) alloca (p - name + 1);
598 bcopy (name, newdir, p - name);
599 newdir[p - name] = '\0';
604 for (map = read_name_map (pfile, dir); map; map = map->map_next)
605 if (! strcmp (map->map_from, name))
611 /* Read the contents of FD into the buffer on the top of PFILE's stack.
612 IHASH points to the include hash entry for the file associated with
615 The caller is responsible for the cpp_push_buffer. */
618 finclude (pfile, fd, ihash)
621 struct include_hash *ihash;
628 if (fstat (fd, &st) < 0)
630 if (fcntl (fd, F_SETFL, 0) == -1) /* turn off nonblocking mode */
633 fp = CPP_BUFFER (pfile);
635 /* If fd points to a plain file, we know how big it is, so we can
636 allocate the buffer all at once. If fd is a pipe or terminal, we
637 can't. Most C source files are 4k or less, so we guess that. If
638 fd is something weird, like a block device or a directory, we
639 don't want to read it at all.
641 Unfortunately, different systems use different st.st_mode values
642 for pipes: some have S_ISFIFO, some S_ISSOCK, some are buggy and
643 zero the entire struct stat except a couple fields. Hence the
646 In all cases, read_and_prescan will resize the buffer if it
647 turns out there's more data than we thought. */
649 if (S_ISREG (st.st_mode))
651 /* off_t might have a wider range than size_t - in other words,
652 the max size of a file might be bigger than the address
653 space. We can't handle a file that large. (Anyone with
654 a single source file bigger than 4GB needs to rethink
655 their coding style.) */
656 st_size = (size_t) st.st_size;
657 if ((unsigned HOST_WIDEST_INT) st_size
658 != (unsigned HOST_WIDEST_INT) st.st_size)
660 cpp_error (pfile, "file `%s' is too large", ihash->name);
664 else if (S_ISFIFO (st.st_mode) || S_ISSOCK (st.st_mode)
665 /* Permit any kind of character device: the sensible ones are
666 ttys and /dev/null, but weeding out the others is too hard. */
667 || S_ISCHR (st.st_mode)
668 /* Some 4.x (x<4) derivatives have a bug that makes fstat() of a
669 socket or pipe return a stat struct with most fields zeroed. */
670 || (st.st_mode == 0 && st.st_nlink == 0 && st.st_size == 0))
672 /* Cannot get its file size before reading. 4k is a decent
678 cpp_error (pfile, "`%s' is not a file, pipe, or tty", ihash->name);
682 if (pfile->input_buffer == NULL)
683 initialize_input_buffer (pfile, fd, &st);
685 /* Read the file, converting end-of-line characters and trigraphs
688 fp->nominal_fname = fp->fname = ihash->name;
689 length = read_and_prescan (pfile, fp, fd, st_size);
693 ihash->control_macro = ""; /* never re-include */
696 fp->rlimit = fp->alimit = fp->buf + length;
698 if (ihash->foundhere != ABSOLUTE_PATH)
699 fp->system_header_p = ihash->foundhere->sysp;
702 fp->line_base = fp->buf;
703 fp->cleanup = file_cleanup;
705 /* The ->actual_dir field is only used when ignore_srcdir is not in effect;
707 if (!CPP_OPTIONS (pfile)->ignore_srcdir)
708 fp->actual_dir = actual_directory (pfile, fp->fname);
710 pfile->input_stack_listing_current = 0;
714 cpp_error_from_errno (pfile, ihash->name);
716 cpp_pop_buffer (pfile);
721 /* Given a path FNAME, extract the directory component and place it
722 onto the actual_dirs list. Return a pointer to the allocated
723 file_name_list structure. These structures are used to implement
724 current-directory "" include searching. */
726 static struct file_name_list *
727 actual_directory (pfile, fname)
731 char *last_slash, *dir;
733 struct file_name_list *x;
735 dir = xstrdup (fname);
736 last_slash = rindex (dir, '/');
739 if (last_slash == dir)
742 last_slash[1] = '\0';
746 dlen = last_slash - dir;
757 if (dlen > pfile->max_include_len)
758 pfile->max_include_len = dlen;
760 for (x = pfile->actual_dirs; x; x = x->alloc)
761 if (!strcmp (x->name, dir))
767 /* Not found, make a new one. */
768 x = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
771 x->next = CPP_OPTIONS (pfile)->quote_include;
772 x->alloc = pfile->actual_dirs;
773 x->sysp = CPP_BUFFER (pfile)->system_header_p;
776 pfile->actual_dirs = x;
780 /* Determine the current line and column. Used only by read_and_prescan. */
782 find_position (start, limit, linep)
785 unsigned long *linep;
787 unsigned long line = *linep;
788 U_CHAR *lbase = start;
789 while (start < limit)
791 U_CHAR ch = *start++;
792 if (ch == '\n' || ch == '\r')
802 /* Read the entire contents of file DESC into buffer BUF. LEN is how
803 much memory to allocate initially; more will be allocated if
804 necessary. Convert end-of-line markers (\n, \r, \r\n, \n\r) to
805 canonical form (\n). If enabled, convert and/or warn about
806 trigraphs. Convert backslash-newline to a one-character escape
807 (\r) and remove it from "embarrassing" places (i.e. the middle of a
808 token). If there is no newline at the end of the file, add one and
809 warn. Returns -1 on failure, or the actual length of the data to
812 This function does a lot of work, and can be a serious performance
813 bottleneck. It has been tuned heavily; make sure you understand it
814 before hacking. The common case - no trigraphs, Unix style line
815 breaks, backslash-newline set off by whitespace, newline at EOF -
816 has been optimized at the expense of the others. The performance
817 penalty for DOS style line breaks (\r\n) is about 15%.
819 Warnings lose particularly heavily since we have to determine the
820 line number, which involves scanning from the beginning of the file
821 or from the last warning. The penalty for the absence of a newline
822 at the end of reload1.c is about 60%. (reload1.c is 329k.)
824 If your file has more than one kind of end-of-line marker, you
825 will get messed-up line numbering. */
827 /* Table of characters that can't be handled in the inner loop.
828 Keep these contiguous to optimize the performance of the code generated
829 for the switch that uses them. */
830 #define SPECCASE_EMPTY 0
831 #define SPECCASE_NUL 1
832 #define SPECCASE_CR 2
833 #define SPECCASE_BACKSLASH 3
834 #define SPECCASE_QUESTION 4
837 read_and_prescan (pfile, fp, desc, len)
843 U_CHAR *buf = (U_CHAR *) xmalloc (len);
844 U_CHAR *ip, *op, *line_base;
846 U_CHAR *speccase = pfile->input_speccase;
848 unsigned int deferred_newlines;
856 ibase = pfile->input_buffer + 2;
857 deferred_newlines = 0;
863 count = read (desc, pfile->input_buffer + 2, pfile->input_buffer_len);
871 ibase = pfile->input_buffer + 2;
872 ibase[count] = ibase[count+1] = '\0';
877 size_t delta_line_base;
881 This could happen if the file is larger than half the
882 maximum address space of the machine. */
886 delta_line_base = line_base - buf;
887 buf = (U_CHAR *) xrealloc (buf, len);
889 line_base = buf + delta_line_base;
894 unsigned int span = 0;
896 /* Deal with \-newline in the middle of a token. */
897 if (deferred_newlines)
899 while (speccase[ip[span]] == SPECCASE_EMPTY
904 memcpy (op, ip, span);
907 if (*ip == '\n' || *ip == '\t'
908 || *ip == ' ' || *ip == ' ')
909 while (deferred_newlines)
910 deferred_newlines--, *op++ = '\r';
914 /* Copy as much as we can without special treatment. */
915 while (speccase[ip[span]] == SPECCASE_EMPTY) span++;
916 memcpy (op, ip, span);
920 switch (speccase[*ip++])
922 case SPECCASE_NUL: /* \0 */
926 case SPECCASE_CR: /* \r */
929 else if (*ip == '\0')
934 else if (ip[-2] == '\n')
939 case SPECCASE_BACKSLASH: /* \ */
942 /* If we're at the end of the intermediate buffer,
943 we have to shift the backslash down to the start
944 and come back next pass. */
950 else if (*ip == '\n')
953 if (*ip == '\r') ip++;
954 if (*ip == '\n' || *ip == '\t' || *ip == ' ')
956 else if (op[-1] == '\t' || op[-1] == ' '
957 || op[-1] == '\r' || op[-1] == '\n')
962 else if (*ip == '\r')
965 if (*ip == '\n') ip++;
966 else if (*ip == '\0')
972 else if (*ip == '\r' || *ip == '\t' || *ip == ' ')
982 case SPECCASE_QUESTION: /* ? */
985 /* If we're at the end of the intermediate buffer,
986 we have to shift the ?'s down to the start and
987 come back next pass. */
1008 * from to from to from to
1009 * ?? = # ?? ) ] ?? ! |
1010 * ?? ( [ ?? ' ^ ?? > }
1011 * ?? / \ ?? < { ?? - ~
1013 if (d == '=') t = '#';
1014 else if (d == ')') t = ']';
1015 else if (d == '!') t = '|';
1016 else if (d == '(') t = '[';
1017 else if (d == '\'') t = '^';
1018 else if (d == '>') t = '}';
1019 else if (d == '/') t = '\\';
1020 else if (d == '<') t = '{';
1021 else if (d == '-') t = '~';
1028 if (CPP_OPTIONS (pfile)->warn_trigraphs)
1031 line_base = find_position (line_base, op, &line);
1032 col = op - line_base + 1;
1033 if (CPP_OPTIONS (pfile)->trigraphs)
1034 cpp_warning_with_line (pfile, line, col,
1035 "trigraph ??%c converted to %c", d, t);
1037 cpp_warning_with_line (pfile, line, col,
1038 "trigraph ??%c ignored", d);
1040 if (CPP_OPTIONS (pfile)->trigraphs)
1061 /* Deal with pushed-back chars at true EOF.
1062 This may be any of: ?? ? \ \r \n \\r \\n.
1063 \r must become \n, \\r or \\n must become \r.
1064 We know we have space already. */
1065 if (ibase == pfile->input_buffer)
1075 else if (ibase == pfile->input_buffer + 1)
1086 line_base = find_position (line_base, op, &line);
1087 col = op - line_base + 1;
1088 cpp_warning_with_line (pfile, line, col, "no newline at end of file\n");
1089 if (offset + 1 > len)
1092 if (offset + 1 > len)
1094 buf = (U_CHAR *) xrealloc (buf, len);
1100 fp->buf = ((len - offset < 20) ? buf : (U_CHAR *)xrealloc (buf, op - buf));
1104 cpp_error (pfile, "file is too large (>%lu bytes)\n", (unsigned long)offset);
1109 cpp_error_from_errno (pfile, fp->fname);
1114 /* Initialize the `input_buffer' and `input_speccase' tables.
1115 These are only used by read_and_prescan, but they're large and
1116 somewhat expensive to set up, so we want them allocated once for
1117 the duration of the cpp run. */
1120 initialize_input_buffer (pfile, fd, st)
1128 /* Table of characters that cannot be handled by the
1129 read_and_prescan inner loop. The number of non-EMPTY entries
1130 should be as small as humanly possible. */
1132 tmp = (U_CHAR *) xmalloc (1 << CHAR_BIT);
1133 memset (tmp, SPECCASE_EMPTY, 1 << CHAR_BIT);
1134 tmp['\0'] = SPECCASE_NUL;
1135 tmp['\r'] = SPECCASE_CR;
1136 tmp['\\'] = SPECCASE_BACKSLASH;
1137 if (CPP_OPTIONS (pfile)->trigraphs || CPP_OPTIONS (pfile)->warn_trigraphs)
1138 tmp['?'] = SPECCASE_QUESTION;
1140 pfile->input_speccase = tmp;
1142 /* Determine the appropriate size for the input buffer. Normal C
1143 source files are smaller than eight K. If we are reading a pipe,
1144 we want to make sure the input buffer is bigger than the kernel's
1148 if (! S_ISREG (st->st_mode))
1151 pipe_buf = fpathconf (fd, _PC_PIPE_BUF);
1156 pipe_buf = PIPE_BUF;
1163 if (pipe_buf < 8192)
1165 /* PIPE_BUF bytes of buffer proper, 2 to detect running off the end
1166 without address arithmetic all the time, and 2 for pushback in
1167 the case there's a potential trigraph or end-of-line digraph at
1168 the end of a block. */
1170 tmp = (U_CHAR *) xmalloc (pipe_buf + 2 + 2);
1171 pfile->input_buffer = tmp;
1172 pfile->input_buffer_len = pipe_buf;
1175 /* Add output to `deps_buffer' for the -M switch.
1176 STRING points to the text to be output.
1177 SPACER is ':' for targets, ' ' for dependencies, zero for text
1178 to be inserted literally. */
1181 deps_output (pfile, string, spacer)
1192 size = strlen (string);
1194 #ifndef MAX_OUTPUT_COLUMNS
1195 #define MAX_OUTPUT_COLUMNS 72
1197 if (pfile->deps_column > 0
1198 && (pfile->deps_column + size) > MAX_OUTPUT_COLUMNS)
1201 pfile->deps_column = 0;
1204 if (pfile->deps_size + size + cr + 8 > pfile->deps_allocated_size)
1206 pfile->deps_allocated_size = (pfile->deps_size + size + 50) * 2;
1207 pfile->deps_buffer = (char *) xrealloc (pfile->deps_buffer,
1208 pfile->deps_allocated_size);
1213 bcopy (" \\\n ", &pfile->deps_buffer[pfile->deps_size], 5);
1214 pfile->deps_size += 5;
1217 if (spacer == ' ' && pfile->deps_column > 0)
1218 pfile->deps_buffer[pfile->deps_size++] = ' ';
1219 bcopy (string, &pfile->deps_buffer[pfile->deps_size], size);
1220 pfile->deps_size += size;
1221 pfile->deps_column += size + 1; /* count spacer too */
1223 pfile->deps_buffer[pfile->deps_size++] = ':';
1224 pfile->deps_buffer[pfile->deps_size] = 0;
1227 /* Simplify a path name in place, deleting redundant components. This
1228 reduces OS overhead and guarantees that equivalent paths compare
1229 the same (modulo symlinks).
1232 foo/bar/../quux foo/quux
1236 //quux //quux (POSIX allows leading // as a namespace escape)
1238 Guarantees no trailing slashes. All transforms reduce the length
1242 simplify_pathname (path)
1249 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
1250 /* Convert all backslashes to slashes. */
1251 for (from = path; *from; from++)
1252 if (*from == '\\') *from = '/';
1254 /* Skip over leading drive letter if present. */
1255 if (ISALPHA (path[0]) && path[1] == ':')
1256 from = to = &path[2];
1263 /* Remove redundant initial /s. */
1272 /* 3 or more initial /s are equivalent to 1 /. */
1273 while (*++from == '/');
1275 /* On some hosts // differs from /; Posix allows this. */
1283 while (*from == '/')
1286 if (from[0] == '.' && from[1] == '/')
1288 else if (from[0] == '.' && from[1] == '\0')
1290 else if (from[0] == '.' && from[1] == '.' && from[2] == '/')
1307 while (to > base && *to != '/') to--;
1313 else if (from[0] == '.' && from[1] == '.' && from[2] == '\0')
1326 while (to > base && *to != '/') to--;
1333 /* Copy this component and trailing /, if any. */
1334 while ((*to++ = *from++) != '/')
1346 /* Trim trailing slash */
1347 if (to[0] == '/' && (!absolute || to > path+1))
1350 /* Change the empty string to "." so that stat() on the result
1351 will always work. */
1360 /* It is not clear when this should be used if at all, so I've
1361 disabled it until someone who understands VMS can look at it. */
1364 /* Under VMS we need to fix up the "include" specification filename.
1366 Rules for possible conversions
1368 fullname tried paths
1371 ./dir/name [.dir]name
1373 /name [000000]name, name
1374 dir/name dir:[000000]name, dir:name, dir/name
1375 dir1/dir2/name dir1:[dir2]name, dir1:[000000.dir2]name
1376 path:/name path:[000000]name, path:name
1377 path:/dir/name path:[000000.dir]name, path:[dir]name
1378 path:dir/name path:[dir]name
1379 [path]:[dir]name [path.dir]name
1380 path/[dir]name [path.dir]name
1382 The path:/name input is constructed when expanding <> includes. */
1386 hack_vms_include_specification (fullname)
1389 register char *basename, *unixname, *local_ptr, *first_slash;
1390 int f, check_filename_before_returning, must_revert;
1393 check_filename_before_returning = 0;
1395 /* See if we can find a 1st slash. If not, there's no path information. */
1396 first_slash = index (fullname, '/');
1397 if (first_slash == 0)
1398 return 0; /* Nothing to do!!! */
1400 /* construct device spec if none given. */
1402 if (index (fullname, ':') == 0)
1405 /* If fullname has a slash, take it as device spec. */
1407 if (first_slash == fullname)
1409 first_slash = index (fullname+1, '/'); /* 2nd slash ? */
1411 *first_slash = ':'; /* make device spec */
1412 for (basename = fullname; *basename != 0; basename++)
1413 *basename = *(basename+1); /* remove leading slash */
1415 else if ((first_slash[-1] != '.') /* keep ':/', './' */
1416 && (first_slash[-1] != ':')
1417 && (first_slash[-1] != ']')) /* or a vms path */
1421 else if ((first_slash[1] == '[') /* skip './' in './[dir' */
1422 && (first_slash[-1] == '.'))
1426 /* Get part after first ':' (basename[-1] == ':')
1427 or last '/' (basename[-1] == '/'). */
1429 basename = base_name (fullname);
1431 local_ptr = Local; /* initialize */
1433 /* We are trying to do a number of things here. First of all, we are
1434 trying to hammer the filenames into a standard format, such that later
1435 processing can handle them.
1437 If the file name contains something like [dir.], then it recognizes this
1438 as a root, and strips the ".]". Later processing will add whatever is
1439 needed to get things working properly.
1441 If no device is specified, then the first directory name is taken to be
1442 a device name (or a rooted logical). */
1444 /* Point to the UNIX filename part (which needs to be fixed!)
1445 but skip vms path information.
1446 [basename != fullname since first_slash != 0]. */
1448 if ((basename[-1] == ':') /* vms path spec. */
1449 || (basename[-1] == ']')
1450 || (basename[-1] == '>'))
1451 unixname = basename;
1453 unixname = fullname;
1455 if (*unixname == '/')
1458 /* If the directory spec is not rooted, we can just copy
1459 the UNIX filename part and we are done. */
1461 if (((basename - fullname) > 1)
1462 && ( (basename[-1] == ']')
1463 || (basename[-1] == '>')))
1465 if (basename[-2] != '.')
1468 /* The VMS part ends in a `]', and the preceding character is not a `.'.
1469 -> PATH]:/name (basename = '/name', unixname = 'name')
1470 We strip the `]', and then splice the two parts of the name in the
1471 usual way. Given the default locations for include files in cccp.c,
1472 we will only use this code if the user specifies alternate locations
1473 with the /include (-I) switch on the command line. */
1475 basename -= 1; /* Strip "]" */
1476 unixname--; /* backspace */
1481 /* The VMS part has a ".]" at the end, and this will not do. Later
1482 processing will add a second directory spec, and this would be a syntax
1483 error. Thus we strip the ".]", and thus merge the directory specs.
1484 We also backspace unixname, so that it points to a '/'. This inhibits the
1485 generation of the 000000 root directory spec (which does not belong here
1488 basename -= 2; /* Strip ".]" */
1489 unixname--; /* backspace */
1497 /* We drop in here if there is no VMS style directory specification yet.
1498 If there is no device specification either, we make the first dir a
1499 device and try that. If we do not do this, then we will be essentially
1500 searching the users default directory (as if they did a #include "asdf.h").
1502 Then all we need to do is to push a '[' into the output string. Later
1503 processing will fill this in, and close the bracket. */
1505 if ((unixname != fullname) /* vms path spec found. */
1506 && (basename[-1] != ':'))
1507 *local_ptr++ = ':'; /* dev not in spec. take first dir */
1509 *local_ptr++ = '['; /* Open the directory specification */
1512 if (unixname == fullname) /* no vms dir spec. */
1515 if ((first_slash != 0) /* unix dir spec. */
1516 && (*unixname != '/') /* not beginning with '/' */
1517 && (*unixname != '.')) /* or './' or '../' */
1518 *local_ptr++ = '.'; /* dir is local ! */
1521 /* at this point we assume that we have the device spec, and (at least
1522 the opening "[" for a directory specification. We may have directories
1525 If there are no other slashes then the filename will be
1526 in the "root" directory. Otherwise, we need to add
1527 directory specifications. */
1529 if (index (unixname, '/') == 0)
1531 /* if no directories specified yet and none are following. */
1532 if (local_ptr[-1] == '[')
1534 /* Just add "000000]" as the directory string */
1535 strcpy (local_ptr, "000000]");
1536 local_ptr += strlen (local_ptr);
1537 check_filename_before_returning = 1; /* we might need to fool with this later */
1543 /* As long as there are still subdirectories to add, do them. */
1544 while (index (unixname, '/') != 0)
1546 /* If this token is "." we can ignore it
1547 if it's not at the beginning of a path. */
1548 if ((unixname[0] == '.') && (unixname[1] == '/'))
1550 /* remove it at beginning of path. */
1551 if ( ((unixname == fullname) /* no device spec */
1552 && (fullname+2 != basename)) /* starts with ./ */
1554 || ((basename[-1] == ':') /* device spec */
1555 && (unixname-1 == basename))) /* and ./ afterwards */
1556 *local_ptr++ = '.'; /* make '[.' start of path. */
1561 /* Add a subdirectory spec. Do not duplicate "." */
1562 if ( local_ptr[-1] != '.'
1563 && local_ptr[-1] != '['
1564 && local_ptr[-1] != '<')
1567 /* If this is ".." then the spec becomes "-" */
1568 if ( (unixname[0] == '.')
1569 && (unixname[1] == '.')
1570 && (unixname[2] == '/'))
1572 /* Add "-" and skip the ".." */
1573 if ((local_ptr[-1] == '.')
1574 && (local_ptr[-2] == '['))
1575 local_ptr--; /* prevent [.- */
1581 /* Copy the subdirectory */
1582 while (*unixname != '/')
1583 *local_ptr++= *unixname++;
1585 unixname++; /* Skip the "/" */
1588 /* Close the directory specification */
1589 if (local_ptr[-1] == '.') /* no trailing periods */
1592 if (local_ptr[-1] == '[') /* no dir needed */
1598 /* Now add the filename. */
1601 *local_ptr++ = *unixname++;
1604 /* Now append it to the original VMS spec. */
1606 strcpy ((must_revert==1)?fullname:basename, Local);
1608 /* If we put a [000000] in the filename, try to open it first. If this fails,
1609 remove the [000000], and return that name. This provides flexibility
1610 to the user in that they can use both rooted and non-rooted logical names
1611 to point to the location of the file. */
1613 if (check_filename_before_returning)
1615 f = open (fullname, O_RDONLY, 0666);
1618 /* The file name is OK as it is, so return it as is. */
1623 /* The filename did not work. Try to remove the [000000] from the name,
1626 basename = index (fullname, '[');
1627 local_ptr = index (fullname, ']') + 1;
1628 strcpy (basename, local_ptr); /* this gets rid of it */