1 /* Reading and parsing of makefiles for GNU Make.
2 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 2002 Free Software Foundation, Inc.
4 This file is part of GNU Make.
6 GNU Make is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Make is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Make; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
42 struct passwd
*getpwnam
PARAMS ((char *name
));
45 #endif /* !WINDOWS32 */
47 /* A 'struct ebuffer' controls the origin of the makefile we are currently
53 char *buffer
; /* Start of the current line in the buffer. */
54 char *bufnext
; /* Start of the next line in the buffer. */
55 char *bufstart
; /* Start of the entire buffer. */
56 unsigned int size
; /* Malloc'd size of buffer. */
57 FILE *fp
; /* File, or NULL if this is an internal buffer. */
58 struct floc floc
; /* Info on the file in fp (if any). */
61 /* Types of "words" that can be read in a makefile. */
64 w_bogus
, w_eol
, w_static
, w_variable
, w_colon
, w_dcolon
, w_semicolon
,
69 /* A `struct conditionals' contains the information describing
70 all the active conditionals in a makefile.
72 The global variable `conditionals' contains the conditionals
73 information for the current makefile. It is initialized from
74 the static structure `toplevel_conditionals' and is later changed
75 to new structures for included makefiles. */
79 unsigned int if_cmds
; /* Depth of conditional nesting. */
80 unsigned int allocated
; /* Elts allocated in following arrays. */
81 char *ignoring
; /* Are we ignoring or interpreting?
82 0=interpreting, 1=not yet interpreted,
83 2=already interpreted */
84 char *seen_else
; /* Have we already seen an `else'? */
87 static struct conditionals toplevel_conditionals
;
88 static struct conditionals
*conditionals
= &toplevel_conditionals
;
91 /* Default directories to search for include files in */
93 static char *default_include_directories
[] =
95 #if defined(WINDOWS32) && !defined(INCLUDEDIR)
97 * This completely up to the user when they install MSVC or other packages.
98 * This is defined as a placeholder.
100 #define INCLUDEDIR "."
105 "/usr/local/include",
111 /* List of directories to search for include files in */
113 static char **include_directories
;
115 /* Maximum length of an element of the above. */
117 static unsigned int max_incl_len
;
119 /* The filename and pointer to line number of the
120 makefile currently being read in. */
122 const struct floc
*reading_file
= 0;
124 /* The chain of makefiles read by read_makefile. */
126 static struct dep
*read_makefiles
= 0;
128 static int eval_makefile
PARAMS ((char *filename
, int flags
));
129 static int eval
PARAMS ((struct ebuffer
*buffer
, int flags
));
131 static long readline
PARAMS ((struct ebuffer
*ebuf
));
132 static void do_define
PARAMS ((char *name
, unsigned int namelen
,
133 enum variable_origin origin
,
134 struct ebuffer
*ebuf
));
135 static int conditional_line
PARAMS ((char *line
, int len
, const struct floc
*flocp
));
136 static void record_files
PARAMS ((struct nameseq
*filenames
, char *pattern
, char *pattern_percent
,
137 struct dep
*deps
, unsigned int cmds_started
, char *commands
,
138 unsigned int commands_idx
, int two_colon
,
139 const struct floc
*flocp
));
140 static void record_target_var
PARAMS ((struct nameseq
*filenames
, char *defn
,
141 enum variable_origin origin
,
143 const struct floc
*flocp
));
144 static enum make_word_type get_next_mword
PARAMS ((char *buffer
, char *delim
,
145 char **startp
, unsigned int *length
));
146 static void remove_comments
PARAMS ((char *line
));
147 static char *find_char_unquote
PARAMS ((char *string
, int stop1
,
148 int stop2
, int blank
, int ignorevars
));
150 /* Read in all the makefiles and return the chain of their names. */
153 read_all_makefiles (char **makefiles
)
155 unsigned int num_makefiles
= 0;
157 /* Create *_LIST variables, to hold the makefiles, targets, and variables
158 we will be reading. */
160 define_variable ("MAKEFILE_LIST", sizeof ("MAKEFILE_LIST")-1, "", o_file
, 0);
162 DB (DB_BASIC
, (_("Reading makefiles...\n")));
164 /* If there's a non-null variable MAKEFILES, its value is a list of
165 files to read first thing. But don't let it prevent reading the
166 default makefiles and don't let the default goal come from there. */
174 /* Turn off --warn-undefined-variables while we expand MAKEFILES. */
175 int save
= warn_undefined_variables_flag
;
176 warn_undefined_variables_flag
= 0;
178 value
= allocated_variable_expand ("$(MAKEFILES)");
180 warn_undefined_variables_flag
= save
;
183 /* Set NAME to the start of next token and LENGTH to its length.
184 MAKEFILES is updated for finding remaining tokens. */
187 while ((name
= find_next_token (&p
, &length
)) != 0)
191 name
= xstrdup (name
);
192 if (eval_makefile (name
,
193 RM_NO_DEFAULT_GOAL
|RM_INCLUDED
|RM_DONTCARE
) < 2)
200 /* Read makefiles specified with -f switches. */
203 while (*makefiles
!= 0)
205 struct dep
*tail
= read_makefiles
;
206 register struct dep
*d
;
208 if (! eval_makefile (*makefiles
, 0))
209 perror_with_name ("", *makefiles
);
211 /* Find the right element of read_makefiles. */
213 while (d
->next
!= tail
)
216 /* Use the storage read_makefile allocates. */
217 *makefiles
= dep_name (d
);
222 /* If there were no -f switches, try the default names. */
224 if (num_makefiles
== 0)
226 static char *default_makefiles
[] =
228 /* all lower case since readdir() (the vms version) 'lowercasifies' */
229 { "makefile.vms", "gnumakefile.", "makefile.", 0 };
232 { "GNUmakefile", "Makefile", "SMakefile", 0 };
233 #else /* !Amiga && !VMS */
234 { "GNUmakefile", "makefile", "Makefile", 0 };
237 register char **p
= default_makefiles
;
238 while (*p
!= 0 && !file_exists_p (*p
))
243 if (! eval_makefile (*p
, 0))
244 perror_with_name ("", *p
);
248 /* No default makefile was found. Add the default makefiles to the
249 `read_makefiles' chain so they will be updated if possible. */
250 struct dep
*tail
= read_makefiles
;
251 /* Add them to the tail, after any MAKEFILES variable makefiles. */
252 while (tail
!= 0 && tail
->next
!= 0)
254 for (p
= default_makefiles
; *p
!= 0; ++p
)
256 struct dep
*d
= (struct dep
*) xmalloc (sizeof (struct dep
));
258 d
->file
= enter_file (*p
);
259 d
->file
->dontcare
= 1;
261 d
->staticpattern
= 0;
262 d
->need_2nd_expansion
= 0;
263 /* Tell update_goal_chain to bail out as soon as this file is
264 made, and main not to die if we can't make this file. */
265 d
->changed
= RM_DONTCARE
;
277 return read_makefiles
;
280 /* Install a new conditional and return the previous one. */
282 static struct conditionals
*
283 install_conditionals (struct conditionals
*new)
285 struct conditionals
*save
= conditionals
;
287 bzero ((char *) new, sizeof (*new));
293 /* Free the current conditionals and reinstate a saved one. */
296 restore_conditionals (struct conditionals
*saved
)
298 /* Free any space allocated by conditional_line. */
299 if (conditionals
->ignoring
)
300 free (conditionals
->ignoring
);
301 if (conditionals
->seen_else
)
302 free (conditionals
->seen_else
);
305 conditionals
= saved
;
309 eval_makefile (char *filename
, int flags
)
313 const struct floc
*curfile
;
317 ebuf
.floc
.filenm
= filename
;
318 ebuf
.floc
.lineno
= 1;
320 if (ISDB (DB_VERBOSE
))
322 printf (_("Reading makefile `%s'"), filename
);
323 if (flags
& RM_NO_DEFAULT_GOAL
)
324 printf (_(" (no default goal)"));
325 if (flags
& RM_INCLUDED
)
326 printf (_(" (search path)"));
327 if (flags
& RM_DONTCARE
)
328 printf (_(" (don't care)"));
329 if (flags
& RM_NO_TILDE
)
330 printf (_(" (no ~ expansion)"));
334 /* First, get a stream to read. */
336 /* Expand ~ in FILENAME unless it came from `include',
337 in which case it was already done. */
338 if (!(flags
& RM_NO_TILDE
) && filename
[0] == '~')
340 char *expanded
= tilde_expand (filename
);
345 ebuf
.fp
= fopen (filename
, "r");
346 /* Save the error code so we print the right message later. */
347 makefile_errno
= errno
;
349 /* If the makefile wasn't found and it's either a makefile from
350 the `MAKEFILES' variable or an included makefile,
351 search the included makefile search path for this makefile. */
352 if (ebuf
.fp
== 0 && (flags
& RM_INCLUDED
) && *filename
!= '/')
354 register unsigned int i
;
355 for (i
= 0; include_directories
[i
] != 0; ++i
)
357 char *name
= concat (include_directories
[i
], "/", filename
);
358 ebuf
.fp
= fopen (name
, "r");
369 /* Add FILENAME to the chain of read makefiles. */
370 deps
= (struct dep
*) xmalloc (sizeof (struct dep
));
371 deps
->next
= read_makefiles
;
372 read_makefiles
= deps
;
374 deps
->file
= lookup_file (filename
);
376 deps
->file
= enter_file (xstrdup (filename
));
377 if (filename
!= ebuf
.floc
.filenm
)
379 filename
= deps
->file
->name
;
380 deps
->changed
= flags
;
381 deps
->ignore_mtime
= 0;
382 deps
->staticpattern
= 0;
383 deps
->need_2nd_expansion
= 0;
384 if (flags
& RM_DONTCARE
)
385 deps
->file
->dontcare
= 1;
387 /* If the makefile can't be found at all, give up entirely. */
391 /* If we did some searching, errno has the error from the last
392 attempt, rather from FILENAME itself. Restore it in case the
393 caller wants to use it in a message. */
394 errno
= makefile_errno
;
398 /* Add this makefile to the list. */
399 do_variable_definition (&ebuf
.floc
, "MAKEFILE_LIST", filename
, o_file
,
402 /* Evaluate the makefile */
405 ebuf
.buffer
= ebuf
.bufnext
= ebuf
.bufstart
= xmalloc (ebuf
.size
);
407 curfile
= reading_file
;
408 reading_file
= &ebuf
.floc
;
410 r
= eval (&ebuf
, !(flags
& RM_NO_DEFAULT_GOAL
));
412 reading_file
= curfile
;
416 free (ebuf
.bufstart
);
422 eval_buffer (char *buffer
)
425 struct conditionals
*saved
;
426 struct conditionals
new;
427 const struct floc
*curfile
;
430 /* Evaluate the buffer */
432 ebuf
.size
= strlen (buffer
);
433 ebuf
.buffer
= ebuf
.bufnext
= ebuf
.bufstart
= buffer
;
436 ebuf
.floc
= *reading_file
;
438 curfile
= reading_file
;
439 reading_file
= &ebuf
.floc
;
441 saved
= install_conditionals (&new);
445 restore_conditionals (saved
);
447 reading_file
= curfile
;
454 /* Read file FILENAME as a makefile and add its contents to the data base.
456 SET_DEFAULT is true if we are allowed to set the default goal. */
460 eval (struct ebuffer
*ebuf
, int set_default
)
463 unsigned int collapsed_length
= 0;
464 unsigned int commands_len
= 200;
466 unsigned int commands_idx
= 0;
467 unsigned int cmds_started
, tgts_started
;
468 int ignoring
= 0, in_ignored_define
= 0;
469 int no_targets
= 0; /* Set when reading a rule without targets. */
470 struct nameseq
*filenames
= 0;
471 struct dep
*deps
= 0;
474 char *pattern
= 0, *pattern_percent
;
478 #define record_waiting_files() \
481 if (filenames != 0) \
483 fi.lineno = tgts_started; \
484 record_files (filenames, pattern, pattern_percent, deps, \
485 cmds_started, commands, commands_idx, two_colon, \
491 if (pattern) { free(pattern); pattern = 0; } \
495 cmds_started
= tgts_started
= 1;
497 fstart
= &ebuf
->floc
;
498 fi
.filenm
= ebuf
->floc
.filenm
;
500 /* Loop over lines in the file.
501 The strategy is to accumulate target names in FILENAMES, dependencies
502 in DEPS and commands in COMMANDS. These are used to define a rule
503 when the start of the next rule (or eof) is encountered.
505 When you see a "continue" in the loop below, that means we are moving on
506 to the next line _without_ ending any rule that we happen to be working
507 with at the moment. If you see a "goto rule_complete", then the
508 statement we just parsed also finishes the previous rule. */
510 commands
= xmalloc (200);
514 unsigned int linelen
;
520 /* Grab the next line to be evaluated */
521 ebuf
->floc
.lineno
+= nlines
;
522 nlines
= readline (ebuf
);
524 /* If there is nothing left to eval, we're done. */
528 /* If this line is empty, skip it. */
533 linelen
= strlen (line
);
535 /* Check for a shell command line first.
536 If it is not one, we can stop treating tab specially. */
540 /* Ignore the commands in a rule with no targets. */
543 /* If there is no preceding rule line, don't treat this line
544 as a command, even though it begins with a tab character.
545 SunOS 4 make appears to behave this way. */
550 /* Yep, this is a shell command, and we don't care. */
553 /* Append this command line to the line being accumulated. */
554 if (commands_idx
== 0)
555 cmds_started
= ebuf
->floc
.lineno
;
557 if (linelen
+ 1 + commands_idx
> commands_len
)
559 commands_len
= (linelen
+ 1 + commands_idx
) * 2;
560 commands
= xrealloc (commands
, commands_len
);
562 bcopy (line
, &commands
[commands_idx
], linelen
);
563 commands_idx
+= linelen
;
564 commands
[commands_idx
++] = '\n';
570 /* This line is not a shell command line. Don't worry about tabs.
571 Get more space if we need it; we don't need to preserve the current
572 contents of the buffer. */
574 if (collapsed_length
< linelen
+1)
576 collapsed_length
= linelen
+1;
578 free ((char *)collapsed
);
579 collapsed
= (char *) xmalloc (collapsed_length
);
581 strcpy (collapsed
, line
);
582 /* Collapse continuation lines. */
583 collapse_continuations (collapsed
);
584 remove_comments (collapsed
);
586 /* Compare a word, both length and contents. */
587 #define word1eq(s) (len == sizeof(s)-1 && strneq (s, p, sizeof(s)-1))
589 while (isspace ((unsigned char)*p
))
593 /* This line is completely empty--ignore it. */
596 /* Find the end of the first token. Note we don't need to worry about
597 * ":" here since we compare tokens by length (so "export" will never
598 * be equal to "export:").
600 for (p2
= p
+1; *p2
!= '\0' && !isspace ((unsigned char)*p2
); ++p2
)
604 /* Find the start of the second token. If it looks like a target or
605 variable definition it can't be a preprocessor token so skip
606 them--this allows variables/targets named `ifdef', `export', etc. */
607 while (isspace ((unsigned char)*p2
))
610 if ((p2
[0] == ':' || p2
[0] == '+' || p2
[0] == '=') && p2
[1] == '\0')
612 /* It can't be a preprocessor token so skip it if we're ignoring */
616 goto skip_conditionals
;
619 /* We must first check for conditional and `define' directives before
620 ignoring anything, since they control what we will do with
623 if (!in_ignored_define
)
625 int i
= conditional_line (p
, len
, fstart
);
629 fatal (fstart
, _("invalid syntax in conditional"));
636 if (word1eq ("endef"))
638 if (!in_ignored_define
)
639 fatal (fstart
, _("extraneous `endef'"));
640 in_ignored_define
= 0;
644 if (word1eq ("define"))
647 in_ignored_define
= 1;
651 fatal (fstart
, _("empty variable name"));
653 /* Let the variable name be the whole rest of the line,
654 with trailing blanks stripped (comments have already been
655 removed), so it could be a complex variable/function
656 reference that might contain blanks. */
657 p
= strchr (p2
, '\0');
658 while (isblank ((unsigned char)p
[-1]))
660 do_define (p2
, p
- p2
, o_file
, ebuf
);
665 if (word1eq ("override"))
668 error (fstart
, _("empty `override' directive"));
670 if (strneq (p2
, "define", 6)
671 && (isblank ((unsigned char)p2
[6]) || p2
[6] == '\0'))
674 in_ignored_define
= 1;
677 p2
= next_token (p2
+ 6);
679 fatal (fstart
, _("empty variable name"));
681 /* Let the variable name be the whole rest of the line,
682 with trailing blanks stripped (comments have already been
683 removed), so it could be a complex variable/function
684 reference that might contain blanks. */
685 p
= strchr (p2
, '\0');
686 while (isblank ((unsigned char)p
[-1]))
688 do_define (p2
, p
- p2
, o_override
, ebuf
);
692 && !try_variable_definition (fstart
, p2
, o_override
, 0))
693 error (fstart
, _("invalid `override' directive"));
699 /* Ignore the line. We continue here so conditionals
700 can appear in the middle of a rule. */
703 if (word1eq ("export"))
705 /* 'export' by itself causes everything to be exported. */
707 export_all_variables
= 1;
712 v
= try_variable_definition (fstart
, p2
, o_file
, 0);
714 v
->export
= v_export
;
720 /* Expand the line so we can use indirect and constructed
721 variable names in an export command. */
722 p2
= ap
= allocated_variable_expand (p2
);
724 for (p
= find_next_token (&p2
, &len
); p
!= 0;
725 p
= find_next_token (&p2
, &len
))
727 v
= lookup_variable (p
, len
);
729 v
= define_variable_loc (p
, len
, "", o_file
, 0,
731 v
->export
= v_export
;
740 if (word1eq ("unexport"))
743 export_all_variables
= 0;
750 /* Expand the line so we can use indirect and constructed
751 variable names in an unexport command. */
752 p2
= ap
= allocated_variable_expand (p2
);
754 for (p
= find_next_token (&p2
, &len
); p
!= 0;
755 p
= find_next_token (&p2
, &len
))
757 v
= lookup_variable (p
, len
);
759 v
= define_variable_loc (p
, len
, "", o_file
, 0, fstart
);
761 v
->export
= v_noexport
;
770 if (word1eq ("vpath"))
774 p2
= variable_expand (p2
);
775 p
= find_next_token (&p2
, &len
);
778 pattern
= savestring (p
, len
);
779 p
= find_next_token (&p2
, &len
);
780 /* No searchpath means remove all previous
781 selective VPATH's with the same pattern. */
784 /* No pattern means remove all previous selective VPATH's. */
786 construct_vpath_list (pattern
, p
);
793 if (word1eq ("include") || word1eq ("-include") || word1eq ("sinclude"))
795 /* We have found an `include' line specifying a nested
796 makefile to be read at this point. */
797 struct conditionals
*save
;
798 struct conditionals new_conditionals
;
799 struct nameseq
*files
;
800 /* "-include" (vs "include") says no error if the file does not
801 exist. "sinclude" is an alias for this from SGI. */
802 int noerror
= (p
[0] != 'i');
804 p
= allocated_variable_expand (p2
);
806 /* If no filenames, it's a no-op. */
810 /* Parse the list of file names. */
812 files
= multi_glob (parse_file_seq (&p2
, '\0',
813 sizeof (struct nameseq
),
815 sizeof (struct nameseq
));
818 /* Save the state of conditionals and start
819 the included makefile with a clean slate. */
820 save
= install_conditionals (&new_conditionals
);
822 /* Record the rules that are waiting so they will determine
823 the default goal before those in the included makefile. */
824 record_waiting_files ();
826 /* Read each included makefile. */
829 struct nameseq
*next
= files
->next
;
830 char *name
= files
->name
;
833 free ((char *)files
);
836 r
= eval_makefile (name
, (RM_INCLUDED
| RM_NO_TILDE
837 | (noerror
? RM_DONTCARE
: 0)));
841 error (fstart
, "%s: %s", name
, strerror (errno
));
846 /* Restore conditional state. */
847 restore_conditionals (save
);
852 if (try_variable_definition (fstart
, p
, o_file
, 0))
853 /* This line has been dealt with. */
856 /* This line starts with a tab but was not caught above because there
857 was no preceding target, and the line might have been usable as a
858 variable definition. But now we know it is definitely lossage. */
860 fatal(fstart
, _("commands commence before first target"));
862 /* This line describes some target files. This is complicated by
863 the existence of target-specific variables, because we can't
864 expand the entire line until we know if we have one or not. So
865 we expand the line word by word until we find the first `:',
866 then check to see if it's a target-specific variable.
868 In this algorithm, `lb_next' will point to the beginning of the
869 unexpanded parts of the input buffer, while `p2' points to the
870 parts of the expanded buffer we haven't searched yet. */
873 enum make_word_type wtype
;
874 enum variable_origin v_origin
;
876 char *cmdleft
, *semip
, *lb_next
;
877 unsigned int len
, plen
= 0;
879 const char *end
, *beg
; /* Helpers for whitespace stripping. */
881 /* Record the previous rule. */
883 record_waiting_files ();
884 tgts_started
= fstart
->lineno
;
886 /* Search the line for an unquoted ; that is not after an
888 cmdleft
= find_char_unquote (line
, ';', '#', 0, 1);
889 if (cmdleft
!= 0 && *cmdleft
== '#')
891 /* We found a comment before a semicolon. */
895 else if (cmdleft
!= 0)
896 /* Found one. Cut the line short there before expanding it. */
900 collapse_continuations (line
);
902 /* We can't expand the entire line, since if it's a per-target
903 variable we don't want to expand it. So, walk from the
904 beginning, expanding as we go, and looking for "interesting"
905 chars. The first word is always expandable. */
906 wtype
= get_next_mword(line
, NULL
, &lb_next
, &len
);
911 fatal(fstart
, _("missing rule before commands"));
912 /* This line contained something but turned out to be nothing
913 but whitespace (a comment?). */
918 /* We accept and ignore rules without targets for
919 compatibility with SunOS 4 make. */
927 p2
= variable_expand_string(NULL
, lb_next
, len
);
934 /* Look for a semicolon in the expanded line. */
935 cmdleft
= find_char_unquote (p2
, ';', 0, 0, 0);
939 unsigned long p2_off
= p2
- variable_buffer
;
940 unsigned long cmd_off
= cmdleft
- variable_buffer
;
941 char *pend
= p2
+ strlen(p2
);
943 /* Append any remnants of lb, then cut the line short
947 /* One school of thought says that you shouldn't expand
948 here, but merely copy, since now you're beyond a ";"
949 and into a command script. However, the old parser
950 expanded the whole line, so we continue that for
951 backwards-compatiblity. Also, it wouldn't be
952 entirely consistent, since we do an unconditional
953 expand below once we know we don't have a
954 target-specific variable. */
955 (void)variable_expand_string(pend
, lb_next
, (long)-1);
956 lb_next
+= strlen(lb_next
);
957 p2
= variable_buffer
+ p2_off
;
958 cmdleft
= variable_buffer
+ cmd_off
+ 1;
962 colonp
= find_char_unquote(p2
, ':', 0, 0, 0);
963 #ifdef HAVE_DOS_PATHS
964 /* The drive spec brain-damage strikes again... */
965 /* Note that the only separators of targets in this context
966 are whitespace and a left paren. If others are possible,
967 they should be added to the string in the call to index. */
968 while (colonp
&& (colonp
[1] == '/' || colonp
[1] == '\\') &&
969 colonp
> p2
&& isalpha ((unsigned char)colonp
[-1]) &&
970 (colonp
== p2
+ 1 || strchr (" \t(", colonp
[-2]) != 0))
971 colonp
= find_char_unquote(colonp
+ 1, ':', 0, 0, 0);
976 wtype
= get_next_mword(lb_next
, NULL
, &lb_next
, &len
);
982 p2
= variable_expand_string(p2
, lb_next
, len
);
983 /* We don't need to worry about cmdleft here, because if it was
984 found in the variable_buffer the entire buffer has already
985 been expanded... we'll never get here. */
988 p2
= next_token (variable_buffer
);
990 /* If the word we're looking at is EOL, see if there's _anything_
991 on the line. If not, a variable expanded to nothing, so ignore
992 it. If so, we can't parse this line so punt. */
996 /* There's no need to be ivory-tower about this: check for
997 one of the most common bugs found in makefiles... */
998 fatal (fstart
, _("missing separator%s"),
999 !strneq(line
, " ", 8) ? ""
1000 : _(" (did you mean TAB instead of 8 spaces?)"));
1004 /* Make the colon the end-of-string so we know where to stop
1005 looking for targets. */
1007 filenames
= multi_glob (parse_file_seq (&p2
, '\0',
1008 sizeof (struct nameseq
),
1010 sizeof (struct nameseq
));
1015 /* We accept and ignore rules without targets for
1016 compatibility with SunOS 4 make. */
1020 /* This should never be possible; we handled it above. */
1021 assert (*p2
!= '\0');
1024 /* Is this a one-colon or two-colon entry? */
1025 two_colon
= *p2
== ':';
1029 /* Test to see if it's a target-specific variable. Copy the rest
1030 of the buffer over, possibly temporarily (we'll expand it later
1031 if it's not a target-specific variable). PLEN saves the length
1032 of the unparsed section of p2, for later. */
1033 if (*lb_next
!= '\0')
1035 unsigned int l
= p2
- variable_buffer
;
1037 (void) variable_buffer_output (p2
+plen
,
1038 lb_next
, strlen (lb_next
)+1);
1039 p2
= variable_buffer
+ l
;
1042 /* See if it's an "override" or "export" keyword; if so see if what
1043 comes after it looks like a variable definition. */
1045 wtype
= get_next_mword (p2
, NULL
, &p
, &len
);
1049 if (wtype
== w_static
)
1051 if (word1eq ("override"))
1053 v_origin
= o_override
;
1054 wtype
= get_next_mword (p
+len
, NULL
, &p
, &len
);
1056 else if (word1eq ("export"))
1059 wtype
= get_next_mword (p
+len
, NULL
, &p
, &len
);
1064 wtype
= get_next_mword (p
+len
, NULL
, NULL
, NULL
);
1066 if (wtype
== w_varassign
)
1068 /* If there was a semicolon found, add it back, plus anything
1072 unsigned int l
= p
- variable_buffer
;
1074 variable_buffer_output (p2
+ strlen (p2
),
1075 semip
, strlen (semip
)+1);
1076 p
= variable_buffer
+ l
;
1078 record_target_var (filenames
, p
, v_origin
, exported
, fstart
);
1083 /* This is a normal target, _not_ a target-specific variable.
1084 Unquote any = in the dependency list. */
1085 find_char_unquote (lb_next
, '=', 0, 0, 0);
1087 /* We have some targets, so don't ignore the following commands. */
1090 /* Expand the dependencies, etc. */
1091 if (*lb_next
!= '\0')
1093 unsigned int l
= p2
- variable_buffer
;
1094 (void) variable_expand_string (p2
+ plen
, lb_next
, (long)-1);
1095 p2
= variable_buffer
+ l
;
1097 /* Look for a semicolon in the expanded line. */
1100 cmdleft
= find_char_unquote (p2
, ';', 0, 0, 0);
1102 *(cmdleft
++) = '\0';
1106 /* Is this a static pattern rule: `target: %targ: %dep; ...'? */
1107 p
= strchr (p2
, ':');
1108 while (p
!= 0 && p
[-1] == '\\')
1110 register char *q
= &p
[-1];
1111 register int backslash
= 0;
1112 while (*q
-- == '\\')
1113 backslash
= !backslash
;
1115 p
= strchr (p
+ 1, ':');
1120 /* Here, the situation is quite complicated. Let's have a look
1121 at a couple of targets:
1129 The rule is that it's only a target, if there are TWO :'s
1130 OR a space around the :.
1132 if (p
&& !(isspace ((unsigned char)p
[1]) || !p
[1]
1133 || isspace ((unsigned char)p
[-1])))
1136 #ifdef HAVE_DOS_PATHS
1142 /* For DOS-style paths, skip a "C:\..." or a "C:/..." */
1143 if (p
!= 0 && (p
[1] == '\\' || p
[1] == '/') &&
1144 isalpha ((unsigned char)p
[-1]) &&
1145 (p
== p2
+ 1 || strchr (" \t:(", p
[-2]) != 0)) {
1146 p
= strchr (p
+ 1, ':');
1149 } while (check_again
);
1154 struct nameseq
*target
;
1155 target
= parse_file_seq (&p2
, ':', sizeof (struct nameseq
), 1);
1158 fatal (fstart
, _("missing target pattern"));
1159 else if (target
->next
!= 0)
1160 fatal (fstart
, _("multiple target patterns"));
1161 pattern
= target
->name
;
1162 pattern_percent
= find_percent (pattern
);
1163 if (pattern_percent
== 0)
1164 fatal (fstart
, _("target pattern contains no `%%'"));
1165 free ((char *)target
);
1170 /* Strip leading and trailing whitespaces. */
1172 end
= beg
+ strlen (beg
) - 1;
1173 strip_whitespace (&beg
, &end
);
1175 if (beg
<= end
&& *beg
!= '\0')
1177 /* Put all the prerequisites here; they'll be parsed later. */
1178 deps
= (struct dep
*) xmalloc (sizeof (struct dep
));
1180 deps
->name
= savestring (beg
, end
- beg
+ 1);
1183 deps
->ignore_mtime
= 0;
1184 deps
->staticpattern
= 0;
1185 deps
->need_2nd_expansion
= 0;
1193 /* Semicolon means rest of line is a command. */
1194 unsigned int len
= strlen (cmdleft
);
1196 cmds_started
= fstart
->lineno
;
1198 /* Add this command line to the buffer. */
1199 if (len
+ 2 > commands_len
)
1201 commands_len
= (len
+ 2) * 2;
1202 commands
= (char *) xrealloc (commands
, commands_len
);
1204 bcopy (cmdleft
, commands
, len
);
1205 commands_idx
+= len
;
1206 commands
[commands_idx
++] = '\n';
1209 /* Determine if this target should be made default. We used to do
1210 this in record_files() but because of the delayed target recording
1211 and because preprocessor directives are legal in target's commands
1212 it is too late. Consider this fragment for example:
1216 ifeq ($(.DEFAULT_GOAL),foo)
1220 Because the target is not recorded until after ifeq directive is
1221 evaluated the .DEFAULT_GOAL does not contain foo yet as one
1222 would expect. Because of this we have to move some of the logic
1225 if (**default_goal_name
== '\0' && set_default
)
1229 struct nameseq
*t
= filenames
;
1231 for (; t
!= 0; t
= t
->next
)
1236 /* We have nothing to do if this is an implicit rule. */
1237 if (strchr (name
, '%') != 0)
1240 /* See if this target's name does not start with a `.',
1241 unless it contains a slash. */
1242 if (*name
== '.' && strchr (name
, '/') == 0
1243 #ifdef HAVE_DOS_PATHS
1244 && strchr (name
, '\\') == 0
1250 /* If this file is a suffix, don't let it be
1251 the default goal file. */
1252 for (d
= suffix_file
->deps
; d
!= 0; d
= d
->next
)
1254 register struct dep
*d2
;
1255 if (*dep_name (d
) != '.' && streq (name
, dep_name (d
)))
1260 for (d2
= suffix_file
->deps
; d2
!= 0; d2
= d2
->next
)
1262 register unsigned int len
= strlen (dep_name (d2
));
1263 if (!strneq (name
, dep_name (d2
), len
))
1265 if (streq (name
+ len
, dep_name (d
)))
1278 define_variable_global (".DEFAULT_GOAL", 13, t
->name
,
1288 /* We get here except in the case that we just read a rule line.
1289 Record now the last rule we read, so following spurious
1290 commands are properly diagnosed. */
1292 record_waiting_files ();
1297 if (conditionals
->if_cmds
)
1298 fatal (fstart
, _("missing `endif'"));
1300 /* At eof, record the last rule. */
1301 record_waiting_files ();
1304 free ((char *) collapsed
);
1305 free ((char *) commands
);
1311 /* Remove comments from LINE.
1312 This is done by copying the text at LINE onto itself. */
1315 remove_comments (char *line
)
1319 comment
= find_char_unquote (line
, '#', 0, 0, 0);
1322 /* Cut off the line at the #. */
1326 /* Execute a `define' directive.
1327 The first line has already been read, and NAME is the name of
1328 the variable to be defined. The following lines remain to be read. */
1331 do_define (char *name
, unsigned int namelen
,
1332 enum variable_origin origin
, struct ebuffer
*ebuf
)
1334 struct floc defstart
;
1337 unsigned int length
= 100;
1338 char *definition
= (char *) xmalloc (length
);
1339 unsigned int idx
= 0;
1342 /* Expand the variable name. */
1343 char *var
= (char *) alloca (namelen
+ 1);
1344 bcopy (name
, var
, namelen
);
1345 var
[namelen
] = '\0';
1346 var
= variable_expand (var
);
1348 defstart
= ebuf
->floc
;
1355 nlines
= readline (ebuf
);
1356 ebuf
->floc
.lineno
+= nlines
;
1358 /* If there is nothing left to eval, we're done. */
1362 line
= ebuf
->buffer
;
1364 collapse_continuations (line
);
1366 /* If the line doesn't begin with a tab, test to see if it introduces
1367 another define, or ends one. */
1369 /* Stop if we find an 'endef' */
1370 if (line
[0] != '\t')
1372 p
= next_token (line
);
1375 /* If this is another 'define', increment the level count. */
1376 if ((len
== 6 || (len
> 6 && isblank ((unsigned char)p
[6])))
1377 && strneq (p
, "define", 6))
1380 /* If this is an 'endef', decrement the count. If it's now 0,
1381 we've found the last one. */
1382 else if ((len
== 5 || (len
> 5 && isblank ((unsigned char)p
[5])))
1383 && strneq (p
, "endef", 5))
1386 remove_comments (p
);
1387 if (*next_token (p
) != '\0')
1389 _("Extraneous text after `endef' directive"));
1393 /* Define the variable. */
1395 definition
[0] = '\0';
1397 definition
[idx
- 1] = '\0';
1399 /* Always define these variables in the global set. */
1400 define_variable_global (var
, strlen (var
), definition
,
1401 origin
, 1, &defstart
);
1408 /* Otherwise add this line to the variable definition. */
1409 len
= strlen (line
);
1410 if (idx
+ len
+ 1 > length
)
1412 length
= (idx
+ len
) * 2;
1413 definition
= (char *) xrealloc (definition
, length
+ 1);
1416 bcopy (line
, &definition
[idx
], len
);
1418 /* Separate lines with a newline. */
1419 definition
[idx
++] = '\n';
1423 fatal (&defstart
, _("missing `endef', unterminated `define'"));
1429 /* Interpret conditional commands "ifdef", "ifndef", "ifeq",
1430 "ifneq", "else" and "endif".
1431 LINE is the input line, with the command as its first word.
1433 FILENAME and LINENO are the filename and line number in the
1434 current makefile. They are used for error messages.
1436 Value is -2 if the line is not a conditional at all,
1437 -1 if the line is an invalid conditional,
1438 0 if following text should be interpreted,
1439 1 if following text should be ignored. */
1442 conditional_line (char *line
, int len
, const struct floc
*flocp
)
1445 enum { c_ifdef
, c_ifndef
, c_ifeq
, c_ifneq
, c_else
, c_endif
} cmdtype
;
1449 /* Compare a word, both length and contents. */
1450 #define word1eq(s) (len == sizeof(s)-1 && strneq (s, line, sizeof(s)-1))
1451 #define chkword(s, t) if (word1eq (s)) { cmdtype = (t); cmdname = (s); }
1453 /* Make sure this line is a conditional. */
1454 chkword ("ifdef", c_ifdef
)
1455 else chkword ("ifndef", c_ifndef
)
1456 else chkword ("ifeq", c_ifeq
)
1457 else chkword ("ifneq", c_ifneq
)
1458 else chkword ("else", c_else
)
1459 else chkword ("endif", c_endif
)
1463 /* Found one: skip past it and any whitespace after it. */
1464 line
= next_token (line
+ len
);
1466 #define EXTRANEOUS() error (flocp, _("Extraneous text after `%s' directive"), cmdname)
1468 /* An 'endif' cannot contain extra text, and reduces the if-depth by 1 */
1469 if (cmdtype
== c_endif
)
1474 if (!conditionals
->if_cmds
)
1475 fatal (flocp
, _("extraneous `%s'"), cmdname
);
1477 --conditionals
->if_cmds
;
1482 /* An 'else' statement can either be simple, or it can have another
1483 conditional after it. */
1484 if (cmdtype
== c_else
)
1488 if (!conditionals
->if_cmds
)
1489 fatal (flocp
, _("extraneous `%s'"), cmdname
);
1491 o
= conditionals
->if_cmds
- 1;
1493 if (conditionals
->seen_else
[o
])
1494 fatal (flocp
, _("only one `else' per conditional"));
1496 /* Change the state of ignorance. */
1497 switch (conditionals
->ignoring
[o
])
1500 /* We've just been interpreting. Never do it again. */
1501 conditionals
->ignoring
[o
] = 2;
1504 /* We've never interpreted yet. Maybe this time! */
1505 conditionals
->ignoring
[o
] = 0;
1509 /* It's a simple 'else'. */
1512 conditionals
->seen_else
[o
] = 1;
1516 /* The 'else' has extra text. That text must be another conditional
1517 and cannot be an 'else' or 'endif'. */
1519 /* Find the length of the next word. */
1520 for (p
= line
+1; *p
!= '\0' && !isspace ((unsigned char)*p
); ++p
)
1524 /* If it's 'else' or 'endif' or an illegal conditional, fail. */
1525 if (word1eq("else") || word1eq("endif")
1526 || conditional_line (line
, len
, flocp
) < 0)
1530 /* conditional_line() created a new level of conditional.
1531 Raise it back to this level. */
1532 if (conditionals
->ignoring
[o
] < 2)
1533 conditionals
->ignoring
[o
] = conditionals
->ignoring
[o
+1];
1534 --conditionals
->if_cmds
;
1540 if (conditionals
->allocated
== 0)
1542 conditionals
->allocated
= 5;
1543 conditionals
->ignoring
= (char *) xmalloc (conditionals
->allocated
);
1544 conditionals
->seen_else
= (char *) xmalloc (conditionals
->allocated
);
1547 o
= conditionals
->if_cmds
++;
1548 if (conditionals
->if_cmds
> conditionals
->allocated
)
1550 conditionals
->allocated
+= 5;
1551 conditionals
->ignoring
= (char *)
1552 xrealloc (conditionals
->ignoring
, conditionals
->allocated
);
1553 conditionals
->seen_else
= (char *)
1554 xrealloc (conditionals
->seen_else
, conditionals
->allocated
);
1557 /* Record that we have seen an `if...' but no `else' so far. */
1558 conditionals
->seen_else
[o
] = 0;
1560 /* Search through the stack to see if we're already ignoring. */
1561 for (i
= 0; i
< o
; ++i
)
1562 if (conditionals
->ignoring
[i
])
1564 /* We are already ignoring, so just push a level to match the next
1565 "else" or "endif", and keep ignoring. We don't want to expand
1566 variables in the condition. */
1567 conditionals
->ignoring
[o
] = 1;
1571 if (cmdtype
== c_ifdef
|| cmdtype
== c_ifndef
)
1577 /* Expand the thing we're looking up, so we can use indirect and
1578 constructed variable names. */
1579 var
= allocated_variable_expand (line
);
1581 /* Make sure there's only one variable name to test. */
1582 p
= end_of_token (var
);
1589 v
= lookup_variable (var
, i
);
1591 conditionals
->ignoring
[o
] =
1592 ((v
!= 0 && *v
->value
!= '\0') == (cmdtype
== c_ifndef
));
1598 /* "Ifeq" or "ifneq". */
1601 char termin
= *line
== '(' ? ',' : *line
;
1603 if (termin
!= ',' && termin
!= '"' && termin
!= '\'')
1607 /* Find the end of the first string. */
1611 for (; *line
!= '\0'; ++line
)
1614 else if (*line
== ')')
1616 else if (*line
== ',' && count
<= 0)
1620 while (*line
!= '\0' && *line
!= termin
)
1628 /* Strip blanks after the first string. */
1630 while (isblank ((unsigned char)p
[-1]))
1637 s2
= variable_expand (s1
);
1638 /* We must allocate a new copy of the expanded string because
1639 variable_expand re-uses the same buffer. */
1641 s1
= (char *) alloca (len
+ 1);
1642 bcopy (s2
, s1
, len
+ 1);
1645 /* Find the start of the second string. */
1646 line
= next_token (line
);
1648 termin
= termin
== ',' ? ')' : *line
;
1649 if (termin
!= ')' && termin
!= '"' && termin
!= '\'')
1652 /* Find the end of the second string. */
1655 register int count
= 0;
1656 s2
= next_token (line
);
1657 for (line
= s2
; *line
!= '\0'; ++line
)
1661 else if (*line
== ')')
1674 while (*line
!= '\0' && *line
!= termin
)
1682 line
= next_token (++line
);
1686 s2
= variable_expand (s2
);
1687 conditionals
->ignoring
[o
] = (streq (s1
, s2
) == (cmdtype
== c_ifneq
));
1691 /* Search through the stack to see if we're ignoring. */
1692 for (i
= 0; i
< conditionals
->if_cmds
; ++i
)
1693 if (conditionals
->ignoring
[i
])
1698 /* Remove duplicate dependencies in CHAIN. */
1700 static unsigned long
1701 dep_hash_1 (const void *key
)
1703 return_STRING_HASH_1 (dep_name ((struct dep
const *) key
));
1706 static unsigned long
1707 dep_hash_2 (const void *key
)
1709 return_STRING_HASH_2 (dep_name ((struct dep
const *) key
));
1713 dep_hash_cmp (const void *x
, const void *y
)
1715 struct dep
*dx
= (struct dep
*) x
;
1716 struct dep
*dy
= (struct dep
*) y
;
1717 int cmp
= strcmp (dep_name (dx
), dep_name (dy
));
1719 /* If the names are the same but ignore_mtimes are not equal, one of these
1720 is an order-only prerequisite and one isn't. That means that we should
1721 remove the one that isn't and keep the one that is. */
1723 if (!cmp
&& dx
->ignore_mtime
!= dy
->ignore_mtime
)
1724 dx
->ignore_mtime
= dy
->ignore_mtime
= 0;
1731 uniquize_deps (struct dep
*chain
)
1733 struct hash_table deps
;
1734 register struct dep
**depp
;
1736 hash_init (&deps
, 500, dep_hash_1
, dep_hash_2
, dep_hash_cmp
);
1738 /* Make sure that no dependencies are repeated. This does not
1739 really matter for the purpose of updating targets, but it
1740 might make some names be listed twice for $^ and $?. */
1745 struct dep
*dep
= *depp
;
1746 struct dep
**dep_slot
= (struct dep
**) hash_find_slot (&deps
, dep
);
1747 if (HASH_VACANT (*dep_slot
))
1749 hash_insert_at (&deps
, dep
, dep_slot
);
1754 /* Don't bother freeing duplicates.
1755 It's dangerous and little benefit accrues. */
1760 hash_free (&deps
, 0);
1763 /* Record target-specific variable values for files FILENAMES.
1764 TWO_COLON is nonzero if a double colon was used.
1766 The links of FILENAMES are freed, and so are any names in it
1767 that are not incorporated into other data structures.
1769 If the target is a pattern, add the variable to the pattern-specific
1770 variable value list. */
1773 record_target_var (struct nameseq
*filenames
, char *defn
,
1774 enum variable_origin origin
, int exported
,
1775 const struct floc
*flocp
)
1777 struct nameseq
*nextf
;
1778 struct variable_set_list
*global
;
1780 global
= current_variable_set_list
;
1782 /* If the variable is an append version, store that but treat it as a
1783 normal recursive variable. */
1785 for (; filenames
!= 0; filenames
= nextf
)
1788 register char *name
= filenames
->name
;
1791 struct pattern_var
*p
;
1793 nextf
= filenames
->next
;
1794 free ((char *) filenames
);
1796 /* If it's a pattern target, then add it to the pattern-specific
1798 percent
= find_percent (name
);
1801 /* Get a reference for this pattern-specific variable struct. */
1802 p
= create_pattern_var (name
, percent
);
1803 p
->variable
.fileinfo
= *flocp
;
1804 /* I don't think this can fail since we already determined it was a
1805 variable definition. */
1806 v
= parse_variable_definition (&p
->variable
, defn
);
1809 if (v
->flavor
== f_simple
)
1810 v
->value
= allocated_variable_expand (v
->value
);
1812 v
->value
= xstrdup (v
->value
);
1820 /* Get a file reference for this file, and initialize it.
1821 We don't want to just call enter_file() because that allocates a
1822 new entry if the file is a double-colon, which we don't want in
1824 f
= lookup_file (name
);
1826 f
= enter_file (name
);
1827 else if (f
->double_colon
)
1828 f
= f
->double_colon
;
1830 initialize_file_variables (f
, 1);
1833 current_variable_set_list
= f
->variables
;
1834 v
= try_variable_definition (flocp
, defn
, origin
, 1);
1836 error (flocp
, _("Malformed target-specific variable definition"));
1837 current_variable_set_list
= global
;
1840 /* Set up the variable to be *-specific. */
1843 v
->export
= exported
? v_export
: v_default
;
1845 /* If it's not an override, check to see if there was a command-line
1846 setting. If so, reset the value. */
1847 if (origin
!= o_override
)
1849 struct variable
*gv
;
1850 int len
= strlen(v
->name
);
1852 gv
= lookup_variable (v
->name
, len
);
1853 if (gv
&& (gv
->origin
== o_env_override
|| gv
->origin
== o_command
))
1857 v
->value
= xstrdup (gv
->value
);
1858 v
->origin
= gv
->origin
;
1859 v
->recursive
= gv
->recursive
;
1864 /* Free name if not needed further. */
1865 if (name
!= fname
&& (name
< fname
|| name
> fname
+ strlen (fname
)))
1870 /* Record a description line for files FILENAMES,
1871 with dependencies DEPS, commands to execute described
1872 by COMMANDS and COMMANDS_IDX, coming from FILENAME:COMMANDS_STARTED.
1873 TWO_COLON is nonzero if a double colon was used.
1874 If not nil, PATTERN is the `%' pattern to make this
1875 a static pattern rule, and PATTERN_PERCENT is a pointer
1876 to the `%' within it.
1878 The links of FILENAMES are freed, and so are any names in it
1879 that are not incorporated into other data structures. */
1882 record_files (struct nameseq
*filenames
, char *pattern
, char *pattern_percent
,
1883 struct dep
*deps
, unsigned int cmds_started
, char *commands
,
1884 unsigned int commands_idx
, int two_colon
,
1885 const struct floc
*flocp
)
1887 struct nameseq
*nextf
;
1889 unsigned int max_targets
= 0, target_idx
= 0;
1890 char **targets
= 0, **target_percents
= 0;
1891 struct commands
*cmds
;
1893 /* If we've already snapped deps, that means we're in an eval being
1894 resolved after the makefiles have been read in. We can't add more rules
1895 at this time, since they won't get snapped and we'll get core dumps.
1896 See Savannah bug # 12124. */
1898 fatal (flocp
, _("prerequisites cannot be defined in command scripts"));
1900 if (commands_idx
> 0)
1902 cmds
= (struct commands
*) xmalloc (sizeof (struct commands
));
1903 cmds
->fileinfo
.filenm
= flocp
->filenm
;
1904 cmds
->fileinfo
.lineno
= cmds_started
;
1905 cmds
->commands
= savestring (commands
, commands_idx
);
1906 cmds
->command_lines
= 0;
1911 for (; filenames
!= 0; filenames
= nextf
)
1913 char *name
= filenames
->name
;
1915 struct dep
*this = 0;
1916 char *implicit_percent
;
1918 nextf
= filenames
->next
;
1921 /* Check for special targets. Do it here instead of, say, snap_deps()
1922 so that we can immediately use the value. */
1924 if (streq (name
, ".POSIX"))
1926 else if (streq (name
, ".SECONDEXPANSION"))
1927 second_expansion
= 1;
1929 implicit_percent
= find_percent (name
);
1930 implicit
|= implicit_percent
!= 0;
1932 if (implicit
&& pattern
!= 0)
1933 fatal (flocp
, _("mixed implicit and static pattern rules"));
1935 if (implicit
&& implicit_percent
== 0)
1936 fatal (flocp
, _("mixed implicit and normal rules"));
1943 targets
= (char **) xmalloc (5 * sizeof (char *));
1944 target_percents
= (char **) xmalloc (5 * sizeof (char *));
1947 else if (target_idx
== max_targets
- 1)
1950 targets
= (char **) xrealloc ((char *) targets
,
1951 max_targets
* sizeof (char *));
1953 = (char **) xrealloc ((char *) target_percents
,
1954 max_targets
* sizeof (char *));
1956 targets
[target_idx
] = name
;
1957 target_percents
[target_idx
] = implicit_percent
;
1962 /* If this is a static pattern rule:
1963 `targets: target%pattern: dep%pattern; cmds',
1964 make sure the pattern matches this target name. */
1965 if (pattern
&& !pattern_matches (pattern
, pattern_percent
, name
))
1966 error (flocp
, _("target `%s' doesn't match the target pattern"), name
);
1969 /* If there are multiple filenames, copy the chain DEPS for all but
1970 the last one. It is not safe for the same deps to go in more
1971 than one place in the database. */
1972 this = nextf
!= 0 ? copy_dep_chain (deps
) : deps
;
1973 this->need_2nd_expansion
= (second_expansion
1974 && strchr (this->name
, '$'));
1979 /* Single-colon. Combine these dependencies
1980 with others in file's existing record, if any. */
1981 f
= enter_file (name
);
1983 if (f
->double_colon
)
1985 _("target file `%s' has both : and :: entries"), f
->name
);
1987 /* If CMDS == F->CMDS, this target was listed in this rule
1988 more than once. Just give a warning since this is harmless. */
1989 if (cmds
!= 0 && cmds
== f
->cmds
)
1991 _("target `%s' given more than once in the same rule."),
1994 /* Check for two single-colon entries both with commands.
1995 Check is_target so that we don't lose on files such as .c.o
1996 whose commands were preinitialized. */
1997 else if (cmds
!= 0 && f
->cmds
!= 0 && f
->is_target
)
1999 error (&cmds
->fileinfo
,
2000 _("warning: overriding commands for target `%s'"),
2002 error (&f
->cmds
->fileinfo
,
2003 _("warning: ignoring old commands for target `%s'"),
2009 /* Defining .DEFAULT with no deps or cmds clears it. */
2010 if (f
== default_file
&& this == 0 && cmds
== 0)
2015 /* Defining .SUFFIXES with no dependencies clears out the list of
2017 if (f
== suffix_file
&& this == 0)
2019 free_dep_chain (f
->deps
);
2024 /* Add the file's old deps and the new ones in THIS together. */
2028 struct dep
**d_ptr
= &f
->deps
;
2030 while ((*d_ptr
)->next
!= 0)
2031 d_ptr
= &(*d_ptr
)->next
;
2034 /* This is the rule with commands, so put its deps
2035 last. The rationale behind this is that $< expands to
2036 the first dep in the chain, and commands use $<
2037 expecting to get the dep that rule specifies. However
2038 the second expansion algorithm reverses the order thus
2039 we need to make it last here. */
2040 (*d_ptr
)->next
= this;
2043 /* This is the rule without commands. Put its
2044 dependencies at the end but before dependencies from
2045 the rule with commands (if any). This way everything
2046 appears in makefile order. */
2050 this->next
= *d_ptr
;
2054 (*d_ptr
)->next
= this;
2060 /* This is a hack. I need a way to communicate to snap_deps()
2061 that the last dependency line in this file came with commands
2062 (so that logic in snap_deps() can put it in front and all
2063 this $< -logic works). I cannot simply rely on file->cmds
2064 being not 0 because of the cases like the following:
2070 I am going to temporarily "borrow" UPDATING member in
2071 `struct file' for this. */
2079 /* Double-colon. Make a new record even if there already is one. */
2080 f
= lookup_file (name
);
2082 /* Check for both : and :: rules. Check is_target so
2083 we don't lose on default suffix rules or makefiles. */
2084 if (f
!= 0 && f
->is_target
&& !f
->double_colon
)
2086 _("target file `%s' has both : and :: entries"), f
->name
);
2087 f
= enter_file (name
);
2088 /* If there was an existing entry and it was a double-colon entry,
2089 enter_file will have returned a new one, making it the prev
2090 pointer of the old one, and setting its double_colon pointer to
2092 if (f
->double_colon
== 0)
2093 /* This is the first entry for this name, so we must set its
2094 double_colon pointer to itself. */
2095 f
->double_colon
= f
;
2101 /* If this is a static pattern rule, set the stem to the part of its
2102 name that matched the `%' in the pattern, so you can use $* in the
2106 static char *percent
= "%";
2107 char *buffer
= variable_expand ("");
2108 char *o
= patsubst_expand (buffer
, name
, pattern
, percent
,
2109 pattern_percent
+1, percent
+1);
2110 f
->stem
= savestring (buffer
, o
- buffer
);
2112 this->staticpattern
= 1;
2115 /* Free name if not needed further. */
2116 if (f
!= 0 && name
!= f
->name
2117 && (name
< f
->name
|| name
> f
->name
+ strlen (f
->name
)))
2123 /* If this target is a default target, update DEFAULT_GOAL_FILE. */
2124 if (streq (*default_goal_name
, name
)
2125 && (default_goal_file
== 0
2126 || ! streq (default_goal_file
->name
, name
)))
2127 default_goal_file
= f
;
2132 targets
[target_idx
] = 0;
2133 target_percents
[target_idx
] = 0;
2135 deps
->need_2nd_expansion
= second_expansion
;
2136 create_pattern_rule (targets
, target_percents
, two_colon
, deps
, cmds
, 1);
2137 free ((char *) target_percents
);
2141 /* Search STRING for an unquoted STOPCHAR or blank (if BLANK is nonzero).
2142 Backslashes quote STOPCHAR, blanks if BLANK is nonzero, and backslash.
2143 Quoting backslashes are removed from STRING by compacting it into
2144 itself. Returns a pointer to the first unquoted STOPCHAR if there is
2145 one, or nil if there are none. STOPCHARs inside variable references are
2146 ignored if IGNOREVARS is true.
2148 STOPCHAR _cannot_ be '$' if IGNOREVARS is true. */
2151 find_char_unquote (char *string
, int stop1
, int stop2
, int blank
,
2154 unsigned int string_len
= 0;
2155 register char *p
= string
;
2163 while (*p
!= '\0' && *p
!= ignorevars
&& *p
!= stop1
&& *p
!= stop2
2164 && ! isblank ((unsigned char) *p
))
2167 while (*p
!= '\0' && *p
!= ignorevars
&& *p
!= stop1
&& *p
!= stop2
)
2170 while (*p
!= '\0' && *p
!= ignorevars
&& *p
!= stop1
2171 && ! isblank ((unsigned char) *p
))
2174 while (*p
!= '\0' && *p
!= ignorevars
&& *p
!= stop1
)
2180 /* If we stopped due to a variable reference, skip over its contents. */
2181 if (*p
== ignorevars
)
2183 char openparen
= p
[1];
2187 /* Skip the contents of a non-quoted, multi-char variable ref. */
2188 if (openparen
== '(' || openparen
== '{')
2190 unsigned int pcount
= 1;
2191 char closeparen
= (openparen
== '(' ? ')' : '}');
2195 if (*p
== openparen
)
2197 else if (*p
== closeparen
)
2207 /* Skipped the variable reference: look for STOPCHARS again. */
2211 if (p
> string
&& p
[-1] == '\\')
2213 /* Search for more backslashes. */
2214 register int i
= -2;
2215 while (&p
[i
] >= string
&& p
[i
] == '\\')
2218 /* Only compute the length if really needed. */
2219 if (string_len
== 0)
2220 string_len
= strlen (string
);
2221 /* The number of backslashes is now -I.
2222 Copy P over itself to swallow half of them. */
2223 bcopy (&p
[i
/ 2], &p
[i
], (string_len
- (p
- string
)) - (i
/ 2) + 1);
2226 /* All the backslashes quoted each other; the STOPCHAR was
2230 /* The STOPCHAR was quoted by a backslash. Look for another. */
2233 /* No backslash in sight. */
2237 /* Never hit a STOPCHAR or blank (with BLANK nonzero). */
2241 /* Search PATTERN for an unquoted %. */
2244 find_percent (char *pattern
)
2246 return find_char_unquote (pattern
, '%', 0, 0, 0);
2249 /* Parse a string into a sequence of filenames represented as a
2250 chain of struct nameseq's in reverse order and return that chain.
2252 The string is passed as STRINGP, the address of a string pointer.
2253 The string pointer is updated to point at the first character
2254 not parsed, which either is a null char or equals STOPCHAR.
2256 SIZE is how big to construct chain elements.
2257 This is useful if we want them actually to be other structures
2258 that have room for additional info.
2260 If STRIP is nonzero, strip `./'s off the beginning. */
2263 parse_file_seq (char **stringp
, int stopchar
, unsigned int size
, int strip
)
2265 struct nameseq
*new = 0;
2266 struct nameseq
*new1
, *lastnew1
;
2272 # define VMS_COMMA ','
2274 # define VMS_COMMA 0
2279 /* Skip whitespace; see if any more names are left. */
2286 /* Yes, find end of next name. */
2288 p
= find_char_unquote (q
, stopchar
, VMS_COMMA
, 1, 0);
2290 /* convert comma separated list to space separated */
2295 if (stopchar
== ':' && p
&& *p
== ':'
2296 && !(isspace ((unsigned char)p
[1]) || !p
[1]
2297 || isspace ((unsigned char)p
[-1])))
2299 p
= find_char_unquote (p
+1, stopchar
, VMS_COMMA
, 1, 0);
2302 #ifdef HAVE_DOS_PATHS
2303 /* For DOS paths, skip a "C:\..." or a "C:/..." until we find the
2304 first colon which isn't followed by a slash or a backslash.
2305 Note that tokens separated by spaces should be treated as separate
2306 tokens since make doesn't allow path names with spaces */
2307 if (stopchar
== ':')
2308 while (p
!= 0 && !isspace ((unsigned char)*p
) &&
2309 (p
[1] == '\\' || p
[1] == '/') && isalpha ((unsigned char)p
[-1]))
2310 p
= find_char_unquote (p
+ 1, stopchar
, VMS_COMMA
, 1, 0);
2317 /* Skip leading `[]'s. */
2318 while (p
- q
> 2 && q
[0] == '[' && q
[1] == ']')
2320 /* Skip leading `./'s. */
2321 while (p
- q
> 2 && q
[0] == '.' && q
[1] == '/')
2324 q
+= 2; /* Skip "./". */
2325 while (q
< p
&& *q
== '/')
2326 /* Skip following slashes: ".//foo" is "foo", not "/foo". */
2330 /* Extract the filename just found, and skip it. */
2333 /* ".///" was stripped to "". */
2338 name
= savestring ("", 0);
2340 name
= savestring ("./", 2);
2345 /* VMS filenames can have a ':' in them but they have to be '\'ed but we need
2346 * to remove this '\' before we can use the filename.
2347 * Savestring called because q may be read-only string constant.
2350 char *qbase
= xstrdup (q
);
2351 char *pbase
= qbase
+ (p
-q
);
2358 if (*q1
== '\\' && *(q1
+1) == ':')
2365 name
= savestring (qbase
, p1
- qbase
);
2369 name
= savestring (q
, p
- q
);
2372 /* Add it to the front of the chain. */
2373 new1
= (struct nameseq
*) xmalloc (size
);
2381 /* Look for multi-word archive references.
2382 They are indicated by a elt ending with an unmatched `)' and
2383 an elt further down the chain (i.e., previous in the file list)
2384 with an unmatched `(' (e.g., "lib(mem"). */
2389 if (new1
->name
[0] != '(' /* Don't catch "(%)" and suchlike. */
2390 && new1
->name
[strlen (new1
->name
) - 1] == ')'
2391 && strchr (new1
->name
, '(') == 0)
2393 /* NEW1 ends with a `)' but does not contain a `('.
2394 Look back for an elt with an opening `(' but no closing `)'. */
2396 struct nameseq
*n
= new1
->next
, *lastn
= new1
;
2398 while (n
!= 0 && (paren
= strchr (n
->name
, '(')) == 0)
2404 /* Ignore something starting with `(', as that cannot actually
2405 be an archive-member reference (and treating it as such
2406 results in an empty file name, which causes much lossage). */
2407 && n
->name
[0] != '(')
2409 /* N is the first element in the archive group.
2410 Its name looks like "lib(mem" (with no closing `)'). */
2414 /* Copy "lib(" into LIBNAME. */
2416 libname
= (char *) alloca (paren
- n
->name
+ 1);
2417 bcopy (n
->name
, libname
, paren
- n
->name
);
2418 libname
[paren
- n
->name
] = '\0';
2422 /* N was just "lib(", part of something like "lib( a b)".
2423 Edit it out of the chain and free its storage. */
2424 lastn
->next
= n
->next
;
2427 /* LASTN->next is the new stopping elt for the loop below. */
2432 /* Replace N's name with the full archive reference. */
2433 name
= concat (libname
, paren
, ")");
2438 if (new1
->name
[1] == '\0')
2440 /* NEW1 is just ")", part of something like "lib(a b )".
2441 Omit it from the chain and free its storage. */
2445 lastnew1
->next
= new1
->next
;
2449 free ((char *) lastn
);
2453 /* Replace also NEW1->name, which already has closing `)'. */
2454 name
= concat (libname
, new1
->name
, "");
2460 /* Trace back from NEW1 (the end of the list) until N
2461 (the beginning of the list), rewriting each name
2462 with the full archive reference. */
2466 name
= concat (libname
, new1
->name
, ")");
2475 /* No frobnication happening. Just step down the list. */
2492 /* Find the next line of text in an eval buffer, combining continuation lines
2494 Return the number of actual lines read (> 1 if continuation lines).
2495 Returns -1 if there's nothing left in the buffer.
2497 After this function, ebuf->buffer points to the first character of the
2501 /* Read a line of text from a STRING.
2502 Since we aren't really reading from a file, don't bother with linenumbers.
2505 static unsigned long
2506 readstring (struct ebuffer
*ebuf
)
2510 /* If there is nothing left in this buffer, return 0. */
2511 if (ebuf
->bufnext
>= ebuf
->bufstart
+ ebuf
->size
)
2514 /* Set up a new starting point for the buffer, and find the end of the
2515 next logical line (taking into account backslash/newline pairs). */
2517 eol
= ebuf
->buffer
= ebuf
->bufnext
;
2525 /* Find the next newline. At EOS, stop. */
2526 eol
= p
= strchr (eol
, '\n');
2529 ebuf
->bufnext
= ebuf
->bufstart
+ ebuf
->size
+ 1;
2533 /* Found a newline; if it's escaped continue; else we're done. */
2534 while (p
> bol
&& *(--p
) == '\\')
2535 backslash
= !backslash
;
2541 /* Overwrite the newline char. */
2543 ebuf
->bufnext
= eol
+1;
2549 readline (struct ebuffer
*ebuf
)
2556 /* The behaviors between string and stream buffers are different enough to
2557 warrant different functions. Do the Right Thing. */
2560 return readstring (ebuf
);
2562 /* When reading from a file, we always start over at the beginning of the
2563 buffer for each new line. */
2565 p
= start
= ebuf
->bufstart
;
2566 end
= p
+ ebuf
->size
;
2569 while (fgets (p
, end
- p
, ebuf
->fp
) != 0)
2578 /* This only happens when the first thing on the line is a '\0'.
2579 It is a pretty hopeless case, but (wonder of wonders) Athena
2580 lossage strikes again! (xmkmf puts NULs in its makefiles.)
2581 There is nothing really to be done; we synthesize a newline so
2582 the following line doesn't appear to be part of this line. */
2584 _("warning: NUL character seen; rest of line ignored"));
2589 /* Jump past the text we just read. */
2592 /* If the last char isn't a newline, the whole line didn't fit into the
2593 buffer. Get some more buffer and try again. */
2597 /* We got a newline, so add one to the count of lines. */
2600 #if !defined(WINDOWS32) && !defined(__MSDOS__) && !defined(__EMX__)
2601 /* Check to see if the line was really ended with CRLF; if so ignore
2603 if ((p
- start
) > 1 && p
[-2] == '\r')
2611 for (p2
= p
- 2; p2
>= start
; --p2
)
2615 backslash
= !backslash
;
2624 /* It was a backslash/newline combo. If we have more space, read
2629 /* We need more space at the end of our buffer, so realloc it.
2630 Make sure to preserve the current offset of p. */
2633 unsigned long off
= p
- start
;
2635 start
= ebuf
->buffer
= ebuf
->bufstart
= (char *) xrealloc (start
,
2638 end
= start
+ ebuf
->size
;
2643 if (ferror (ebuf
->fp
))
2644 pfatal_with_name (ebuf
->floc
.filenm
);
2646 /* If we found some lines, return how many.
2647 If we didn't, but we did find _something_, that indicates we read the last
2648 line of a file with no final newline; return 1.
2649 If we read nothing, we're at EOF; return -1. */
2651 return nlines
? nlines
: p
== ebuf
->bufstart
? -1 : 1;
2654 /* Parse the next "makefile word" from the input buffer, and return info
2657 A "makefile word" is one of:
2659 w_bogus Should never happen
2661 w_static A static word; cannot be expanded
2662 w_variable A word containing one or more variables/functions
2664 w_dcolon A double-colon
2665 w_semicolon A semicolon
2666 w_varassign A variable assignment operator (=, :=, +=, or ?=)
2668 Note that this function is only used when reading certain parts of the
2669 makefile. Don't use it where special rules hold sway (RHS of a variable,
2670 in a command list, etc.) */
2672 static enum make_word_type
2673 get_next_mword (char *buffer
, char *delim
, char **startp
, unsigned int *length
)
2675 enum make_word_type wtype
= w_bogus
;
2676 char *p
= buffer
, *beg
;
2679 /* Skip any leading whitespace. */
2680 while (isblank ((unsigned char)*p
))
2692 wtype
= w_semicolon
;
2696 wtype
= w_varassign
;
2710 wtype
= w_varassign
;
2720 wtype
= w_varassign
;
2725 if (delim
&& strchr (delim
, c
))
2730 /* Did we find something? If so, return now. */
2731 if (wtype
!= w_bogus
)
2734 /* This is some non-operator word. A word consists of the longest
2735 string of characters that doesn't contain whitespace, one of [:=#],
2736 or [?+]=, or one of the chars in the DELIM string. */
2738 /* We start out assuming a static word; if we see a variable we'll
2739 adjust our assumptions then. */
2742 /* We already found the first value of "c", above. */
2757 #ifdef HAVE_DOS_PATHS
2758 /* A word CAN include a colon in its drive spec. The drive
2759 spec is allowed either at the beginning of a word, or as part
2760 of the archive member name, like in "libfoo.a(d:/foo/bar.o)". */
2762 && (*p
== '/' || *p
== '\\') && isalpha ((unsigned char)p
[-2])
2763 && (p
- beg
== 2 || p
[-3] == '(')))
2772 /* This is a variable reference, so note that it's expandable.
2773 Then read it to the matching close paren. */
2781 /* This is a single-letter variable reference. */
2784 for (count
=0; *p
!= '\0'; ++p
)
2788 else if (*p
== closeparen
&& --count
< 0)
2815 if (delim
&& strchr (delim
, c
))
2833 /* Construct the list of include directories
2834 from the arguments and the default list. */
2837 construct_include_path (char **arg_dirs
)
2839 register unsigned int i
;
2840 #ifdef VAXC /* just don't ask ... */
2845 /* Table to hold the dirs. */
2847 register unsigned int defsize
= (sizeof (default_include_directories
)
2848 / sizeof (default_include_directories
[0]));
2849 register unsigned int max
= 5;
2850 register char **dirs
= (char **) xmalloc ((5 + defsize
) * sizeof (char *));
2851 register unsigned int idx
= 0;
2857 /* First consider any dirs specified with -I switches.
2858 Ignore dirs that don't exist. */
2861 while (*arg_dirs
!= 0)
2863 char *dir
= *arg_dirs
++;
2868 char *expanded
= tilde_expand (dir
);
2873 EINTRLOOP (e
, stat (dir
, &stbuf
));
2874 if (e
== 0 && S_ISDIR (stbuf
.st_mode
))
2880 xrealloc ((char *) dirs
, (max
+ defsize
) * sizeof (char *));
2884 else if (dir
!= arg_dirs
[-1])
2888 /* Now add at the end the standard default dirs. */
2892 /* The environment variable $DJDIR holds the root of the
2893 DJGPP directory tree; add ${DJDIR}/include. */
2894 struct variable
*djdir
= lookup_variable ("DJDIR", 5);
2898 char *defdir
= (char *) xmalloc (strlen (djdir
->value
) + 8 + 1);
2900 strcat (strcpy (defdir
, djdir
->value
), "/include");
2901 dirs
[idx
++] = defdir
;
2906 for (i
= 0; default_include_directories
[i
] != 0; ++i
)
2910 EINTRLOOP (e
, stat (default_include_directories
[i
], &stbuf
));
2911 if (e
== 0 && S_ISDIR (stbuf
.st_mode
))
2912 dirs
[idx
++] = default_include_directories
[i
];
2917 /* Now compute the maximum length of any name in it. Also add each
2918 dir to the .INCLUDE_DIRS variable. */
2921 for (i
= 0; i
< idx
; ++i
)
2923 unsigned int len
= strlen (dirs
[i
]);
2924 /* If dir name is written with a trailing slash, discard it. */
2925 if (dirs
[i
][len
- 1] == '/')
2926 /* We can't just clobber a null in because it may have come from
2927 a literal string and literal strings may not be writable. */
2928 dirs
[i
] = savestring (dirs
[i
], len
- 1);
2929 if (len
> max_incl_len
)
2932 /* Append to .INCLUDE_DIRS. */
2933 do_variable_definition (NILF
, ".INCLUDE_DIRS", dirs
[i
],
2934 o_default
, f_append
, 0);
2937 include_directories
= dirs
;
2940 /* Expand ~ or ~USER at the beginning of NAME.
2941 Return a newly malloc'd string or 0. */
2944 tilde_expand (char *name
)
2947 if (name
[1] == '/' || name
[1] == '\0')
2949 extern char *getenv ();
2954 /* Turn off --warn-undefined-variables while we expand HOME. */
2955 int save
= warn_undefined_variables_flag
;
2956 warn_undefined_variables_flag
= 0;
2958 home_dir
= allocated_variable_expand ("$(HOME)");
2960 warn_undefined_variables_flag
= save
;
2963 is_variable
= home_dir
[0] != '\0';
2967 home_dir
= getenv ("HOME");
2969 #if !defined(_AMIGA) && !defined(WINDOWS32)
2970 if (home_dir
== 0 || home_dir
[0] == '\0')
2972 extern char *getlogin ();
2973 char *logname
= getlogin ();
2977 struct passwd
*p
= getpwnam (logname
);
2979 home_dir
= p
->pw_dir
;
2982 #endif /* !AMIGA && !WINDOWS32 */
2985 char *new = concat (home_dir
, "", name
+ 1);
2991 #if !defined(_AMIGA) && !defined(WINDOWS32)
2994 struct passwd
*pwent
;
2995 char *userend
= strchr (name
+ 1, '/');
2998 pwent
= getpwnam (name
+ 1);
3002 return xstrdup (pwent
->pw_dir
);
3004 return concat (pwent
->pw_dir
, "/", userend
+ 1);
3006 else if (userend
!= 0)
3009 #endif /* !AMIGA && !WINDOWS32 */
3014 /* Given a chain of struct nameseq's describing a sequence of filenames,
3015 in reverse of the intended order, return a new chain describing the
3016 result of globbing the filenames. The new chain is in forward order.
3017 The links of the old chain are freed or used in the new chain.
3018 Likewise for the names in the old chain.
3020 SIZE is how big to construct chain elements.
3021 This is useful if we want them actually to be other structures
3022 that have room for additional info. */
3025 multi_glob (struct nameseq
*chain
, unsigned int size
)
3027 extern void dir_setup_glob ();
3028 register struct nameseq
*new = 0;
3029 register struct nameseq
*old
;
3030 struct nameseq
*nexto
;
3033 dir_setup_glob (&gl
);
3035 for (old
= chain
; old
!= 0; old
= nexto
)
3043 if (old
->name
[0] == '~')
3045 char *newname
= tilde_expand (old
->name
);
3049 old
->name
= newname
;
3054 if (ar_name (old
->name
))
3056 /* OLD->name is an archive member reference.
3057 Replace it with the archive file name,
3058 and save the member name in MEMNAME.
3059 We will glob on the archive name and then
3060 reattach MEMNAME later. */
3062 ar_parse_name (old
->name
, &arname
, &memname
);
3068 #endif /* !NO_ARCHIVES */
3070 switch (glob (old
->name
, GLOB_NOCHECK
|GLOB_ALTDIRFUNC
, NULL
, &gl
))
3072 case 0: /* Success. */
3074 register int i
= gl
.gl_pathc
;
3080 /* Try to glob on MEMNAME within the archive. */
3081 struct nameseq
*found
3082 = ar_glob (gl
.gl_pathv
[i
], memname
, size
);
3085 /* No matches. Use MEMNAME as-is. */
3086 unsigned int alen
= strlen (gl
.gl_pathv
[i
]);
3087 unsigned int mlen
= strlen (memname
);
3089 = (struct nameseq
*) xmalloc (size
);
3090 if (size
> sizeof (struct nameseq
))
3091 bzero (((char *) elt
) + sizeof (struct nameseq
),
3092 size
- sizeof (struct nameseq
));
3093 elt
->name
= (char *) xmalloc (alen
+ 1 + mlen
+ 2);
3094 bcopy (gl
.gl_pathv
[i
], elt
->name
, alen
);
3095 elt
->name
[alen
] = '(';
3096 bcopy (memname
, &elt
->name
[alen
+ 1], mlen
);
3097 elt
->name
[alen
+ 1 + mlen
] = ')';
3098 elt
->name
[alen
+ 1 + mlen
+ 1] = '\0';
3104 /* Find the end of the FOUND chain. */
3105 struct nameseq
*f
= found
;
3106 while (f
->next
!= 0)
3109 /* Attach the chain being built to the end of the FOUND
3110 chain, and make FOUND the new NEW chain. */
3118 #endif /* !NO_ARCHIVES */
3120 struct nameseq
*elt
= (struct nameseq
*) xmalloc (size
);
3121 if (size
> sizeof (struct nameseq
))
3122 bzero (((char *) elt
) + sizeof (struct nameseq
),
3123 size
- sizeof (struct nameseq
));
3124 elt
->name
= xstrdup (gl
.gl_pathv
[i
]);
3136 fatal (NILF
, _("virtual memory exhausted"));