1 /* Reading and parsing of makefiles for GNU Make.
2 Copyright (C) 1988,89,90,91,92,93,94,95,96 Free Software Foundation, Inc.
3 This file is part of GNU Make.
5 GNU Make is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2, or (at your option)
10 GNU Make is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GNU Make; see the file COPYING. If not, write to
17 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
26 /* This is POSIX.2, but most systems using -DPOSIX probably don't have it. */
30 #include "glob/glob.h"
38 struct passwd
*getpwnam
PARAMS ((char *name
));
43 /* A `struct linebuffer' is a structure which holds a line of text.
44 `readline' reads a line from a stream into a linebuffer
45 and works regardless of the length of the line. */
49 /* Note: This is the number of bytes malloc'ed for `buffer'
50 It does not indicate `buffer's real length.
51 Instead, a null char indicates end-of-string. */
56 #define initbuffer(lb) (lb)->buffer = (char *) xmalloc ((lb)->size = 200)
57 #define freebuffer(lb) free ((lb)->buffer)
60 /* A `struct conditionals' contains the information describing
61 all the active conditionals in a makefile.
63 The global variable `conditionals' contains the conditionals
64 information for the current makefile. It is initialized from
65 the static structure `toplevel_conditionals' and is later changed
66 to new structures for included makefiles. */
70 unsigned int if_cmds
; /* Depth of conditional nesting. */
71 unsigned int allocated
; /* Elts allocated in following arrays. */
72 char *ignoring
; /* Are we ignoring or interepreting? */
73 char *seen_else
; /* Have we already seen an `else'? */
76 static struct conditionals toplevel_conditionals
;
77 static struct conditionals
*conditionals
= &toplevel_conditionals
;
80 /* Default directories to search for include files in */
82 static char *default_include_directories
[] =
84 #if defined(WIN32) && !defined(INCLUDEDIR)
86 * This completly up to the user when they install MSVC or other packages.
87 * This is defined as a placeholder.
89 #define INCLUDEDIR "."
100 /* List of directories to search for include files in */
102 static char **include_directories
;
104 /* Maximum length of an element of the above. */
106 static unsigned int max_incl_len
;
108 /* The filename and pointer to line number of the
109 makefile currently being read in. */
111 char *reading_filename
;
112 unsigned int *reading_lineno_ptr
;
114 /* The chain of makefiles read by read_makefile. */
116 static struct dep
*read_makefiles
= 0;
118 static int read_makefile
PARAMS ((char *filename
, int flags
));
119 static unsigned int readline
PARAMS ((struct linebuffer
*linebuffer
, FILE *stream
,
120 char *filename
, unsigned int lineno
));
121 static unsigned int do_define
PARAMS ((char *name
, unsigned int namelen
, enum variable_origin origin
,
122 unsigned int lineno
, FILE *infile
, char *filename
));
123 static int conditional_line
PARAMS ((char *line
, char *filename
, unsigned int lineno
));
124 static void record_files
PARAMS ((struct nameseq
*filenames
, char *pattern
, char *pattern_percent
,
125 struct dep
*deps
, unsigned int commands_started
, char *commands
,
126 unsigned int commands_idx
, int two_colon
, char *filename
,
127 unsigned int lineno
, int set_default
));
129 /* Read in all the makefiles and return the chain of their names. */
132 read_all_makefiles (makefiles
)
135 unsigned int num_makefiles
= 0;
138 puts ("Reading makefiles...");
140 /* If there's a non-null variable MAKEFILES, its value is a list of
141 files to read first thing. But don't let it prevent reading the
142 default makefiles and don't let the default goal come from there. */
150 /* Turn off --warn-undefined-variables while we expand MAKEFILES. */
151 int save
= warn_undefined_variables_flag
;
152 warn_undefined_variables_flag
= 0;
154 value
= allocated_variable_expand ("$(MAKEFILES)");
156 warn_undefined_variables_flag
= save
;
159 /* Set NAME to the start of next token and LENGTH to its length.
160 MAKEFILES is updated for finding remaining tokens. */
163 while ((name
= find_next_token (&p
, &length
)) != 0)
167 (void) read_makefile (name
,
168 RM_NO_DEFAULT_GOAL
| RM_INCLUDED
| RM_DONTCARE
);
174 /* Read makefiles specified with -f switches. */
177 while (*makefiles
!= 0)
179 struct dep
*tail
= read_makefiles
;
180 register struct dep
*d
;
182 if (! read_makefile (*makefiles
, 0))
183 perror_with_name ("", *makefiles
);
185 /* Find the right element of read_makefiles. */
187 while (d
->next
!= tail
)
190 /* Use the storage read_makefile allocates. */
191 *makefiles
= dep_name (d
);
196 /* If there were no -f switches, try the default names. */
198 if (num_makefiles
== 0)
200 static char *default_makefiles
[] =
202 /* all lower case since readdir() (the vms version) 'lowercasifies' */
203 { "makefile.vms", "gnumakefile", "makefile", 0 };
206 { "GNUmakefile", "Makefile", "SMakefile", 0 };
207 #else /* !Amiga && !VMS */
208 { "GNUmakefile", "makefile", "Makefile", 0 };
211 register char **p
= default_makefiles
;
212 while (*p
!= 0 && !file_exists_p (*p
))
217 if (! read_makefile (*p
, 0))
218 perror_with_name ("", *p
);
222 /* No default makefile was found. Add the default makefiles to the
223 `read_makefiles' chain so they will be updated if possible. */
224 struct dep
*tail
= read_makefiles
;
225 /* Add them to the tail, after any MAKEFILES variable makefiles. */
226 while (tail
!= 0 && tail
->next
!= 0)
228 for (p
= default_makefiles
; *p
!= 0; ++p
)
230 struct dep
*d
= (struct dep
*) xmalloc (sizeof (struct dep
));
232 d
->file
= enter_file (*p
);
233 d
->file
->dontcare
= 1;
234 /* Tell update_goal_chain to bail out as soon as this file is
235 made, and main not to die if we can't make this file. */
236 d
->changed
= RM_DONTCARE
;
248 return read_makefiles
;
251 /* Read file FILENAME as a makefile and add its contents to the data base.
253 FLAGS contains bits as above.
255 FILENAME is added to the `read_makefiles' chain.
257 Returns 1 if a file was found and read, 0 if not. */
260 read_makefile (filename
, flags
)
264 static char *collapsed
= 0;
265 static unsigned int collapsed_length
= 0;
266 register FILE *infile
;
267 struct linebuffer lb
;
268 unsigned int commands_len
= 200;
269 char *commands
= (char *) xmalloc (200);
270 unsigned int commands_idx
= 0;
271 unsigned int commands_started
;
274 int ignoring
= 0, in_ignored_define
= 0;
275 int no_targets
= 0; /* Set when reading a rule without targets. */
276 char *passed_filename
= filename
;
278 struct nameseq
*filenames
= 0;
280 unsigned int lineno
= 1;
281 unsigned int nlines
= 0;
283 char *pattern
= 0, *pattern_percent
;
290 #define record_waiting_files() \
293 if (filenames != 0) \
294 record_files (filenames, pattern, pattern_percent, deps, \
295 commands_started, commands, commands_idx, \
296 two_colon, filename, lineno, \
297 !(flags & RM_NO_DEFAULT_GOAL)); \
303 #ifdef lint /* Suppress `used before set' messages. */
310 printf ("Reading makefile `%s'", filename
);
311 if (flags
& RM_NO_DEFAULT_GOAL
)
312 printf (" (no default goal)");
313 if (flags
& RM_INCLUDED
)
314 printf (" (search path)");
315 if (flags
& RM_DONTCARE
)
316 printf (" (don't care)");
317 if (flags
& RM_NO_TILDE
)
318 printf (" (no ~ expansion)");
322 /* First, get a stream to read. */
324 /* Expand ~ in FILENAME unless it came from `include',
325 in which case it was already done. */
326 if (!(flags
& RM_NO_TILDE
) && filename
[0] == '~')
328 char *expanded
= tilde_expand (filename
);
333 infile
= fopen (filename
, "r");
334 /* Save the error code so we print the right message later. */
335 makefile_errno
= errno
;
337 /* If the makefile wasn't found and it's either a makefile from
338 the `MAKEFILES' variable or an included makefile,
339 search the included makefile search path for this makefile. */
340 if (infile
== 0 && (flags
& RM_INCLUDED
) && *filename
!= '/')
342 register unsigned int i
;
343 for (i
= 0; include_directories
[i
] != 0; ++i
)
345 char *name
= concat (include_directories
[i
], "/", filename
);
346 infile
= fopen (name
, "r");
357 /* Add FILENAME to the chain of read makefiles. */
358 deps
= (struct dep
*) xmalloc (sizeof (struct dep
));
359 deps
->next
= read_makefiles
;
360 read_makefiles
= deps
;
362 deps
->file
= lookup_file (filename
);
365 deps
->file
= enter_file (savestring (filename
, strlen (filename
)));
366 if (flags
& RM_DONTCARE
)
367 deps
->file
->dontcare
= 1;
369 if (filename
!= passed_filename
)
371 filename
= deps
->file
->name
;
372 deps
->changed
= flags
;
375 /* If the makefile can't be found at all, give up entirely. */
379 /* If we did some searching, errno has the error from the last
380 attempt, rather from FILENAME itself. Restore it in case the
381 caller wants to use it in a message. */
382 errno
= makefile_errno
;
386 reading_filename
= filename
;
387 reading_lineno_ptr
= &lineno
;
389 /* Loop over lines in the file.
390 The strategy is to accumulate target names in FILENAMES, dependencies
391 in DEPS and commands in COMMANDS. These are used to define a rule
392 when the start of the next rule (or eof) is encountered. */
396 while (!feof (infile
))
399 nlines
= readline (&lb
, infile
, filename
, lineno
);
401 /* Check for a shell command line first.
402 If it is not one, we can stop treating tab specially. */
403 if (lb
.buffer
[0] == '\t')
405 /* This line is a probably shell command. */
409 /* Ignore the commands in a rule with no targets. */
412 /* If there is no preceding rule line, don't treat this line
413 as a command, even though it begins with a tab character.
414 SunOS 4 make appears to behave this way. */
419 /* Yep, this is a shell command, and we don't care. */
422 /* Append this command line to the line being accumulated. */
424 if (commands_idx
== 0)
425 commands_started
= lineno
;
427 if (len
+ 1 + commands_idx
> commands_len
)
429 commands_len
= (len
+ 1 + commands_idx
) * 2;
430 commands
= (char *) xrealloc (commands
, commands_len
);
432 bcopy (p
, &commands
[commands_idx
], len
);
434 commands
[commands_idx
++] = '\n';
440 /* This line is not a shell command line. Don't worry about tabs. */
442 if (collapsed_length
< lb
.size
)
444 collapsed_length
= lb
.size
;
447 collapsed
= (char *) xmalloc (collapsed_length
);
449 strcpy (collapsed
, lb
.buffer
);
450 /* Collapse continuation lines. */
451 collapse_continuations (collapsed
);
452 remove_comments (collapsed
);
454 /* strncmp is first to avoid dereferencing out into space. */
455 #define word1eq(s, l) (!strncmp (s, p, l) \
456 && (p[l] == '\0' || isblank (p[l])))
461 /* This line is completely empty. */
464 /* We must first check for conditional and `define' directives before
465 ignoring anything, since they control what we will do with
468 if (!in_ignored_define
469 && (word1eq ("ifdef", 5) || word1eq ("ifndef", 6)
470 || word1eq ("ifeq", 4) || word1eq ("ifneq", 5)
471 || word1eq ("else", 4) || word1eq ("endif", 5)))
473 int i
= conditional_line (p
, filename
, lineno
);
477 makefile_fatal (filename
, lineno
,
478 "invalid syntax in conditional");
481 else if (word1eq ("endef", 5))
483 if (in_ignored_define
)
484 in_ignored_define
= 0;
486 makefile_fatal (filename
, lineno
, "extraneous `endef'");
489 else if (word1eq ("define", 6))
492 in_ignored_define
= 1;
495 p2
= next_token (p
+ 6);
496 /* Let the variable name be the whole rest of the line,
497 with trailing blanks stripped (comments have already been
498 removed), so it could be a complex variable/function
499 reference that might contain blanks. */
500 p
= index (p2
, '\0');
501 while (isblank (p
[-1]))
503 lineno
= do_define (p2
, p
- p2
, o_file
,
504 lineno
, infile
, filename
);
508 else if (word1eq ("override", 8))
510 p2
= next_token (p
+ 8);
512 makefile_error (filename
, lineno
, "empty `override' directive");
513 if (!strncmp (p2
, "define", 6) && (isblank (p2
[6]) || p2
[6] == '\0'))
516 in_ignored_define
= 1;
519 p2
= next_token (p2
+ 6);
520 /* Let the variable name be the whole rest of the line,
521 with trailing blanks stripped (comments have already been
522 removed), so it could be a complex variable/function
523 reference that might contain blanks. */
524 p
= index (p2
, '\0');
525 while (isblank (p
[-1]))
527 lineno
= do_define (p2
, p
- p2
, o_override
,
528 lineno
, infile
, filename
);
532 && !try_variable_definition (filename
, lineno
,
534 makefile_error (filename
, lineno
, "empty `override' directive");
540 /* Ignore the line. We continue here so conditionals
541 can appear in the middle of a rule. */
543 else if (word1eq ("export", 6))
546 p2
= next_token (p
+ 6);
548 export_all_variables
= 1;
549 v
= try_variable_definition (filename
, lineno
, p2
, o_file
);
551 v
->export
= v_export
;
555 for (p
= find_next_token (&p2
, &len
); p
!= 0;
556 p
= find_next_token (&p2
, &len
))
558 v
= lookup_variable (p
, len
);
560 v
= define_variable (p
, len
, "", o_file
, 0);
561 v
->export
= v_export
;
565 else if (word1eq ("unexport", 8))
569 p2
= next_token (p
+ 8);
571 export_all_variables
= 0;
572 for (p
= find_next_token (&p2
, &len
); p
!= 0;
573 p
= find_next_token (&p2
, &len
))
575 v
= lookup_variable (p
, len
);
577 v
= define_variable (p
, len
, "", o_file
, 0);
578 v
->export
= v_noexport
;
581 else if (word1eq ("include", 7) || word1eq ("-include", 8)
582 || word1eq ("sinclude", 8))
584 /* We have found an `include' line specifying a nested
585 makefile to be read at this point. */
586 struct conditionals
*save
, new_conditionals
;
587 struct nameseq
*files
;
588 /* "-include" (vs "include") says no error if the file does not
589 exist. "sinclude" is an alias for this from SGI. */
590 int noerror
= p
[0] != 'i';
592 p
= allocated_variable_expand (next_token (p
+ (noerror
? 9 : 8)));
595 makefile_error (filename
, lineno
,
596 "no file name for `%sinclude'",
601 /* Parse the list of file names. */
603 files
= multi_glob (parse_file_seq (&p2
, '\0',
604 sizeof (struct nameseq
),
606 sizeof (struct nameseq
));
609 /* Save the state of conditionals and start
610 the included makefile with a clean slate. */
612 bzero ((char *) &new_conditionals
, sizeof new_conditionals
);
613 conditionals
= &new_conditionals
;
615 /* Record the rules that are waiting so they will determine
616 the default goal before those in the included makefile. */
617 record_waiting_files ();
619 /* Read each included makefile. */
622 struct nameseq
*next
= files
->next
;
623 char *name
= files
->name
;
624 free ((char *)files
);
627 if (! read_makefile (name
, (RM_INCLUDED
| RM_NO_TILDE
628 | (noerror
? RM_DONTCARE
: 0)))
630 makefile_error (filename
, lineno
,
631 "%s: %s", name
, strerror (errno
));
634 /* Free any space allocated by conditional_line. */
635 if (conditionals
->ignoring
)
636 free (conditionals
->ignoring
);
637 if (conditionals
->seen_else
)
638 free (conditionals
->seen_else
);
642 reading_filename
= filename
;
643 reading_lineno_ptr
= &lineno
;
645 else if (word1eq ("vpath", 5))
649 p2
= variable_expand (p
+ 5);
650 p
= find_next_token (&p2
, &len
);
653 pattern
= savestring (p
, len
);
654 p
= find_next_token (&p2
, &len
);
655 /* No searchpath means remove all previous
656 selective VPATH's with the same pattern. */
659 /* No pattern means remove all previous selective VPATH's. */
661 construct_vpath_list (pattern
, p
);
666 else if (try_variable_definition (filename
, lineno
, p
, o_file
))
667 /* This line has been dealt with. */
669 else if (lb
.buffer
[0] == '\t')
671 p
= collapsed
; /* Ignore comments. */
675 /* The line is completely blank; that is harmless. */
677 /* This line starts with a tab but was not caught above
678 because there was no preceding target, and the line
679 might have been usable as a variable definition.
680 But now it is definitely lossage. */
681 makefile_fatal (filename
, lineno
,
682 "commands commence before first target");
686 /* This line describes some target files. */
690 /* Record the previous rule. */
692 record_waiting_files ();
694 /* Search the line for an unquoted ; that is not after an
696 cmdleft
= find_char_unquote (lb
.buffer
, ";#", 0);
697 if (cmdleft
!= 0 && *cmdleft
== '#')
699 /* We found a comment before a semicolon. */
703 else if (cmdleft
!= 0)
704 /* Found one. Cut the line short there before expanding it. */
707 collapse_continuations (lb
.buffer
);
709 /* Expand variable and function references before doing anything
710 else so that special characters can be inside variables. */
711 p
= variable_expand (lb
.buffer
);
714 /* Look for a semicolon in the expanded line. */
715 cmdleft
= find_char_unquote (p
, ";", 0);
718 /* Cut the line short at the semicolon. */
725 makefile_fatal (filename
, lineno
,
726 "missing rule before commands");
728 /* This line contained a variable reference that
729 expanded to nothing but whitespace. */
734 /* We accept and ignore rules without targets for
735 compatibility with SunOS 4 make. */
740 filenames
= multi_glob (parse_file_seq (&p2
, ':',
741 sizeof (struct nameseq
),
743 sizeof (struct nameseq
));
745 makefile_fatal (filename
, lineno
, "missing separator");
746 /* Is this a one-colon or two-colon entry? */
747 two_colon
= *p2
== ':';
751 /* We have some targets, so don't ignore the following commands. */
754 /* Is this a static pattern rule: `target: %targ: %dep; ...'? */
756 while (p
!= 0 && p
[-1] == '\\')
758 register char *q
= &p
[-1];
759 register int backslash
= 0;
761 backslash
= !backslash
;
763 p
= index (p
+ 1, ':');
768 /* For MS-DOS, skip a "C:\...". */
769 if (p
!= 0 && p
[1] == '\\' && isalpha (p
[-1]))
773 /* Here, the situation is quite complicated. Let's have a look
774 at a couple of targets:
782 The rule is that it's only a target, if there are TWO :'s
783 OR a space around the :.
785 if (p
&& !(isspace(p
[1]) || !p
[1] || isspace(p
[-1])))
791 /* For WIN32, skip a "C:\..." or a "C:/..." */
792 if (p
!= 0 && (p
[1] == '\\' || p
[1] == '/') && isalpha (p
[-1])) {
793 p
= index(p
+ 1, ':');
796 } while (check_again
);
800 struct nameseq
*target
;
801 target
= parse_file_seq (&p2
, ':', sizeof (struct nameseq
), 1);
804 makefile_fatal (filename
, lineno
, "missing target pattern");
805 else if (target
->next
!= 0)
806 makefile_fatal (filename
, lineno
, "multiple target patterns");
807 pattern
= target
->name
;
808 pattern_percent
= find_percent (pattern
);
809 if (pattern_percent
== 0)
810 makefile_fatal (filename
, lineno
,
811 "target pattern contains no `%%'");
816 /* Parse the dependencies. */
817 deps
= (struct dep
*)
818 multi_glob (parse_file_seq (&p2
, '\0', sizeof (struct dep
), 1),
819 sizeof (struct dep
));
824 /* Semicolon means rest of line is a command. */
825 unsigned int len
= strlen (cmdleft
+ 1);
827 commands_started
= lineno
;
829 /* Add this command line to the buffer. */
830 if (len
+ 2 > commands_len
)
832 commands_len
= (len
+ 2) * 2;
833 commands
= (char *) xrealloc (commands
, commands_len
);
835 bcopy (cmdleft
+ 1, commands
, len
);
837 commands
[commands_idx
++] = '\n';
843 /* We get here except in the case that we just read a rule line.
844 Record now the last rule we read, so following spurious
845 commands are properly diagnosed. */
846 record_waiting_files ();
850 if (conditionals
->if_cmds
)
851 makefile_fatal (filename
, lineno
, "missing `endif'");
853 /* At eof, record the last rule. */
854 record_waiting_files ();
857 free ((char *) commands
);
860 reading_filename
= 0;
861 reading_lineno_ptr
= 0;
866 /* Execute a `define' directive.
867 The first line has already been read, and NAME is the name of
868 the variable to be defined. The following lines remain to be read.
869 LINENO, INFILE and FILENAME refer to the makefile being read.
870 The value returned is LINENO, updated for lines read here. */
873 do_define (name
, namelen
, origin
, lineno
, infile
, filename
)
875 unsigned int namelen
;
876 enum variable_origin origin
;
881 struct linebuffer lb
;
882 unsigned int nlines
= 0;
883 unsigned int length
= 100;
884 char *definition
= (char *) xmalloc (100);
885 register unsigned int idx
= 0;
888 /* Expand the variable name. */
889 char *var
= (char *) alloca (namelen
+ 1);
890 bcopy (name
, var
, namelen
);
892 var
= variable_expand (var
);
895 while (!feof (infile
))
898 nlines
= readline (&lb
, infile
, filename
, lineno
);
900 collapse_continuations (lb
.buffer
);
902 p
= next_token (lb
.buffer
);
903 if ((p
[5] == '\0' || isblank (p
[5])) && !strncmp (p
, "endef", 5))
907 if (*next_token (p
) != '\0')
908 makefile_error (filename
, lineno
,
909 "Extraneous text after `endef' directive");
910 /* Define the variable. */
912 definition
[0] = '\0';
914 definition
[idx
- 1] = '\0';
915 (void) define_variable (var
, strlen (var
), definition
, origin
, 1);
922 unsigned int len
= strlen (lb
.buffer
);
924 /* Increase the buffer size if necessary. */
925 if (idx
+ len
+ 1 > length
)
927 length
= (idx
+ len
) * 2;
928 definition
= (char *) xrealloc (definition
, length
+ 1);
931 bcopy (lb
.buffer
, &definition
[idx
], len
);
933 /* Separate lines with a newline. */
934 definition
[idx
++] = '\n';
939 makefile_fatal (filename
, lineno
, "missing `endef', unterminated `define'");
945 /* Interpret conditional commands "ifdef", "ifndef", "ifeq",
946 "ifneq", "else" and "endif".
947 LINE is the input line, with the command as its first word.
949 FILENAME and LINENO are the filename and line number in the
950 current makefile. They are used for error messages.
952 Value is -1 if the line is invalid,
953 0 if following text should be interpreted,
954 1 if following text should be ignored. */
957 conditional_line (line
, filename
, lineno
)
964 register unsigned int i
;
968 /* It's an "if..." command. */
969 notdef
= line
[2] == 'n';
972 cmdname
= line
[3] == 'd' ? "ifndef" : "ifneq";
973 line
+= cmdname
[3] == 'd' ? 7 : 6;
977 cmdname
= line
[2] == 'd' ? "ifdef" : "ifeq";
978 line
+= cmdname
[2] == 'd' ? 6 : 5;
983 /* It's an "else" or "endif" command. */
984 notdef
= line
[1] == 'n';
985 cmdname
= notdef
? "endif" : "else";
986 line
+= notdef
? 5 : 4;
989 line
= next_token (line
);
994 makefile_error (filename
, lineno
,
995 "Extraneous text after `%s' directive",
997 /* "Else" or "endif". */
998 if (conditionals
->if_cmds
== 0)
999 makefile_fatal (filename
, lineno
, "extraneous `%s'", cmdname
);
1000 /* NOTDEF indicates an `endif' command. */
1002 --conditionals
->if_cmds
;
1003 else if (conditionals
->seen_else
[conditionals
->if_cmds
- 1])
1004 makefile_fatal (filename
, lineno
, "only one `else' per conditional");
1007 /* Toggle the state of ignorance. */
1008 conditionals
->ignoring
[conditionals
->if_cmds
- 1]
1009 = !conditionals
->ignoring
[conditionals
->if_cmds
- 1];
1010 /* Record that we have seen an `else' in this conditional.
1011 A second `else' will be erroneous. */
1012 conditionals
->seen_else
[conditionals
->if_cmds
- 1] = 1;
1014 for (i
= 0; i
< conditionals
->if_cmds
; ++i
)
1015 if (conditionals
->ignoring
[i
])
1020 if (conditionals
->allocated
== 0)
1022 conditionals
->allocated
= 5;
1023 conditionals
->ignoring
= (char *) xmalloc (conditionals
->allocated
);
1024 conditionals
->seen_else
= (char *) xmalloc (conditionals
->allocated
);
1027 ++conditionals
->if_cmds
;
1028 if (conditionals
->if_cmds
> conditionals
->allocated
)
1030 conditionals
->allocated
+= 5;
1031 conditionals
->ignoring
= (char *)
1032 xrealloc (conditionals
->ignoring
, conditionals
->allocated
);
1033 conditionals
->seen_else
= (char *)
1034 xrealloc (conditionals
->seen_else
, conditionals
->allocated
);
1037 /* Record that we have seen an `if...' but no `else' so far. */
1038 conditionals
->seen_else
[conditionals
->if_cmds
- 1] = 0;
1040 /* Search through the stack to see if we're already ignoring. */
1041 for (i
= 0; i
< conditionals
->if_cmds
- 1; ++i
)
1042 if (conditionals
->ignoring
[i
])
1044 /* We are already ignoring, so just push a level
1045 to match the next "else" or "endif", and keep ignoring.
1046 We don't want to expand variables in the condition. */
1047 conditionals
->ignoring
[conditionals
->if_cmds
- 1] = 1;
1051 if (cmdname
[notdef
? 3 : 2] == 'd')
1053 /* "Ifdef" or "ifndef". */
1055 register char *p
= end_of_token (line
);
1060 v
= lookup_variable (line
, i
);
1061 conditionals
->ignoring
[conditionals
->if_cmds
- 1]
1062 = (v
!= 0 && *v
->value
!= '\0') == notdef
;
1066 /* "Ifeq" or "ifneq". */
1069 char termin
= *line
== '(' ? ',' : *line
;
1071 if (termin
!= ',' && termin
!= '"' && termin
!= '\'')
1075 /* Find the end of the first string. */
1078 register int count
= 0;
1079 for (; *line
!= '\0'; ++line
)
1082 else if (*line
== ')')
1084 else if (*line
== ',' && count
<= 0)
1088 while (*line
!= '\0' && *line
!= termin
)
1096 s2
= variable_expand (s1
);
1097 /* We must allocate a new copy of the expanded string because
1098 variable_expand re-uses the same buffer. */
1100 s1
= (char *) alloca (len
+ 1);
1101 bcopy (s2
, s1
, len
+ 1);
1104 /* Find the start of the second string. */
1105 line
= next_token (line
);
1107 termin
= termin
== ',' ? ')' : *line
;
1108 if (termin
!= ')' && termin
!= '"' && termin
!= '\'')
1111 /* Find the end of the second string. */
1114 register int count
= 0;
1115 s2
= next_token (line
);
1116 for (line
= s2
; *line
!= '\0'; ++line
)
1120 else if (*line
== ')')
1131 while (*line
!= '\0' && *line
!= termin
)
1139 line
= next_token (++line
);
1141 makefile_error (filename
, lineno
,
1142 "Extraneous text after `%s' directive",
1145 s2
= variable_expand (s2
);
1146 conditionals
->ignoring
[conditionals
->if_cmds
- 1]
1147 = streq (s1
, s2
) == notdef
;
1150 /* Search through the stack to see if we're ignoring. */
1151 for (i
= 0; i
< conditionals
->if_cmds
; ++i
)
1152 if (conditionals
->ignoring
[i
])
1157 /* Remove duplicate dependencies in CHAIN. */
1160 uniquize_deps (chain
)
1163 register struct dep
*d
;
1165 /* Make sure that no dependencies are repeated. This does not
1166 really matter for the purpose of updating targets, but it
1167 might make some names be listed twice for $^ and $?. */
1169 for (d
= chain
; d
!= 0; d
= d
->next
)
1171 struct dep
*last
, *next
;
1176 if (streq (dep_name (d
), dep_name (next
)))
1178 struct dep
*n
= next
->next
;
1180 if (next
->name
!= 0 && next
->name
!= d
->name
)
1183 free ((char *) next
);
1194 /* Record a description line for files FILENAMES,
1195 with dependencies DEPS, commands to execute described
1196 by COMMANDS and COMMANDS_IDX, coming from FILENAME:COMMANDS_STARTED.
1197 TWO_COLON is nonzero if a double colon was used.
1198 If not nil, PATTERN is the `%' pattern to make this
1199 a static pattern rule, and PATTERN_PERCENT is a pointer
1200 to the `%' within it.
1202 The links of FILENAMES are freed, and so are any names in it
1203 that are not incorporated into other data structures. */
1206 record_files (filenames
, pattern
, pattern_percent
, deps
, commands_started
,
1207 commands
, commands_idx
, two_colon
, filename
, lineno
, set_default
)
1208 struct nameseq
*filenames
;
1209 char *pattern
, *pattern_percent
;
1211 unsigned int commands_started
;
1213 unsigned int commands_idx
;
1216 unsigned int lineno
;
1219 struct nameseq
*nextf
;
1221 unsigned int max_targets
, target_idx
;
1222 char **targets
= 0, **target_percents
= 0;
1223 struct commands
*cmds
;
1225 if (commands_idx
> 0)
1227 cmds
= (struct commands
*) xmalloc (sizeof (struct commands
));
1228 cmds
->filename
= filename
;
1229 cmds
->lineno
= commands_started
;
1230 cmds
->commands
= savestring (commands
, commands_idx
);
1231 cmds
->command_lines
= 0;
1236 for (; filenames
!= 0; filenames
= nextf
)
1238 register char *name
= filenames
->name
;
1239 register struct file
*f
;
1240 register struct dep
*d
;
1242 char *implicit_percent
;
1244 nextf
= filenames
->next
;
1245 free ((char *) filenames
);
1247 implicit_percent
= find_percent (name
);
1248 implicit
|= implicit_percent
!= 0;
1250 if (implicit
&& pattern
!= 0)
1251 makefile_fatal (filename
, lineno
,
1252 "mixed implicit and static pattern rules");
1254 if (implicit
&& implicit_percent
== 0)
1255 makefile_fatal (filename
, lineno
, "mixed implicit and normal rules");
1262 targets
= (char **) xmalloc (5 * sizeof (char *));
1263 target_percents
= (char **) xmalloc (5 * sizeof (char *));
1266 else if (target_idx
== max_targets
- 1)
1269 targets
= (char **) xrealloc ((char *) targets
,
1270 max_targets
* sizeof (char *));
1272 = (char **) xrealloc ((char *) target_percents
,
1273 max_targets
* sizeof (char *));
1275 targets
[target_idx
] = name
;
1276 target_percents
[target_idx
] = implicit_percent
;
1281 /* If there are multiple filenames, copy the chain DEPS
1282 for all but the last one. It is not safe for the same deps
1283 to go in more than one place in the data base. */
1284 this = nextf
!= 0 ? copy_dep_chain (deps
) : deps
;
1287 /* If this is an extended static rule:
1288 `targets: target%pattern: dep%pattern; cmds',
1289 translate each dependency pattern into a plain filename
1290 using the target pattern and this target's name. */
1291 if (!pattern_matches (pattern
, pattern_percent
, name
))
1293 /* Give a warning if the rule is meaningless. */
1294 makefile_error (filename
, lineno
,
1295 "target `%s' doesn't match the target pattern",
1301 /* We use patsubst_expand to do the work of translating
1302 the target pattern, the target's name and the dependencies'
1303 patterns into plain dependency names. */
1304 char *buffer
= variable_expand ("");
1306 for (d
= this; d
!= 0; d
= d
->next
)
1309 char *percent
= find_percent (d
->name
);
1312 o
= patsubst_expand (buffer
, name
, pattern
, d
->name
,
1313 pattern_percent
, percent
);
1315 d
->name
= savestring (buffer
, o
- buffer
);
1321 /* Single-colon. Combine these dependencies
1322 with others in file's existing record, if any. */
1323 f
= enter_file (name
);
1325 if (f
->double_colon
)
1326 makefile_fatal (filename
, lineno
,
1327 "target file `%s' has both : and :: entries",
1330 /* If CMDS == F->CMDS, this target was listed in this rule
1331 more than once. Just give a warning since this is harmless. */
1332 if (cmds
!= 0 && cmds
== f
->cmds
)
1335 "target `%s' given more than once in the same rule.",
1338 /* Check for two single-colon entries both with commands.
1339 Check is_target so that we don't lose on files such as .c.o
1340 whose commands were preinitialized. */
1341 else if (cmds
!= 0 && f
->cmds
!= 0 && f
->is_target
)
1343 makefile_error (cmds
->filename
, cmds
->lineno
,
1344 "warning: overriding commands for target `%s'",
1346 makefile_error (f
->cmds
->filename
, f
->cmds
->lineno
,
1347 "warning: ignoring old commands for target `%s'",
1353 /* Defining .DEFAULT with no deps or cmds clears it. */
1354 if (f
== default_file
&& this == 0 && cmds
== 0)
1358 /* Defining .SUFFIXES with no dependencies
1359 clears out the list of suffixes. */
1360 if (f
== suffix_file
&& this == 0)
1365 struct dep
*nextd
= d
->next
;
1372 else if (f
->deps
!= 0)
1374 /* Add the file's old deps and the new ones in THIS together. */
1376 struct dep
*firstdeps
, *moredeps
;
1379 /* This is the rule with commands, so put its deps first.
1380 The rationale behind this is that $< expands to the
1381 first dep in the chain, and commands use $< expecting
1382 to get the dep that rule specifies. */
1388 /* Append the new deps to the old ones. */
1389 firstdeps
= f
->deps
;
1394 firstdeps
= moredeps
;
1398 while (d
->next
!= 0)
1403 f
->deps
= firstdeps
;
1408 /* If this is a static pattern rule, set the file's stem to
1409 the part of its name that matched the `%' in the pattern,
1410 so you can use $* in the commands. */
1413 static char *percent
= "%";
1414 char *buffer
= variable_expand ("");
1415 char *o
= patsubst_expand (buffer
, name
, pattern
, percent
,
1416 pattern_percent
, percent
);
1417 f
->stem
= savestring (buffer
, o
- buffer
);
1422 /* Double-colon. Make a new record
1423 even if the file already has one. */
1424 f
= lookup_file (name
);
1425 /* Check for both : and :: rules. Check is_target so
1426 we don't lose on default suffix rules or makefiles. */
1427 if (f
!= 0 && f
->is_target
&& !f
->double_colon
)
1428 makefile_fatal (filename
, lineno
,
1429 "target file `%s' has both : and :: entries",
1431 f
= enter_file (name
);
1432 /* If there was an existing entry and it was a double-colon
1433 entry, enter_file will have returned a new one, making it the
1434 prev pointer of the old one, and setting its double_colon
1435 pointer to the first one. */
1436 if (f
->double_colon
== 0)
1437 /* This is the first entry for this name, so we must
1438 set its double_colon pointer to itself. */
1439 f
->double_colon
= f
;
1445 /* Free name if not needed further. */
1446 if (f
!= 0 && name
!= f
->name
1447 && (name
< f
->name
|| name
> f
->name
+ strlen (f
->name
)))
1453 /* See if this is first target seen whose name does
1454 not start with a `.', unless it contains a slash. */
1455 if (default_goal_file
== 0 && set_default
1456 && (*name
!= '.' || index (name
, '/') != 0))
1460 /* If this file is a suffix, don't
1461 let it be the default goal file. */
1463 for (d
= suffix_file
->deps
; d
!= 0; d
= d
->next
)
1465 register struct dep
*d2
;
1466 if (*dep_name (d
) != '.' && streq (name
, dep_name (d
)))
1471 for (d2
= suffix_file
->deps
; d2
!= 0; d2
= d2
->next
)
1473 register unsigned int len
= strlen (dep_name (d2
));
1474 if (strncmp (name
, dep_name (d2
), len
))
1476 if (streq (name
+ len
, dep_name (d
)))
1487 default_goal_file
= f
;
1493 targets
[target_idx
] = 0;
1494 target_percents
[target_idx
] = 0;
1495 create_pattern_rule (targets
, target_percents
, two_colon
, deps
, cmds
, 1);
1496 free ((char *) target_percents
);
1500 /* Search STRING for an unquoted STOPCHAR or blank (if BLANK is nonzero).
1501 Backslashes quote STOPCHAR, blanks if BLANK is nonzero, and backslash.
1502 Quoting backslashes are removed from STRING by compacting it into
1503 itself. Returns a pointer to the first unquoted STOPCHAR if there is
1504 one, or nil if there are none. */
1507 find_char_unquote (string
, stopchars
, blank
)
1512 unsigned int string_len
= 0;
1513 register char *p
= string
;
1517 while (*p
!= '\0' && index (stopchars
, *p
) == 0
1518 && (!blank
|| !isblank (*p
)))
1523 if (p
> string
&& p
[-1] == '\\')
1525 /* Search for more backslashes. */
1526 register int i
= -2;
1527 while (&p
[i
] >= string
&& p
[i
] == '\\')
1530 /* Only compute the length if really needed. */
1531 if (string_len
== 0)
1532 string_len
= strlen (string
);
1533 /* The number of backslashes is now -I.
1534 Copy P over itself to swallow half of them. */
1535 bcopy (&p
[i
/ 2], &p
[i
], (string_len
- (p
- string
)) - (i
/ 2) + 1);
1538 /* All the backslashes quoted each other; the STOPCHAR was
1542 /* The STOPCHAR was quoted by a backslash. Look for another. */
1545 /* No backslash in sight. */
1549 /* Never hit a STOPCHAR or blank (with BLANK nonzero). */
1553 /* Search PATTERN for an unquoted %. */
1556 find_percent (pattern
)
1559 return find_char_unquote (pattern
, "%", 0);
1562 /* Parse a string into a sequence of filenames represented as a
1563 chain of struct nameseq's in reverse order and return that chain.
1565 The string is passed as STRINGP, the address of a string pointer.
1566 The string pointer is updated to point at the first character
1567 not parsed, which either is a null char or equals STOPCHAR.
1569 SIZE is how big to construct chain elements.
1570 This is useful if we want them actually to be other structures
1571 that have room for additional info.
1573 If STRIP is nonzero, strip `./'s off the beginning. */
1576 parse_file_seq (stringp
, stopchar
, size
, strip
)
1582 register struct nameseq
*new = 0;
1583 register struct nameseq
*new1
, *lastnew1
;
1584 register char *p
= *stringp
;
1591 stopchars
[1] = stopchar
;
1592 stopchars
[2] = '\0';
1594 stopchars
[0] = stopchar
;
1595 stopchars
[1] = '\0';
1600 /* Skip whitespace; see if any more names are left. */
1607 /* Yes, find end of next name. */
1609 p
= find_char_unquote (q
, stopchars
, 1);
1611 /* convert comma separated list to space separated */
1616 /* For MS-DOS, skip a "C:\...". */
1617 if (stopchar
== ':' && p
!= 0 && p
[1] == '\\' && isalpha (p
[-1]))
1621 if (stopchar
== ':' && p
&& *p
== ':' &&
1622 !(isspace(p
[1]) || !p
[1] || isspace(p
[-1])))
1624 p
= find_char_unquote (p
+1, stopchars
, 1);
1628 /* For WIN32, skip a "C:\..." or "C:/...". */
1629 if (stopchar
== ':' &&
1631 (p
[1] == '\\' || p
[1] == '/') &&
1633 p
= end_of_token_w32(++p
, ':');
1634 if (*p
== '\0' && p
[-1] == ':')
1643 /* Skip leading `[]'s. */
1644 while (p
- q
> 2 && q
[0] == '[' && q
[1] == ']')
1646 /* Skip leading `./'s. */
1647 while (p
- q
> 2 && q
[0] == '.' && q
[1] == '/')
1650 q
+= 2; /* Skip "./". */
1651 while (q
< p
&& *q
== '/')
1652 /* Skip following slashes: ".//foo" is "foo", not "/foo". */
1656 /* Extract the filename just found, and skip it. */
1659 /* ".///" was stripped to "". */
1664 name
= savestring ("", 0);
1666 name
= savestring ("./", 2);
1671 /* VMS filenames can have a ':' in them but they have to be '\'ed but we need
1672 * to remove this '\' before we can use the filename.
1673 * Savestring called because q may be read-only string constant.
1676 char *qbase
= savestring(q
, strlen(q
));
1677 char *pbase
= qbase
+ (p
-q
);
1684 if (*q1
== '\\' && *(q1
+1) == ':')
1691 name
= savestring (qbase
, p1
- qbase
);
1695 name
= savestring (q
, p
- q
);
1698 /* Add it to the front of the chain. */
1699 new1
= (struct nameseq
*) xmalloc (size
);
1707 /* Look for multi-word archive references.
1708 They are indicated by a elt ending with an unmatched `)' and
1709 an elt further down the chain (i.e., previous in the file list)
1710 with an unmatched `(' (e.g., "lib(mem"). */
1715 if (new1
->name
[0] != '(' /* Don't catch "(%)" and suchlike. */
1716 && new1
->name
[strlen (new1
->name
) - 1] == ')'
1717 && index (new1
->name
, '(') == 0)
1719 /* NEW1 ends with a `)' but does not contain a `('.
1720 Look back for an elt with an opening `(' but no closing `)'. */
1722 struct nameseq
*n
= new1
->next
, *lastn
= new1
;
1724 while (n
!= 0 && (paren
= index (n
->name
, '(')) == 0)
1730 /* Ignore something starting with `(', as that cannot actually
1731 be an archive-member reference (and treating it as such
1732 results in an empty file name, which causes much lossage). */
1733 && n
->name
[0] != '(')
1735 /* N is the first element in the archive group.
1736 Its name looks like "lib(mem" (with no closing `)'). */
1740 /* Copy "lib(" into LIBNAME. */
1742 libname
= (char *) alloca (paren
- n
->name
+ 1);
1743 bcopy (n
->name
, libname
, paren
- n
->name
);
1744 libname
[paren
- n
->name
] = '\0';
1748 /* N was just "lib(", part of something like "lib( a b)".
1749 Edit it out of the chain and free its storage. */
1750 lastn
->next
= n
->next
;
1753 /* LASTN->next is the new stopping elt for the loop below. */
1758 /* Replace N's name with the full archive reference. */
1759 name
= concat (libname
, paren
, ")");
1764 if (new1
->name
[1] == '\0')
1766 /* NEW1 is just ")", part of something like "lib(a b )".
1767 Omit it from the chain and free its storage. */
1771 lastnew1
->next
= new1
->next
;
1775 free ((char *) lastn
);
1779 /* Replace also NEW1->name, which already has closing `)'. */
1780 name
= concat (libname
, new1
->name
, "");
1786 /* Trace back from NEW1 (the end of the list) until N
1787 (the beginning of the list), rewriting each name
1788 with the full archive reference. */
1792 name
= concat (libname
, new1
->name
, ")");
1801 /* No frobnication happening. Just step down the list. */
1818 /* Read a line of text from STREAM into LINEBUFFER.
1819 Combine continuation lines into one line.
1820 Return the number of actual lines read (> 1 if hacked continuation lines).
1824 readline (linebuffer
, stream
, filename
, lineno
)
1825 struct linebuffer
*linebuffer
;
1828 unsigned int lineno
;
1830 char *buffer
= linebuffer
->buffer
;
1831 register char *p
= linebuffer
->buffer
;
1832 register char *end
= p
+ linebuffer
->size
;
1833 register int len
, lastlen
= 0;
1835 register unsigned int nlines
= 0;
1836 register int backslash
;
1840 while (fgets (p
, end
- p
, stream
) != 0)
1845 /* This only happens when the first thing on the line is a '\0'.
1846 It is a pretty hopeless case, but (wonder of wonders) Athena
1847 lossage strikes again! (xmkmf puts NULs in its makefiles.)
1848 There is nothing really to be done; we synthesize a newline so
1849 the following line doesn't appear to be part of this line. */
1850 makefile_error (filename
, lineno
,
1851 "warning: NUL character seen; rest of line ignored");
1859 /* Probably ran out of buffer space. */
1860 register unsigned int p_off
= p
- buffer
;
1861 linebuffer
->size
*= 2;
1862 buffer
= (char *) xrealloc (buffer
, linebuffer
->size
);
1864 end
= buffer
+ linebuffer
->size
;
1865 linebuffer
->buffer
= buffer
;
1873 if (len
== 1 && p
> buffer
)
1874 /* P is pointing at a newline and it's the beginning of
1875 the buffer returned by the last fgets call. However,
1876 it is not necessarily the beginning of a line if P is
1877 pointing past the beginning of the holding buffer.
1878 If the buffer was just enlarged (right before the newline),
1879 we must account for that, so we pretend that the two lines
1884 for (p2
= p
- 2; --len
> 0; --p2
)
1887 backslash
= !backslash
;
1900 /* Enlarge the buffer. */
1901 register unsigned int p_off
= p
- buffer
;
1902 linebuffer
->size
*= 2;
1903 buffer
= (char *) xrealloc (buffer
, linebuffer
->size
);
1905 end
= buffer
+ linebuffer
->size
;
1906 linebuffer
->buffer
= buffer
;
1910 if (ferror (stream
))
1911 pfatal_with_name (filename
);
1916 /* Construct the list of include directories
1917 from the arguments and the default list. */
1920 construct_include_path (arg_dirs
)
1923 register unsigned int i
;
1924 #ifdef VAXC /* just don't ask ... */
1929 /* Table to hold the dirs. */
1931 register unsigned int defsize
= (sizeof (default_include_directories
)
1932 / sizeof (default_include_directories
[0]));
1933 register unsigned int max
= 5;
1934 register char **dirs
= (char **) xmalloc ((5 + defsize
) * sizeof (char *));
1935 register unsigned int idx
= 0;
1937 /* First consider any dirs specified with -I switches.
1938 Ignore dirs that don't exist. */
1941 while (*arg_dirs
!= 0)
1943 char *dir
= *arg_dirs
++;
1947 char *expanded
= tilde_expand (dir
);
1952 if (stat (dir
, &stbuf
) == 0 && S_ISDIR (stbuf
.st_mode
))
1958 xrealloc ((char *) dirs
, (max
+ defsize
) * sizeof (char *));
1962 else if (dir
!= arg_dirs
[-1])
1966 /* Now add at the end the standard default dirs. */
1968 for (i
= 0; default_include_directories
[i
] != 0; ++i
)
1969 if (stat (default_include_directories
[i
], &stbuf
) == 0
1970 && S_ISDIR (stbuf
.st_mode
))
1971 dirs
[idx
++] = default_include_directories
[i
];
1975 /* Now compute the maximum length of any name in it. */
1978 for (i
= 0; i
< idx
; ++i
)
1980 unsigned int len
= strlen (dirs
[i
]);
1981 /* If dir name is written with a trailing slash, discard it. */
1982 if (dirs
[i
][len
- 1] == '/')
1983 /* We can't just clobber a null in because it may have come from
1984 a literal string and literal strings may not be writable. */
1985 dirs
[i
] = savestring (dirs
[i
], len
- 1);
1986 if (len
> max_incl_len
)
1990 include_directories
= dirs
;
1993 /* Expand ~ or ~USER at the beginning of NAME.
1994 Return a newly malloc'd string or 0. */
2001 if (name
[1] == '/' || name
[1] == '\0')
2003 extern char *getenv ();
2008 /* Turn off --warn-undefined-variables while we expand HOME. */
2009 int save
= warn_undefined_variables_flag
;
2010 warn_undefined_variables_flag
= 0;
2012 home_dir
= allocated_variable_expand ("$(HOME)");
2014 warn_undefined_variables_flag
= save
;
2017 is_variable
= home_dir
[0] != '\0';
2021 home_dir
= getenv ("HOME");
2023 #if !defined(_AMIGA) && !defined(WIN32)
2024 if (home_dir
== 0 || home_dir
[0] == '\0')
2026 extern char *getlogin ();
2027 char *name
= getlogin ();
2031 struct passwd
*p
= getpwnam (name
);
2033 home_dir
= p
->pw_dir
;
2036 #endif /* !AMIGA && !WIN32 */
2039 char *new = concat (home_dir
, "", name
+ 1);
2045 #if !defined(_AMIGA) && !defined(WIN32)
2048 struct passwd
*pwent
;
2049 char *userend
= index (name
+ 1, '/');
2052 pwent
= getpwnam (name
+ 1);
2056 return savestring (pwent
->pw_dir
, strlen (pwent
->pw_dir
));
2058 return concat (pwent
->pw_dir
, "/", userend
+ 1);
2060 else if (userend
!= 0)
2063 #endif /* !AMIGA && !WIN32 */
2068 /* Given a chain of struct nameseq's describing a sequence of filenames,
2069 in reverse of the intended order, return a new chain describing the
2070 result of globbing the filenames. The new chain is in forward order.
2071 The links of the old chain are freed or used in the new chain.
2072 Likewise for the names in the old chain.
2074 SIZE is how big to construct chain elements.
2075 This is useful if we want them actually to be other structures
2076 that have room for additional info. */
2079 multi_glob (chain
, size
)
2080 struct nameseq
*chain
;
2083 extern void dir_setup_glob ();
2084 register struct nameseq
*new = 0;
2085 register struct nameseq
*old
;
2086 struct nameseq
*nexto
;
2089 dir_setup_glob (&gl
);
2091 for (old
= chain
; old
!= 0; old
= nexto
)
2099 if (old
->name
[0] == '~')
2101 char *newname
= tilde_expand (old
->name
);
2105 old
->name
= newname
;
2110 if (ar_name (old
->name
))
2112 /* OLD->name is an archive member reference.
2113 Replace it with the archive file name,
2114 and save the member name in MEMNAME.
2115 We will glob on the archive name and then
2116 reattach MEMNAME later. */
2118 ar_parse_name (old
->name
, &arname
, &memname
);
2124 #endif /* !NO_ARCHIVES */
2126 switch (glob (old
->name
, GLOB_NOCHECK
|GLOB_ALTDIRFUNC
, NULL
, &gl
))
2128 case 0: /* Success. */
2130 register int i
= gl
.gl_pathc
;
2136 /* Try to glob on MEMNAME within the archive. */
2137 struct nameseq
*found
2138 = ar_glob (gl
.gl_pathv
[i
], memname
, size
);
2141 /* No matches. Use MEMNAME as-is. */
2143 = (struct nameseq
*) xmalloc (size
);
2144 unsigned int alen
= strlen (gl
.gl_pathv
[i
]);
2145 unsigned int mlen
= strlen (memname
);
2146 elt
->name
= (char *) xmalloc (alen
+ 1 + mlen
+ 2);
2147 bcopy (gl
.gl_pathv
[i
], elt
->name
, alen
);
2148 elt
->name
[alen
] = '(';
2149 bcopy (memname
, &elt
->name
[alen
+ 1], mlen
);
2150 elt
->name
[alen
+ 1 + mlen
] = ')';
2151 elt
->name
[alen
+ 1 + mlen
+ 1] = '\0';
2157 /* Find the end of the FOUND chain. */
2158 struct nameseq
*f
= found
;
2159 while (f
->next
!= 0)
2162 /* Attach the chain being built to the end of the FOUND
2163 chain, and make FOUND the new NEW chain. */
2171 #endif /* !NO_ARCHIVES */
2173 struct nameseq
*elt
= (struct nameseq
*) xmalloc (size
);
2174 elt
->name
= savestring (gl
.gl_pathv
[i
],
2175 strlen (gl
.gl_pathv
[i
]));
2187 fatal ("virtual memory exhausted");