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 *,
48 static void initialize_input_buffer PROTO ((cpp_reader *, int,
50 static int file_cleanup PROTO ((cpp_buffer *, cpp_reader *));
51 static void find_position PROTO ((U_CHAR *, U_CHAR *,
56 static void hack_vms_include_specification PROTO ((char *));
59 /* Windows does not natively support inodes, and neither does MSDOS.
60 VMS has non-numeric inodes. */
62 #define INO_T_EQ(a, b) (!bcmp((char *) &(a), (char *) &(b), sizeof (a)))
63 #elif (defined _WIN32 && !defined CYGWIN && ! defined (_UWIN)) \
65 #define INO_T_EQ(a, b) 0
67 #define INO_T_EQ(a, b) ((a) == (b))
70 /* Merge the four include chains together in the order quote, bracket,
71 system, after. Remove duplicate dirs (as determined by
72 INO_T_EQ()). The system_include and after_include chains are never
73 referred to again after this function; all access is through the
76 For the future: Check if the directory is empty (but
77 how?) and possibly preload the include hash. */
80 merge_include_chains (opts)
81 struct cpp_options *opts;
83 struct file_name_list *prev, *cur, *other;
84 struct file_name_list *quote, *brack, *systm, *after;
85 struct file_name_list *qtail, *btail, *stail, *atail;
87 qtail = opts->pending->quote_tail;
88 btail = opts->pending->brack_tail;
89 stail = opts->pending->systm_tail;
90 atail = opts->pending->after_tail;
92 quote = opts->pending->quote_head;
93 brack = opts->pending->brack_head;
94 systm = opts->pending->systm_head;
95 after = opts->pending->after_head;
97 /* Paste together bracket, system, and after include chains. */
107 /* This is a bit tricky.
108 First we drop dupes from the quote-include list.
109 Then we drop dupes from the bracket-include list.
110 Finally, if qtail and brack are the same directory,
113 We can't just merge the lists and then uniquify them because
114 then we may lose directories from the <> search path that should
115 be there; consider -Ifoo -Ibar -I- -Ifoo -Iquux. It is however
116 safe to treat -Ibar -Ifoo -I- -Ifoo -Iquux as if written
117 -Ibar -I- -Ifoo -Iquux.
119 Note that this algorithm is quadratic in the number of -I switches,
120 which is acceptable since there aren't usually that many of them. */
122 for (cur = quote, prev = NULL; cur; cur = cur->next)
124 for (other = quote; other != cur; other = other->next)
125 if (INO_T_EQ (cur->ino, other->ino)
126 && cur->dev == other->dev)
129 cpp_notice ("ignoring duplicate directory `%s'\n", cur->name);
131 prev->next = cur->next;
141 for (cur = brack; cur; cur = cur->next)
143 for (other = brack; other != cur; other = other->next)
144 if (INO_T_EQ (cur->ino, other->ino)
145 && cur->dev == other->dev)
148 cpp_notice ("ignoring duplicate directory `%s'\n", cur->name);
150 prev->next = cur->next;
161 if (INO_T_EQ (qtail->ino, brack->ino) && qtail->dev == brack->dev)
166 cpp_notice ("ignoring duplicate directory `%s'\n",
176 while (cur->next != qtail)
180 cpp_notice ("ignoring duplicate directory `%s'\n",
193 opts->quote_include = quote;
194 opts->bracket_include = brack;
197 /* Look up or add an entry to the table of all includes. This table
198 is indexed by the name as it appears in the #include line. The
199 ->next_this_file chain stores all different files with the same
200 #include name (there are at least three ways this can happen). The
201 hash function could probably be improved a bit. */
203 struct include_hash *
204 include_hash (pfile, fname, add)
209 unsigned int hash = 0;
210 struct include_hash *l, *m;
211 const char *f = fname;
216 l = pfile->all_include_files[hash % ALL_INCLUDE_HASHSIZE];
218 for (; l; m = l, l = l->next)
219 if (!strcmp (l->nshort, fname))
225 l = (struct include_hash *) xmalloc (sizeof (struct include_hash));
227 l->next_this_file = NULL;
234 pfile->all_include_files[hash % ALL_INCLUDE_HASHSIZE] = l;
239 /* Return 0 if the file pointed to by IHASH has never been included before,
240 -1 if it has been included before and need not be again,
241 or a pointer to an IHASH entry which is the file to be reread.
242 "Never before" is with respect to the position in ILIST.
244 This will not detect redundancies involving odd uses of the
245 `current directory' rule for "" includes. They aren't quite
246 pathological, but I think they are rare enough not to worry about.
247 The simplest example is:
256 and the problem is that for `current directory' includes,
257 ihash->foundhere is not on any of the global include chains,
258 so the test below (i->foundhere == l) may be false even when
259 the directories are in fact the same. */
261 static struct include_hash *
262 redundant_include_p (pfile, ihash, ilist)
264 struct include_hash *ihash;
265 struct file_name_list *ilist;
267 struct file_name_list *l;
268 struct include_hash *i;
270 if (! ihash->foundhere)
273 for (i = ihash; i; i = i->next_this_file)
274 for (l = ilist; l; l = l->next)
275 if (i->foundhere == l)
276 /* The control_macro works like this: If it's NULL, the file
277 is to be included again. If it's "", the file is never to
278 be included again. If it's a string, the file is not to be
279 included again if the string is the name of a defined macro. */
280 return (i->control_macro
281 && (i->control_macro[0] == '\0'
282 || cpp_lookup (pfile, i->control_macro, -1, -1)))
283 ? (struct include_hash *)-1 : i;
289 file_cleanup (pbuf, pfile)
298 if (pfile->system_include_depth)
299 pfile->system_include_depth--;
303 /* Search for include file FNAME in the include chain starting at
304 SEARCH_START. Return -2 if this file doesn't need to be included
305 (because it was included already and it's marked idempotent),
306 -1 if an error occurred, or a file descriptor open on the file.
307 *IHASH is set to point to the include hash entry for this file, and
308 *BEFORE is 1 if the file was included before (but needs to be read
311 find_include_file (pfile, fname, search_start, ihash, before)
314 struct file_name_list *search_start;
315 struct include_hash **ihash;
318 struct file_name_list *l;
319 struct include_hash *ih, *jh;
323 ih = include_hash (pfile, fname, 1);
324 jh = redundant_include_p (pfile, ih,
325 fname[0] == '/' ? ABSOLUTE_PATH : search_start);
332 if (jh == (struct include_hash *)-1)
335 return open (jh->name, O_RDONLY, 0666);
339 /* A file is already known by this name, but it's not the same file.
340 Allocate another include_hash block and add it to the next_this_file
343 jh = (struct include_hash *)xmalloc (sizeof (struct include_hash));
344 while (ih->next_this_file) ih = ih->next_this_file;
346 ih->next_this_file = jh;
348 ih = ih->next_this_file;
351 ih->next_this_file = NULL;
357 ih->nshort = xstrdup (fname);
358 ih->control_macro = NULL;
360 /* If the pathname is absolute, just open it. */
363 ih->foundhere = ABSOLUTE_PATH;
364 ih->name = ih->nshort;
365 return open (ih->name, O_RDONLY, 0666);
368 /* Search directory path, trying to open the file. */
370 len = strlen (fname);
371 name = xmalloc (len + pfile->max_include_len + 2 + INCLUDE_LEN_FUDGE);
373 for (l = search_start; l; l = l->next)
375 bcopy (l->name, name, l->nlen);
377 strcpy (&name[l->nlen+1], fname);
378 simplify_pathname (name);
379 if (CPP_OPTIONS (pfile)->remap)
380 name = remap_filename (pfile, name, l);
382 f = open (name, O_RDONLY|O_NONBLOCK|O_NOCTTY, 0666);
384 if (f == -1 && errno == EACCES)
386 cpp_error(pfile, "included file `%s' exists but is not readable",
395 ih->name = xrealloc (name, strlen (name)+1);
402 jh->next_this_file = NULL;
406 *ihash = (struct include_hash *)-1;
410 /* The file_name_map structure holds a mapping of file names for a
411 particular directory. This mapping is read from the file named
412 FILE_NAME_MAP_FILE in that directory. Such a file can be used to
413 map filenames on a file system with severe filename restrictions,
414 such as DOS. The format of the file name map file is just a series
415 of lines with two tokens on each line. The first token is the name
416 to map, and the second token is the actual name to use. */
420 struct file_name_map *map_next;
425 #define FILE_NAME_MAP_FILE "header.gcc"
427 /* Read a space delimited string of unlimited length from a stdio
431 read_filename_string (ch, f)
439 set = alloc = xmalloc (len + 1);
443 while ((ch = getc (f)) != EOF && ! is_space[ch])
445 if (set - alloc == len)
448 alloc = xrealloc (alloc, len + 1);
449 set = alloc + len / 2;
459 /* This structure holds a linked list of file name maps, one per directory. */
461 struct file_name_map_list
463 struct file_name_map_list *map_list_next;
465 struct file_name_map *map_list_map;
468 /* Read the file name map file for DIRNAME. */
470 static struct file_name_map *
471 read_name_map (pfile, dirname)
475 register struct file_name_map_list *map_list_ptr;
479 for (map_list_ptr = CPP_OPTIONS (pfile)->map_list; map_list_ptr;
480 map_list_ptr = map_list_ptr->map_list_next)
481 if (! strcmp (map_list_ptr->map_list_name, dirname))
482 return map_list_ptr->map_list_map;
484 map_list_ptr = ((struct file_name_map_list *)
485 xmalloc (sizeof (struct file_name_map_list)));
486 map_list_ptr->map_list_name = xstrdup (dirname);
488 name = (char *) alloca (strlen (dirname) + strlen (FILE_NAME_MAP_FILE) + 2);
489 strcpy (name, dirname);
492 strcat (name, FILE_NAME_MAP_FILE);
493 f = fopen (name, "r");
495 map_list_ptr->map_list_map = (struct file_name_map *)-1;
499 int dirlen = strlen (dirname);
501 while ((ch = getc (f)) != EOF)
504 struct file_name_map *ptr;
508 from = read_filename_string (ch, f);
509 while ((ch = getc (f)) != EOF && is_hor_space[ch])
511 to = read_filename_string (ch, f);
513 ptr = ((struct file_name_map *)
514 xmalloc (sizeof (struct file_name_map)));
515 ptr->map_from = from;
517 /* Make the real filename absolute. */
522 ptr->map_to = xmalloc (dirlen + strlen (to) + 2);
523 strcpy (ptr->map_to, dirname);
524 ptr->map_to[dirlen] = '/';
525 strcpy (ptr->map_to + dirlen + 1, to);
529 ptr->map_next = map_list_ptr->map_list_map;
530 map_list_ptr->map_list_map = ptr;
532 while ((ch = getc (f)) != '\n')
539 map_list_ptr->map_list_next = CPP_OPTIONS (pfile)->map_list;
540 CPP_OPTIONS (pfile)->map_list = map_list_ptr;
542 return map_list_ptr->map_list_map;
545 /* Remap NAME based on the file_name_map (if any) for LOC. */
548 remap_filename (pfile, name, loc)
551 struct file_name_list *loc;
553 struct file_name_map *map;
554 const char *from, *p, *dir;
557 loc->name_map = read_name_map (pfile,
561 if (loc->name_map == (struct file_name_map *)-1)
564 from = name + strlen (loc->name) + 1;
566 for (map = loc->name_map; map; map = map->map_next)
567 if (!strcmp (map->map_from, from))
570 /* Try to find a mapping file for the particular directory we are
571 looking in. Thus #include <sys/types.h> will look up sys/types.h
572 in /usr/include/header.gcc and look up types.h in
573 /usr/include/sys/header.gcc. */
574 p = rindex (name, '/');
578 && strlen (loc->name) == (size_t) (p - name)
579 && !strncmp (loc->name, name, p - name))
580 /* FILENAME is in SEARCHPTR, which we've already checked. */
590 char * newdir = (char *) alloca (p - name + 1);
591 bcopy (name, newdir, p - name);
592 newdir[p - name] = '\0';
597 for (map = read_name_map (pfile, dir); map; map = map->map_next)
598 if (! strcmp (map->map_from, name))
604 /* Read the contents of FD into the buffer on the top of PFILE's stack.
605 IHASH points to the include hash entry for the file associated with
608 The caller is responsible for the cpp_push_buffer. */
611 finclude (pfile, fd, ihash)
614 struct include_hash *ihash;
621 if (fstat (fd, &st) < 0)
623 if (fcntl (fd, F_SETFL, 0) == -1) /* turn off nonblocking mode */
626 fp = CPP_BUFFER (pfile);
628 /* If fd points to a plain file, we know how big it is, so we can
629 allocate the buffer all at once. If fd is a pipe or terminal, we
630 can't. Most C source files are 4k or less, so we guess that. If
631 fd is something weird, like a block device or a directory, we
632 don't want to read it at all.
634 Unfortunately, different systems use different st.st_mode values
635 for pipes: some have S_ISFIFO, some S_ISSOCK, some are buggy and
636 zero the entire struct stat except a couple fields. Hence the
639 In all cases, read_and_prescan will resize the buffer if it
640 turns out there's more data than we thought. */
642 if (S_ISREG (st.st_mode))
644 /* off_t might have a wider range than size_t - in other words,
645 the max size of a file might be bigger than the address
646 space. We can't handle a file that large. (Anyone with
647 a single source file bigger than 4GB needs to rethink
648 their coding style.) */
649 st_size = (size_t) st.st_size;
650 if ((unsigned HOST_WIDEST_INT) st_size
651 != (unsigned HOST_WIDEST_INT) st.st_size)
653 cpp_error (pfile, "file `%s' is too large", ihash->name);
657 else if (S_ISFIFO (st.st_mode) || S_ISSOCK (st.st_mode)
658 /* Permit any kind of character device: the sensible ones are
659 ttys and /dev/null, but weeding out the others is too hard. */
660 || S_ISCHR (st.st_mode)
661 /* Some 4.x (x<4) derivatives have a bug that makes fstat() of a
662 socket or pipe return a stat struct with most fields zeroed. */
663 || (st.st_mode == 0 && st.st_nlink == 0 && st.st_size == 0))
665 /* Cannot get its file size before reading. 4k is a decent
671 cpp_error (pfile, "`%s' is not a file, pipe, or tty", ihash->name);
675 if (pfile->input_buffer == NULL)
676 initialize_input_buffer (pfile, fd, &st);
678 /* Read the file, converting end-of-line characters and trigraphs
681 fp->nominal_fname = fp->fname = ihash->name;
682 length = read_and_prescan (pfile, fp, fd, st_size);
686 ihash->control_macro = ""; /* never re-include */
689 fp->rlimit = fp->alimit = fp->buf + length;
691 if (ihash->foundhere != ABSOLUTE_PATH)
692 fp->system_header_p = ihash->foundhere->sysp;
695 fp->line_base = fp->buf;
696 fp->cleanup = file_cleanup;
698 /* The ->actual_dir field is only used when ignore_srcdir is not in effect;
700 if (!CPP_OPTIONS (pfile)->ignore_srcdir)
701 fp->actual_dir = actual_directory (pfile, fp->fname);
703 pfile->input_stack_listing_current = 0;
707 cpp_error_from_errno (pfile, ihash->name);
709 cpp_pop_buffer (pfile);
714 /* Given a path FNAME, extract the directory component and place it
715 onto the actual_dirs list. Return a pointer to the allocated
716 file_name_list structure. These structures are used to implement
717 current-directory "" include searching. */
719 static struct file_name_list *
720 actual_directory (pfile, fname)
724 char *last_slash, *dir;
726 struct file_name_list *x;
728 dir = xstrdup (fname);
729 last_slash = rindex (dir, '/');
732 if (last_slash == dir)
735 last_slash[1] = '\0';
739 dlen = last_slash - dir;
750 if (dlen > pfile->max_include_len)
751 pfile->max_include_len = dlen;
753 for (x = pfile->actual_dirs; x; x = x->alloc)
754 if (!strcmp (x->name, dir))
760 /* Not found, make a new one. */
761 x = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
764 x->next = CPP_OPTIONS (pfile)->quote_include;
765 x->alloc = pfile->actual_dirs;
766 x->sysp = CPP_BUFFER (pfile)->system_header_p;
769 pfile->actual_dirs = x;
773 /* Determine the current line and column. Used only by read_and_prescan. */
775 find_position (start, limit, linep, colp)
778 unsigned long *linep;
781 unsigned long line = *linep, col = 0;
782 while (start < limit)
784 U_CHAR ch = *start++;
785 if (ch == '\n' || ch == '\r')
790 *linep = line, *colp = col;
793 /* Read the entire contents of file DESC into buffer BUF. LEN is how
794 much memory to allocate initially; more will be allocated if
795 necessary. Convert end-of-line markers (\n, \r, \r\n, \n\r) to
796 canonical form (\n). If enabled, convert and/or warn about
797 trigraphs. Convert backslash-newline to a one-character escape
798 (\r) and remove it from "embarrassing" places (i.e. the middle of a
799 token). If there is no newline at the end of the file, add one and
800 warn. Returns -1 on failure, or the actual length of the data to
803 This function does a lot of work, and can be a serious performance
804 bottleneck. It has been tuned heavily; make sure you understand it
805 before hacking. The common case - no trigraphs, Unix style line
806 breaks, backslash-newline set off by whitespace, newline at EOF -
807 has been optimized at the expense of the others. The performance
808 penalty for DOS style line breaks (\r\n) is about 15%.
810 Warnings lose particularly heavily since we have to determine the
811 line number, which involves scanning from the beginning of the file
812 or from the last warning. The penalty for the absence of a newline
813 at the end of reload1.c is about 60%. (reload1.c is 329k.)
815 If your file has more than one kind of end-of-line marker, you
816 will get messed-up line numbering. */
818 /* Table of characters that can't be handled in the inner loop.
819 Keep these contiguous to optimize the performance of the code generated
820 for the switch that uses them. */
821 #define SPECCASE_EMPTY 0
822 #define SPECCASE_NUL 1
823 #define SPECCASE_CR 2
824 #define SPECCASE_BACKSLASH 3
825 #define SPECCASE_QUESTION 4
828 read_and_prescan (pfile, fp, desc, len)
834 U_CHAR *buf = (U_CHAR *) xmalloc (len);
835 U_CHAR *ip, *op, *line_base;
837 U_CHAR *speccase = pfile->input_speccase;
839 unsigned int deferred_newlines;
847 ibase = pfile->input_buffer + 2;
848 deferred_newlines = 0;
854 count = read (desc, pfile->input_buffer + 2, pfile->input_buffer_len);
862 ibase = pfile->input_buffer + 2;
863 ibase[count] = ibase[count+1] = '\0';
868 size_t delta_line_base;
872 This could happen if the file is larger than half the
873 maximum address space of the machine. */
877 delta_line_base = line_base - buf;
878 buf = (U_CHAR *) xrealloc (buf, len);
880 line_base = buf + delta_line_base;
885 unsigned int span = 0;
887 /* Deal with \-newline in the middle of a token. */
888 if (deferred_newlines)
890 while (speccase[ip[span]] == SPECCASE_EMPTY
895 memcpy (op, ip, span);
898 if (*ip == '\n' || *ip == '\t'
899 || *ip == ' ' || *ip == ' ')
900 while (deferred_newlines)
901 deferred_newlines--, *op++ = '\r';
905 /* Copy as much as we can without special treatment. */
906 while (speccase[ip[span]] == SPECCASE_EMPTY) span++;
907 memcpy (op, ip, span);
911 switch (speccase[*ip++])
913 case SPECCASE_NUL: /* \0 */
917 case SPECCASE_CR: /* \r */
920 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. */
941 else if (*ip == '\n')
944 if (*ip == '\r') ip++;
945 if (*ip == '\n' || *ip == '\t' || *ip == ' ')
947 else if (op[-1] == '\t' || op[-1] == ' '
948 || op[-1] == '\r' || op[-1] == '\n')
955 else if (*ip == '\r')
958 if (*ip == '\n') ip++;
959 else if (*ip == '\0')
965 else if (*ip == '\r' || *ip == '\t' || *ip == ' ')
977 case SPECCASE_QUESTION: /* ? */
980 /* If we're at the end of the intermediate buffer,
981 we have to shift the ?'s down to the start and
982 come back next pass. */
1001 if (!trigraph_table[d])
1007 if (CPP_OPTIONS (pfile)->warn_trigraphs)
1010 find_position (line_base, op, &line, &col);
1011 line_base = op - col;
1012 cpp_warning_with_line (pfile, line, col,
1013 "trigraph ??%c encountered", d);
1015 if (CPP_OPTIONS (pfile)->trigraphs)
1017 if (trigraph_table[d] == '\\')
1020 *op++ = trigraph_table[d];
1037 /* Deal with pushed-back chars at true EOF.
1038 This may be any of: ?? ? \ \r \n \\r \\n.
1039 \r must become \n, \\r or \\n must become \r.
1040 We know we have space already. */
1041 if (ibase == pfile->input_buffer)
1051 else if (ibase == pfile->input_buffer + 1)
1062 find_position (line_base, op, &line, &col);
1063 cpp_warning_with_line (pfile, line, col, "no newline at end of file\n");
1064 if (offset + 1 > len)
1067 if (offset + 1 > len)
1069 buf = (U_CHAR *) xrealloc (buf, len);
1075 fp->buf = ((len - offset < 20) ? buf : (U_CHAR *)xrealloc (buf, op - buf));
1079 cpp_error (pfile, "file is too large (>%lu bytes)\n", (unsigned long)offset);
1084 cpp_error_from_errno (pfile, fp->fname);
1089 /* Initialize the `input_buffer' and `input_speccase' tables.
1090 These are only used by read_and_prescan, but they're large and
1091 somewhat expensive to set up, so we want them allocated once for
1092 the duration of the cpp run. */
1095 initialize_input_buffer (pfile, fd, st)
1103 /* Table of characters that cannot be handled by the
1104 read_and_prescan inner loop. The number of non-EMPTY entries
1105 should be as small as humanly possible. */
1107 tmp = (U_CHAR *) xmalloc (1 << CHAR_BIT);
1108 memset (tmp, SPECCASE_EMPTY, 1 << CHAR_BIT);
1109 tmp['\0'] = SPECCASE_NUL;
1110 tmp['\r'] = SPECCASE_CR;
1111 tmp['\\'] = SPECCASE_BACKSLASH;
1112 if (CPP_OPTIONS (pfile)->trigraphs || CPP_OPTIONS (pfile)->warn_trigraphs)
1113 tmp['?'] = SPECCASE_QUESTION;
1115 pfile->input_speccase = tmp;
1117 /* Determine the appropriate size for the input buffer. Normal C
1118 source files are smaller than eight K. If we are reading a pipe,
1119 we want to make sure the input buffer is bigger than the kernel's
1123 if (! S_ISREG (st->st_mode))
1126 pipe_buf = fpathconf (fd, _PC_PIPE_BUF);
1131 pipe_buf = PIPE_BUF;
1138 if (pipe_buf < 8192)
1140 /* PIPE_BUF bytes of buffer proper, 2 to detect running off the end
1141 without address arithmetic all the time, and 2 for pushback in
1142 the case there's a potential trigraph or end-of-line digraph at
1143 the end of a block. */
1145 tmp = (U_CHAR *) xmalloc (pipe_buf + 2 + 2);
1146 pfile->input_buffer = tmp;
1147 pfile->input_buffer_len = pipe_buf;
1150 /* Add output to `deps_buffer' for the -M switch.
1151 STRING points to the text to be output.
1152 SPACER is ':' for targets, ' ' for dependencies, zero for text
1153 to be inserted literally. */
1156 deps_output (pfile, string, spacer)
1167 size = strlen (string);
1169 #ifndef MAX_OUTPUT_COLUMNS
1170 #define MAX_OUTPUT_COLUMNS 72
1172 if (pfile->deps_column > 0
1173 && (pfile->deps_column + size) > MAX_OUTPUT_COLUMNS)
1176 pfile->deps_column = 0;
1179 if (pfile->deps_size + size + cr + 8 > pfile->deps_allocated_size)
1181 pfile->deps_allocated_size = (pfile->deps_size + size + 50) * 2;
1182 pfile->deps_buffer = (char *) xrealloc (pfile->deps_buffer,
1183 pfile->deps_allocated_size);
1188 bcopy (" \\\n ", &pfile->deps_buffer[pfile->deps_size], 5);
1189 pfile->deps_size += 5;
1192 if (spacer == ' ' && pfile->deps_column > 0)
1193 pfile->deps_buffer[pfile->deps_size++] = ' ';
1194 bcopy (string, &pfile->deps_buffer[pfile->deps_size], size);
1195 pfile->deps_size += size;
1196 pfile->deps_column += size;
1198 pfile->deps_buffer[pfile->deps_size++] = ':';
1199 pfile->deps_buffer[pfile->deps_size] = 0;
1202 /* Simplify a path name in place, deleting redundant components. This
1203 reduces OS overhead and guarantees that equivalent paths compare
1204 the same (modulo symlinks).
1207 foo/bar/../quux foo/quux
1211 //quux //quux (POSIX allows leading // as a namespace escape)
1213 Guarantees no trailing slashes. All transforms reduce the length
1217 simplify_pathname (path)
1224 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
1225 /* Convert all backslashes to slashes. */
1226 for (from = path; *from; from++)
1227 if (*from == '\\') *from = '/';
1229 /* Skip over leading drive letter if present. */
1230 if (ISALPHA (path[0]) && path[1] == ':')
1231 from = to = &path[2];
1238 /* Remove redundant initial /s. */
1247 /* 3 or more initial /s are equivalent to 1 /. */
1248 while (*++from == '/');
1250 /* On some hosts // differs from /; Posix allows this. */
1258 while (*from == '/')
1261 if (from[0] == '.' && from[1] == '/')
1263 else if (from[0] == '.' && from[1] == '\0')
1265 else if (from[0] == '.' && from[1] == '.' && from[2] == '/')
1282 while (to > base && *to != '/') to--;
1288 else if (from[0] == '.' && from[1] == '.' && from[2] == '\0')
1301 while (to > base && *to != '/') to--;
1308 /* Copy this component and trailing /, if any. */
1309 while ((*to++ = *from++) != '/')
1321 /* Trim trailing slash */
1322 if (to[0] == '/' && (!absolute || to > path+1))
1325 /* Change the empty string to "." so that stat() on the result
1326 will always work. */
1335 /* It is not clear when this should be used if at all, so I've
1336 disabled it until someone who understands VMS can look at it. */
1339 /* Under VMS we need to fix up the "include" specification filename.
1341 Rules for possible conversions
1343 fullname tried paths
1346 ./dir/name [.dir]name
1348 /name [000000]name, name
1349 dir/name dir:[000000]name, dir:name, dir/name
1350 dir1/dir2/name dir1:[dir2]name, dir1:[000000.dir2]name
1351 path:/name path:[000000]name, path:name
1352 path:/dir/name path:[000000.dir]name, path:[dir]name
1353 path:dir/name path:[dir]name
1354 [path]:[dir]name [path.dir]name
1355 path/[dir]name [path.dir]name
1357 The path:/name input is constructed when expanding <> includes. */
1361 hack_vms_include_specification (fullname)
1364 register char *basename, *unixname, *local_ptr, *first_slash;
1365 int f, check_filename_before_returning, must_revert;
1368 check_filename_before_returning = 0;
1370 /* See if we can find a 1st slash. If not, there's no path information. */
1371 first_slash = index (fullname, '/');
1372 if (first_slash == 0)
1373 return 0; /* Nothing to do!!! */
1375 /* construct device spec if none given. */
1377 if (index (fullname, ':') == 0)
1380 /* If fullname has a slash, take it as device spec. */
1382 if (first_slash == fullname)
1384 first_slash = index (fullname+1, '/'); /* 2nd slash ? */
1386 *first_slash = ':'; /* make device spec */
1387 for (basename = fullname; *basename != 0; basename++)
1388 *basename = *(basename+1); /* remove leading slash */
1390 else if ((first_slash[-1] != '.') /* keep ':/', './' */
1391 && (first_slash[-1] != ':')
1392 && (first_slash[-1] != ']')) /* or a vms path */
1396 else if ((first_slash[1] == '[') /* skip './' in './[dir' */
1397 && (first_slash[-1] == '.'))
1401 /* Get part after first ':' (basename[-1] == ':')
1402 or last '/' (basename[-1] == '/'). */
1404 basename = base_name (fullname);
1406 local_ptr = Local; /* initialize */
1408 /* We are trying to do a number of things here. First of all, we are
1409 trying to hammer the filenames into a standard format, such that later
1410 processing can handle them.
1412 If the file name contains something like [dir.], then it recognizes this
1413 as a root, and strips the ".]". Later processing will add whatever is
1414 needed to get things working properly.
1416 If no device is specified, then the first directory name is taken to be
1417 a device name (or a rooted logical). */
1419 /* Point to the UNIX filename part (which needs to be fixed!)
1420 but skip vms path information.
1421 [basename != fullname since first_slash != 0]. */
1423 if ((basename[-1] == ':') /* vms path spec. */
1424 || (basename[-1] == ']')
1425 || (basename[-1] == '>'))
1426 unixname = basename;
1428 unixname = fullname;
1430 if (*unixname == '/')
1433 /* If the directory spec is not rooted, we can just copy
1434 the UNIX filename part and we are done. */
1436 if (((basename - fullname) > 1)
1437 && ( (basename[-1] == ']')
1438 || (basename[-1] == '>')))
1440 if (basename[-2] != '.')
1443 /* The VMS part ends in a `]', and the preceding character is not a `.'.
1444 -> PATH]:/name (basename = '/name', unixname = 'name')
1445 We strip the `]', and then splice the two parts of the name in the
1446 usual way. Given the default locations for include files in cccp.c,
1447 we will only use this code if the user specifies alternate locations
1448 with the /include (-I) switch on the command line. */
1450 basename -= 1; /* Strip "]" */
1451 unixname--; /* backspace */
1456 /* The VMS part has a ".]" at the end, and this will not do. Later
1457 processing will add a second directory spec, and this would be a syntax
1458 error. Thus we strip the ".]", and thus merge the directory specs.
1459 We also backspace unixname, so that it points to a '/'. This inhibits the
1460 generation of the 000000 root directory spec (which does not belong here
1463 basename -= 2; /* Strip ".]" */
1464 unixname--; /* backspace */
1472 /* We drop in here if there is no VMS style directory specification yet.
1473 If there is no device specification either, we make the first dir a
1474 device and try that. If we do not do this, then we will be essentially
1475 searching the users default directory (as if they did a #include "asdf.h").
1477 Then all we need to do is to push a '[' into the output string. Later
1478 processing will fill this in, and close the bracket. */
1480 if ((unixname != fullname) /* vms path spec found. */
1481 && (basename[-1] != ':'))
1482 *local_ptr++ = ':'; /* dev not in spec. take first dir */
1484 *local_ptr++ = '['; /* Open the directory specification */
1487 if (unixname == fullname) /* no vms dir spec. */
1490 if ((first_slash != 0) /* unix dir spec. */
1491 && (*unixname != '/') /* not beginning with '/' */
1492 && (*unixname != '.')) /* or './' or '../' */
1493 *local_ptr++ = '.'; /* dir is local ! */
1496 /* at this point we assume that we have the device spec, and (at least
1497 the opening "[" for a directory specification. We may have directories
1500 If there are no other slashes then the filename will be
1501 in the "root" directory. Otherwise, we need to add
1502 directory specifications. */
1504 if (index (unixname, '/') == 0)
1506 /* if no directories specified yet and none are following. */
1507 if (local_ptr[-1] == '[')
1509 /* Just add "000000]" as the directory string */
1510 strcpy (local_ptr, "000000]");
1511 local_ptr += strlen (local_ptr);
1512 check_filename_before_returning = 1; /* we might need to fool with this later */
1518 /* As long as there are still subdirectories to add, do them. */
1519 while (index (unixname, '/') != 0)
1521 /* If this token is "." we can ignore it
1522 if it's not at the beginning of a path. */
1523 if ((unixname[0] == '.') && (unixname[1] == '/'))
1525 /* remove it at beginning of path. */
1526 if ( ((unixname == fullname) /* no device spec */
1527 && (fullname+2 != basename)) /* starts with ./ */
1529 || ((basename[-1] == ':') /* device spec */
1530 && (unixname-1 == basename))) /* and ./ afterwards */
1531 *local_ptr++ = '.'; /* make '[.' start of path. */
1536 /* Add a subdirectory spec. Do not duplicate "." */
1537 if ( local_ptr[-1] != '.'
1538 && local_ptr[-1] != '['
1539 && local_ptr[-1] != '<')
1542 /* If this is ".." then the spec becomes "-" */
1543 if ( (unixname[0] == '.')
1544 && (unixname[1] == '.')
1545 && (unixname[2] == '/'))
1547 /* Add "-" and skip the ".." */
1548 if ((local_ptr[-1] == '.')
1549 && (local_ptr[-2] == '['))
1550 local_ptr--; /* prevent [.- */
1556 /* Copy the subdirectory */
1557 while (*unixname != '/')
1558 *local_ptr++= *unixname++;
1560 unixname++; /* Skip the "/" */
1563 /* Close the directory specification */
1564 if (local_ptr[-1] == '.') /* no trailing periods */
1567 if (local_ptr[-1] == '[') /* no dir needed */
1573 /* Now add the filename. */
1576 *local_ptr++ = *unixname++;
1579 /* Now append it to the original VMS spec. */
1581 strcpy ((must_revert==1)?fullname:basename, Local);
1583 /* If we put a [000000] in the filename, try to open it first. If this fails,
1584 remove the [000000], and return that name. This provides flexibility
1585 to the user in that they can use both rooted and non-rooted logical names
1586 to point to the location of the file. */
1588 if (check_filename_before_returning)
1590 f = open (fullname, O_RDONLY, 0666);
1593 /* The file name is OK as it is, so return it as is. */
1598 /* The filename did not work. Try to remove the [000000] from the name,
1601 basename = index (fullname, '[');
1602 local_ptr = index (fullname, ']') + 1;
1603 strcpy (basename, local_ptr); /* this gets rid of it */