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
->need_2nd_expansion
= 0;
262 /* Tell update_goal_chain to bail out as soon as this file is
263 made, and main not to die if we can't make this file. */
264 d
->changed
= RM_DONTCARE
;
276 return read_makefiles
;
279 /* Install a new conditional and return the previous one. */
281 static struct conditionals
*
282 install_conditionals (struct conditionals
*new)
284 struct conditionals
*save
= conditionals
;
286 bzero ((char *) new, sizeof (*new));
292 /* Free the current conditionals and reinstate a saved one. */
295 restore_conditionals (struct conditionals
*saved
)
297 /* Free any space allocated by conditional_line. */
298 if (conditionals
->ignoring
)
299 free (conditionals
->ignoring
);
300 if (conditionals
->seen_else
)
301 free (conditionals
->seen_else
);
304 conditionals
= saved
;
308 eval_makefile (char *filename
, int flags
)
312 const struct floc
*curfile
;
316 ebuf
.floc
.filenm
= filename
;
317 ebuf
.floc
.lineno
= 1;
319 if (ISDB (DB_VERBOSE
))
321 printf (_("Reading makefile `%s'"), filename
);
322 if (flags
& RM_NO_DEFAULT_GOAL
)
323 printf (_(" (no default goal)"));
324 if (flags
& RM_INCLUDED
)
325 printf (_(" (search path)"));
326 if (flags
& RM_DONTCARE
)
327 printf (_(" (don't care)"));
328 if (flags
& RM_NO_TILDE
)
329 printf (_(" (no ~ expansion)"));
333 /* First, get a stream to read. */
335 /* Expand ~ in FILENAME unless it came from `include',
336 in which case it was already done. */
337 if (!(flags
& RM_NO_TILDE
) && filename
[0] == '~')
339 char *expanded
= tilde_expand (filename
);
344 ebuf
.fp
= fopen (filename
, "r");
345 /* Save the error code so we print the right message later. */
346 makefile_errno
= errno
;
348 /* If the makefile wasn't found and it's either a makefile from
349 the `MAKEFILES' variable or an included makefile,
350 search the included makefile search path for this makefile. */
351 if (ebuf
.fp
== 0 && (flags
& RM_INCLUDED
) && *filename
!= '/')
353 register unsigned int i
;
354 for (i
= 0; include_directories
[i
] != 0; ++i
)
356 char *name
= concat (include_directories
[i
], "/", filename
);
357 ebuf
.fp
= fopen (name
, "r");
368 /* Add FILENAME to the chain of read makefiles. */
369 deps
= (struct dep
*) xmalloc (sizeof (struct dep
));
370 deps
->next
= read_makefiles
;
371 read_makefiles
= deps
;
373 deps
->file
= lookup_file (filename
);
375 deps
->file
= enter_file (xstrdup (filename
));
376 if (filename
!= ebuf
.floc
.filenm
)
378 filename
= deps
->file
->name
;
379 deps
->changed
= flags
;
380 deps
->ignore_mtime
= 0;
381 deps
->need_2nd_expansion
= 0;
382 if (flags
& RM_DONTCARE
)
383 deps
->file
->dontcare
= 1;
385 /* If the makefile can't be found at all, give up entirely. */
389 /* If we did some searching, errno has the error from the last
390 attempt, rather from FILENAME itself. Restore it in case the
391 caller wants to use it in a message. */
392 errno
= makefile_errno
;
396 /* Add this makefile to the list. */
397 do_variable_definition (&ebuf
.floc
, "MAKEFILE_LIST", filename
, o_file
,
400 /* Evaluate the makefile */
403 ebuf
.buffer
= ebuf
.bufnext
= ebuf
.bufstart
= xmalloc (ebuf
.size
);
405 curfile
= reading_file
;
406 reading_file
= &ebuf
.floc
;
408 r
= eval (&ebuf
, !(flags
& RM_NO_DEFAULT_GOAL
));
410 reading_file
= curfile
;
414 free (ebuf
.bufstart
);
420 eval_buffer (char *buffer
)
423 struct conditionals
*saved
;
424 struct conditionals
new;
425 const struct floc
*curfile
;
428 /* Evaluate the buffer */
430 ebuf
.size
= strlen (buffer
);
431 ebuf
.buffer
= ebuf
.bufnext
= ebuf
.bufstart
= buffer
;
434 ebuf
.floc
= *reading_file
;
436 curfile
= reading_file
;
437 reading_file
= &ebuf
.floc
;
439 saved
= install_conditionals (&new);
443 restore_conditionals (saved
);
445 reading_file
= curfile
;
452 /* Read file FILENAME as a makefile and add its contents to the data base.
454 SET_DEFAULT is true if we are allowed to set the default goal. */
458 eval (struct ebuffer
*ebuf
, int set_default
)
461 unsigned int collapsed_length
= 0;
462 unsigned int commands_len
= 200;
464 unsigned int commands_idx
= 0;
465 unsigned int cmds_started
, tgts_started
;
466 int ignoring
= 0, in_ignored_define
= 0;
467 int no_targets
= 0; /* Set when reading a rule without targets. */
468 struct nameseq
*filenames
= 0;
469 struct dep
*deps
= 0;
472 char *pattern
= 0, *pattern_percent
;
476 #define record_waiting_files() \
479 if (filenames != 0) \
481 fi.lineno = tgts_started; \
482 record_files (filenames, pattern, pattern_percent, deps, \
483 cmds_started, commands, commands_idx, two_colon, \
489 if (pattern) { free(pattern); pattern = 0; } \
493 cmds_started
= tgts_started
= 1;
495 fstart
= &ebuf
->floc
;
496 fi
.filenm
= ebuf
->floc
.filenm
;
498 /* Loop over lines in the file.
499 The strategy is to accumulate target names in FILENAMES, dependencies
500 in DEPS and commands in COMMANDS. These are used to define a rule
501 when the start of the next rule (or eof) is encountered.
503 When you see a "continue" in the loop below, that means we are moving on
504 to the next line _without_ ending any rule that we happen to be working
505 with at the moment. If you see a "goto rule_complete", then the
506 statement we just parsed also finishes the previous rule. */
508 commands
= xmalloc (200);
512 unsigned int linelen
;
518 /* Grab the next line to be evaluated */
519 ebuf
->floc
.lineno
+= nlines
;
520 nlines
= readline (ebuf
);
522 /* If there is nothing left to eval, we're done. */
526 /* If this line is empty, skip it. */
531 linelen
= strlen (line
);
533 /* Check for a shell command line first.
534 If it is not one, we can stop treating tab specially. */
538 /* Ignore the commands in a rule with no targets. */
541 /* If there is no preceding rule line, don't treat this line
542 as a command, even though it begins with a tab character.
543 SunOS 4 make appears to behave this way. */
548 /* Yep, this is a shell command, and we don't care. */
551 /* Append this command line to the line being accumulated. */
552 if (commands_idx
== 0)
553 cmds_started
= ebuf
->floc
.lineno
;
555 if (linelen
+ 1 + commands_idx
> commands_len
)
557 commands_len
= (linelen
+ 1 + commands_idx
) * 2;
558 commands
= xrealloc (commands
, commands_len
);
560 bcopy (line
, &commands
[commands_idx
], linelen
);
561 commands_idx
+= linelen
;
562 commands
[commands_idx
++] = '\n';
568 /* This line is not a shell command line. Don't worry about tabs.
569 Get more space if we need it; we don't need to preserve the current
570 contents of the buffer. */
572 if (collapsed_length
< linelen
+1)
574 collapsed_length
= linelen
+1;
576 free ((char *)collapsed
);
577 collapsed
= (char *) xmalloc (collapsed_length
);
579 strcpy (collapsed
, line
);
580 /* Collapse continuation lines. */
581 collapse_continuations (collapsed
);
582 remove_comments (collapsed
);
584 /* Compare a word, both length and contents. */
585 #define word1eq(s) (len == sizeof(s)-1 && strneq (s, p, sizeof(s)-1))
587 while (isspace ((unsigned char)*p
))
591 /* This line is completely empty--ignore it. */
594 /* Find the end of the first token. Note we don't need to worry about
595 * ":" here since we compare tokens by length (so "export" will never
596 * be equal to "export:").
598 for (p2
= p
+1; *p2
!= '\0' && !isspace ((unsigned char)*p2
); ++p2
)
602 /* Find the start of the second token. If it looks like a target or
603 variable definition it can't be a preprocessor token so skip
604 them--this allows variables/targets named `ifdef', `export', etc. */
605 while (isspace ((unsigned char)*p2
))
608 if ((p2
[0] == ':' || p2
[0] == '+' || p2
[0] == '=') && p2
[1] == '\0')
610 /* It can't be a preprocessor token so skip it if we're ignoring */
614 goto skip_conditionals
;
617 /* We must first check for conditional and `define' directives before
618 ignoring anything, since they control what we will do with
621 if (!in_ignored_define
)
623 int i
= conditional_line (p
, len
, fstart
);
627 fatal (fstart
, _("invalid syntax in conditional"));
634 if (word1eq ("endef"))
636 if (!in_ignored_define
)
637 fatal (fstart
, _("extraneous `endef'"));
638 in_ignored_define
= 0;
642 if (word1eq ("define"))
645 in_ignored_define
= 1;
649 fatal (fstart
, _("empty variable name"));
651 /* Let the variable name be the whole rest of the line,
652 with trailing blanks stripped (comments have already been
653 removed), so it could be a complex variable/function
654 reference that might contain blanks. */
655 p
= strchr (p2
, '\0');
656 while (isblank ((unsigned char)p
[-1]))
658 do_define (p2
, p
- p2
, o_file
, ebuf
);
663 if (word1eq ("override"))
666 error (fstart
, _("empty `override' directive"));
668 if (strneq (p2
, "define", 6)
669 && (isblank ((unsigned char)p2
[6]) || p2
[6] == '\0'))
672 in_ignored_define
= 1;
675 p2
= next_token (p2
+ 6);
677 fatal (fstart
, _("empty variable name"));
679 /* Let the variable name be the whole rest of the line,
680 with trailing blanks stripped (comments have already been
681 removed), so it could be a complex variable/function
682 reference that might contain blanks. */
683 p
= strchr (p2
, '\0');
684 while (isblank ((unsigned char)p
[-1]))
686 do_define (p2
, p
- p2
, o_override
, ebuf
);
690 && !try_variable_definition (fstart
, p2
, o_override
, 0))
691 error (fstart
, _("invalid `override' directive"));
697 /* Ignore the line. We continue here so conditionals
698 can appear in the middle of a rule. */
701 if (word1eq ("export"))
703 /* 'export' by itself causes everything to be exported. */
705 export_all_variables
= 1;
710 v
= try_variable_definition (fstart
, p2
, o_file
, 0);
712 v
->export
= v_export
;
718 /* Expand the line so we can use indirect and constructed
719 variable names in an export command. */
720 p2
= ap
= allocated_variable_expand (p2
);
722 for (p
= find_next_token (&p2
, &len
); p
!= 0;
723 p
= find_next_token (&p2
, &len
))
725 v
= lookup_variable (p
, len
);
727 v
= define_variable_loc (p
, len
, "", o_file
, 0,
729 v
->export
= v_export
;
738 if (word1eq ("unexport"))
741 export_all_variables
= 0;
748 /* Expand the line so we can use indirect and constructed
749 variable names in an unexport command. */
750 p2
= ap
= allocated_variable_expand (p2
);
752 for (p
= find_next_token (&p2
, &len
); p
!= 0;
753 p
= find_next_token (&p2
, &len
))
755 v
= lookup_variable (p
, len
);
757 v
= define_variable_loc (p
, len
, "", o_file
, 0, fstart
);
759 v
->export
= v_noexport
;
768 if (word1eq ("vpath"))
772 p2
= variable_expand (p2
);
773 p
= find_next_token (&p2
, &len
);
776 pattern
= savestring (p
, len
);
777 p
= find_next_token (&p2
, &len
);
778 /* No searchpath means remove all previous
779 selective VPATH's with the same pattern. */
782 /* No pattern means remove all previous selective VPATH's. */
784 construct_vpath_list (pattern
, p
);
791 if (word1eq ("include") || word1eq ("-include") || word1eq ("sinclude"))
793 /* We have found an `include' line specifying a nested
794 makefile to be read at this point. */
795 struct conditionals
*save
;
796 struct conditionals new_conditionals
;
797 struct nameseq
*files
;
798 /* "-include" (vs "include") says no error if the file does not
799 exist. "sinclude" is an alias for this from SGI. */
800 int noerror
= (p
[0] != 'i');
802 p
= allocated_variable_expand (p2
);
804 /* If no filenames, it's a no-op. */
808 /* Parse the list of file names. */
810 files
= multi_glob (parse_file_seq (&p2
, '\0',
811 sizeof (struct nameseq
),
813 sizeof (struct nameseq
));
816 /* Save the state of conditionals and start
817 the included makefile with a clean slate. */
818 save
= install_conditionals (&new_conditionals
);
820 /* Record the rules that are waiting so they will determine
821 the default goal before those in the included makefile. */
822 record_waiting_files ();
824 /* Read each included makefile. */
827 struct nameseq
*next
= files
->next
;
828 char *name
= files
->name
;
831 free ((char *)files
);
834 r
= eval_makefile (name
, (RM_INCLUDED
| RM_NO_TILDE
835 | (noerror
? RM_DONTCARE
: 0)));
839 error (fstart
, "%s: %s", name
, strerror (errno
));
844 /* Restore conditional state. */
845 restore_conditionals (save
);
850 if (try_variable_definition (fstart
, p
, o_file
, 0))
851 /* This line has been dealt with. */
854 /* This line starts with a tab but was not caught above because there
855 was no preceding target, and the line might have been usable as a
856 variable definition. But now we know it is definitely lossage. */
858 fatal(fstart
, _("commands commence before first target"));
860 /* This line describes some target files. This is complicated by
861 the existence of target-specific variables, because we can't
862 expand the entire line until we know if we have one or not. So
863 we expand the line word by word until we find the first `:',
864 then check to see if it's a target-specific variable.
866 In this algorithm, `lb_next' will point to the beginning of the
867 unexpanded parts of the input buffer, while `p2' points to the
868 parts of the expanded buffer we haven't searched yet. */
871 enum make_word_type wtype
;
872 enum variable_origin v_origin
;
874 char *cmdleft
, *semip
, *lb_next
;
875 unsigned int len
, plen
= 0;
877 const char *end
, *beg
; /* Helpers for whitespace stripping. */
879 /* Record the previous rule. */
881 record_waiting_files ();
882 tgts_started
= fstart
->lineno
;
884 /* Search the line for an unquoted ; that is not after an
886 cmdleft
= find_char_unquote (line
, ';', '#', 0, 1);
887 if (cmdleft
!= 0 && *cmdleft
== '#')
889 /* We found a comment before a semicolon. */
893 else if (cmdleft
!= 0)
894 /* Found one. Cut the line short there before expanding it. */
898 collapse_continuations (line
);
900 /* We can't expand the entire line, since if it's a per-target
901 variable we don't want to expand it. So, walk from the
902 beginning, expanding as we go, and looking for "interesting"
903 chars. The first word is always expandable. */
904 wtype
= get_next_mword(line
, NULL
, &lb_next
, &len
);
909 fatal(fstart
, _("missing rule before commands"));
910 /* This line contained something but turned out to be nothing
911 but whitespace (a comment?). */
916 /* We accept and ignore rules without targets for
917 compatibility with SunOS 4 make. */
925 p2
= variable_expand_string(NULL
, lb_next
, len
);
932 /* Look for a semicolon in the expanded line. */
933 cmdleft
= find_char_unquote (p2
, ';', 0, 0, 0);
937 unsigned long p2_off
= p2
- variable_buffer
;
938 unsigned long cmd_off
= cmdleft
- variable_buffer
;
939 char *pend
= p2
+ strlen(p2
);
941 /* Append any remnants of lb, then cut the line short
945 /* One school of thought says that you shouldn't expand
946 here, but merely copy, since now you're beyond a ";"
947 and into a command script. However, the old parser
948 expanded the whole line, so we continue that for
949 backwards-compatiblity. Also, it wouldn't be
950 entirely consistent, since we do an unconditional
951 expand below once we know we don't have a
952 target-specific variable. */
953 (void)variable_expand_string(pend
, lb_next
, (long)-1);
954 lb_next
+= strlen(lb_next
);
955 p2
= variable_buffer
+ p2_off
;
956 cmdleft
= variable_buffer
+ cmd_off
+ 1;
960 colonp
= find_char_unquote(p2
, ':', 0, 0, 0);
961 #ifdef HAVE_DOS_PATHS
962 /* The drive spec brain-damage strikes again... */
963 /* Note that the only separators of targets in this context
964 are whitespace and a left paren. If others are possible,
965 they should be added to the string in the call to index. */
966 while (colonp
&& (colonp
[1] == '/' || colonp
[1] == '\\') &&
967 colonp
> p2
&& isalpha ((unsigned char)colonp
[-1]) &&
968 (colonp
== p2
+ 1 || strchr (" \t(", colonp
[-2]) != 0))
969 colonp
= find_char_unquote(colonp
+ 1, ':', 0, 0, 0);
974 wtype
= get_next_mword(lb_next
, NULL
, &lb_next
, &len
);
980 p2
= variable_expand_string(p2
, lb_next
, len
);
981 /* We don't need to worry about cmdleft here, because if it was
982 found in the variable_buffer the entire buffer has already
983 been expanded... we'll never get here. */
986 p2
= next_token (variable_buffer
);
988 /* If the word we're looking at is EOL, see if there's _anything_
989 on the line. If not, a variable expanded to nothing, so ignore
990 it. If so, we can't parse this line so punt. */
994 /* There's no need to be ivory-tower about this: check for
995 one of the most common bugs found in makefiles... */
996 fatal (fstart
, _("missing separator%s"),
997 !strneq(line
, " ", 8) ? ""
998 : _(" (did you mean TAB instead of 8 spaces?)"));
1002 /* Make the colon the end-of-string so we know where to stop
1003 looking for targets. */
1005 filenames
= multi_glob (parse_file_seq (&p2
, '\0',
1006 sizeof (struct nameseq
),
1008 sizeof (struct nameseq
));
1013 /* We accept and ignore rules without targets for
1014 compatibility with SunOS 4 make. */
1018 /* This should never be possible; we handled it above. */
1019 assert (*p2
!= '\0');
1022 /* Is this a one-colon or two-colon entry? */
1023 two_colon
= *p2
== ':';
1027 /* Test to see if it's a target-specific variable. Copy the rest
1028 of the buffer over, possibly temporarily (we'll expand it later
1029 if it's not a target-specific variable). PLEN saves the length
1030 of the unparsed section of p2, for later. */
1031 if (*lb_next
!= '\0')
1033 unsigned int l
= p2
- variable_buffer
;
1035 (void) variable_buffer_output (p2
+plen
,
1036 lb_next
, strlen (lb_next
)+1);
1037 p2
= variable_buffer
+ l
;
1040 /* See if it's an "override" or "export" keyword; if so see if what
1041 comes after it looks like a variable definition. */
1043 wtype
= get_next_mword (p2
, NULL
, &p
, &len
);
1047 if (wtype
== w_static
)
1049 if (word1eq ("override"))
1051 v_origin
= o_override
;
1052 wtype
= get_next_mword (p
+len
, NULL
, &p
, &len
);
1054 else if (word1eq ("export"))
1057 wtype
= get_next_mword (p
+len
, NULL
, &p
, &len
);
1062 wtype
= get_next_mword (p
+len
, NULL
, NULL
, NULL
);
1064 if (wtype
== w_varassign
)
1066 /* If there was a semicolon found, add it back, plus anything
1070 unsigned int l
= p
- variable_buffer
;
1072 variable_buffer_output (p2
+ strlen (p2
),
1073 semip
, strlen (semip
)+1);
1074 p
= variable_buffer
+ l
;
1076 record_target_var (filenames
, p
, v_origin
, exported
, fstart
);
1081 /* This is a normal target, _not_ a target-specific variable.
1082 Unquote any = in the dependency list. */
1083 find_char_unquote (lb_next
, '=', 0, 0, 0);
1085 /* We have some targets, so don't ignore the following commands. */
1088 /* Expand the dependencies, etc. */
1089 if (*lb_next
!= '\0')
1091 unsigned int l
= p2
- variable_buffer
;
1092 (void) variable_expand_string (p2
+ plen
, lb_next
, (long)-1);
1093 p2
= variable_buffer
+ l
;
1095 /* Look for a semicolon in the expanded line. */
1098 cmdleft
= find_char_unquote (p2
, ';', 0, 0, 0);
1100 *(cmdleft
++) = '\0';
1104 /* Is this a static pattern rule: `target: %targ: %dep; ...'? */
1105 p
= strchr (p2
, ':');
1106 while (p
!= 0 && p
[-1] == '\\')
1108 register char *q
= &p
[-1];
1109 register int backslash
= 0;
1110 while (*q
-- == '\\')
1111 backslash
= !backslash
;
1113 p
= strchr (p
+ 1, ':');
1118 /* Here, the situation is quite complicated. Let's have a look
1119 at a couple of targets:
1127 The rule is that it's only a target, if there are TWO :'s
1128 OR a space around the :.
1130 if (p
&& !(isspace ((unsigned char)p
[1]) || !p
[1]
1131 || isspace ((unsigned char)p
[-1])))
1134 #ifdef HAVE_DOS_PATHS
1140 /* For DOS-style paths, skip a "C:\..." or a "C:/..." */
1141 if (p
!= 0 && (p
[1] == '\\' || p
[1] == '/') &&
1142 isalpha ((unsigned char)p
[-1]) &&
1143 (p
== p2
+ 1 || strchr (" \t:(", p
[-2]) != 0)) {
1144 p
= strchr (p
+ 1, ':');
1147 } while (check_again
);
1152 struct nameseq
*target
;
1153 target
= parse_file_seq (&p2
, ':', sizeof (struct nameseq
), 1);
1156 fatal (fstart
, _("missing target pattern"));
1157 else if (target
->next
!= 0)
1158 fatal (fstart
, _("multiple target patterns"));
1159 pattern
= target
->name
;
1160 pattern_percent
= find_percent (pattern
);
1161 if (pattern_percent
== 0)
1162 fatal (fstart
, _("target pattern contains no `%%'"));
1163 free((char *)target
);
1168 /* Strip leading and trailing whitespaces. */
1170 end
= beg
+ strlen (beg
) - 1;
1171 strip_whitespace (&beg
, &end
);
1173 if (beg
<= end
&& *beg
!= '\0')
1176 const char *fromp
= beg
;
1178 /* Make a copy of the dependency string. Note if we find '$'. */
1179 deps
= (struct dep
*) xmalloc (sizeof (struct dep
));
1181 deps
->name
= top
= (char *) xmalloc (end
- beg
+ 2);
1182 deps
->need_2nd_expansion
= 0;
1183 while (fromp
<= end
)
1186 deps
->need_2nd_expansion
= 1;
1187 *(top
++) = *(fromp
++);
1198 /* Semicolon means rest of line is a command. */
1199 unsigned int len
= strlen (cmdleft
);
1201 cmds_started
= fstart
->lineno
;
1203 /* Add this command line to the buffer. */
1204 if (len
+ 2 > commands_len
)
1206 commands_len
= (len
+ 2) * 2;
1207 commands
= (char *) xrealloc (commands
, commands_len
);
1209 bcopy (cmdleft
, commands
, len
);
1210 commands_idx
+= len
;
1211 commands
[commands_idx
++] = '\n';
1214 /* Determine if this target should be made default. We used to do
1215 this in record_files() but because of the delayed target recording
1216 and because preprocessor directives are legal in target's commands
1217 it is too late. Consider this fragment for example:
1221 ifeq ($(.DEFAULT_GOAL),foo)
1225 Because the target is not recorded until after ifeq directive is
1226 evaluated the .DEFAULT_GOAL does not contain foo yet as one
1227 would expect. Because of this we have to move some of the logic
1230 if (**default_goal_name
== '\0' && set_default
)
1234 struct nameseq
*t
= filenames
;
1236 for (; t
!= 0; t
= t
->next
)
1241 /* We have nothing to do if this is an implicit rule. */
1242 if (strchr (name
, '%') != 0)
1245 /* See if this target's name does not start with a `.',
1246 unless it contains a slash. */
1247 if (*name
== '.' && strchr (name
, '/') == 0
1248 #ifdef HAVE_DOS_PATHS
1249 && strchr (name
, '\\') == 0
1255 /* If this file is a suffix, don't let it be
1256 the default goal file. */
1257 for (d
= suffix_file
->deps
; d
!= 0; d
= d
->next
)
1259 register struct dep
*d2
;
1260 if (*dep_name (d
) != '.' && streq (name
, dep_name (d
)))
1265 for (d2
= suffix_file
->deps
; d2
!= 0; d2
= d2
->next
)
1267 register unsigned int len
= strlen (dep_name (d2
));
1268 if (!strneq (name
, dep_name (d2
), len
))
1270 if (streq (name
+ len
, dep_name (d
)))
1283 define_variable_global (".DEFAULT_GOAL", 13, t
->name
,
1293 /* We get here except in the case that we just read a rule line.
1294 Record now the last rule we read, so following spurious
1295 commands are properly diagnosed. */
1297 record_waiting_files ();
1302 if (conditionals
->if_cmds
)
1303 fatal (fstart
, _("missing `endif'"));
1305 /* At eof, record the last rule. */
1306 record_waiting_files ();
1309 free ((char *) collapsed
);
1310 free ((char *) commands
);
1316 /* Remove comments from LINE.
1317 This is done by copying the text at LINE onto itself. */
1320 remove_comments (char *line
)
1324 comment
= find_char_unquote (line
, '#', 0, 0, 0);
1327 /* Cut off the line at the #. */
1331 /* Execute a `define' directive.
1332 The first line has already been read, and NAME is the name of
1333 the variable to be defined. The following lines remain to be read. */
1336 do_define (char *name
, unsigned int namelen
,
1337 enum variable_origin origin
, struct ebuffer
*ebuf
)
1339 struct floc defstart
;
1342 unsigned int length
= 100;
1343 char *definition
= (char *) xmalloc (length
);
1344 unsigned int idx
= 0;
1347 /* Expand the variable name. */
1348 char *var
= (char *) alloca (namelen
+ 1);
1349 bcopy (name
, var
, namelen
);
1350 var
[namelen
] = '\0';
1351 var
= variable_expand (var
);
1353 defstart
= ebuf
->floc
;
1360 nlines
= readline (ebuf
);
1361 ebuf
->floc
.lineno
+= nlines
;
1363 /* If there is nothing left to eval, we're done. */
1367 line
= ebuf
->buffer
;
1369 collapse_continuations (line
);
1371 /* If the line doesn't begin with a tab, test to see if it introduces
1372 another define, or ends one. */
1374 /* Stop if we find an 'endef' */
1375 if (line
[0] != '\t')
1377 p
= next_token (line
);
1380 /* If this is another 'define', increment the level count. */
1381 if ((len
== 6 || (len
> 6 && isblank ((unsigned char)p
[6])))
1382 && strneq (p
, "define", 6))
1385 /* If this is an 'endef', decrement the count. If it's now 0,
1386 we've found the last one. */
1387 else if ((len
== 5 || (len
> 5 && isblank ((unsigned char)p
[5])))
1388 && strneq (p
, "endef", 5))
1391 remove_comments (p
);
1392 if (*next_token (p
) != '\0')
1394 _("Extraneous text after `endef' directive"));
1398 /* Define the variable. */
1400 definition
[0] = '\0';
1402 definition
[idx
- 1] = '\0';
1404 /* Always define these variables in the global set. */
1405 define_variable_global (var
, strlen (var
), definition
,
1406 origin
, 1, &defstart
);
1413 /* Otherwise add this line to the variable definition. */
1414 len
= strlen (line
);
1415 if (idx
+ len
+ 1 > length
)
1417 length
= (idx
+ len
) * 2;
1418 definition
= (char *) xrealloc (definition
, length
+ 1);
1421 bcopy (line
, &definition
[idx
], len
);
1423 /* Separate lines with a newline. */
1424 definition
[idx
++] = '\n';
1428 fatal (&defstart
, _("missing `endef', unterminated `define'"));
1434 /* Interpret conditional commands "ifdef", "ifndef", "ifeq",
1435 "ifneq", "else" and "endif".
1436 LINE is the input line, with the command as its first word.
1438 FILENAME and LINENO are the filename and line number in the
1439 current makefile. They are used for error messages.
1441 Value is -2 if the line is not a conditional at all,
1442 -1 if the line is an invalid conditional,
1443 0 if following text should be interpreted,
1444 1 if following text should be ignored. */
1447 conditional_line (char *line
, int len
, const struct floc
*flocp
)
1450 enum { c_ifdef
, c_ifndef
, c_ifeq
, c_ifneq
, c_else
, c_endif
} cmdtype
;
1454 /* Compare a word, both length and contents. */
1455 #define word1eq(s) (len == sizeof(s)-1 && strneq (s, line, sizeof(s)-1))
1456 #define chkword(s, t) if (word1eq (s)) { cmdtype = (t); cmdname = (s); }
1458 /* Make sure this line is a conditional. */
1459 chkword ("ifdef", c_ifdef
)
1460 else chkword ("ifndef", c_ifndef
)
1461 else chkword ("ifeq", c_ifeq
)
1462 else chkword ("ifneq", c_ifneq
)
1463 else chkword ("else", c_else
)
1464 else chkword ("endif", c_endif
)
1468 /* Found one: skip past it and any whitespace after it. */
1469 line
= next_token (line
+ len
);
1471 #define EXTRANEOUS() error (flocp, _("Extraneous text after `%s' directive"), cmdname)
1473 /* An 'endif' cannot contain extra text, and reduces the if-depth by 1 */
1474 if (cmdtype
== c_endif
)
1479 if (!conditionals
->if_cmds
)
1480 fatal (flocp
, _("extraneous `%s'"), cmdname
);
1482 --conditionals
->if_cmds
;
1487 /* An 'else' statement can either be simple, or it can have another
1488 conditional after it. */
1489 if (cmdtype
== c_else
)
1493 if (!conditionals
->if_cmds
)
1494 fatal (flocp
, _("extraneous `%s'"), cmdname
);
1496 o
= conditionals
->if_cmds
- 1;
1498 if (conditionals
->seen_else
[o
])
1499 fatal (flocp
, _("only one `else' per conditional"));
1501 /* Change the state of ignorance. */
1502 switch (conditionals
->ignoring
[o
])
1505 /* We've just been interpreting. Never do it again. */
1506 conditionals
->ignoring
[o
] = 2;
1509 /* We've never interpreted yet. Maybe this time! */
1510 conditionals
->ignoring
[o
] = 0;
1514 /* It's a simple 'else'. */
1517 conditionals
->seen_else
[o
] = 1;
1521 /* The 'else' has extra text. That text must be another conditional
1522 and cannot be an 'else' or 'endif'. */
1524 /* Find the length of the next word. */
1525 for (p
= line
+1; *p
!= '\0' && !isspace ((unsigned char)*p
); ++p
)
1529 /* If it's 'else' or 'endif' or an illegal conditional, fail. */
1530 if (word1eq("else") || word1eq("endif")
1531 || conditional_line (line
, len
, flocp
) < 0)
1535 /* conditional_line() created a new level of conditional.
1536 Raise it back to this level. */
1537 if (conditionals
->ignoring
[o
] < 2)
1538 conditionals
->ignoring
[o
] = conditionals
->ignoring
[o
+1];
1539 --conditionals
->if_cmds
;
1545 if (conditionals
->allocated
== 0)
1547 conditionals
->allocated
= 5;
1548 conditionals
->ignoring
= (char *) xmalloc (conditionals
->allocated
);
1549 conditionals
->seen_else
= (char *) xmalloc (conditionals
->allocated
);
1552 o
= conditionals
->if_cmds
++;
1553 if (conditionals
->if_cmds
> conditionals
->allocated
)
1555 conditionals
->allocated
+= 5;
1556 conditionals
->ignoring
= (char *)
1557 xrealloc (conditionals
->ignoring
, conditionals
->allocated
);
1558 conditionals
->seen_else
= (char *)
1559 xrealloc (conditionals
->seen_else
, conditionals
->allocated
);
1562 /* Record that we have seen an `if...' but no `else' so far. */
1563 conditionals
->seen_else
[o
] = 0;
1565 /* Search through the stack to see if we're already ignoring. */
1566 for (i
= 0; i
< o
; ++i
)
1567 if (conditionals
->ignoring
[i
])
1569 /* We are already ignoring, so just push a level to match the next
1570 "else" or "endif", and keep ignoring. We don't want to expand
1571 variables in the condition. */
1572 conditionals
->ignoring
[o
] = 1;
1576 if (cmdtype
== c_ifdef
|| cmdtype
== c_ifndef
)
1582 /* Expand the thing we're looking up, so we can use indirect and
1583 constructed variable names. */
1584 var
= allocated_variable_expand (line
);
1586 /* Make sure there's only one variable name to test. */
1587 p
= end_of_token (var
);
1594 v
= lookup_variable (var
, i
);
1596 conditionals
->ignoring
[o
] =
1597 ((v
!= 0 && *v
->value
!= '\0') == (cmdtype
== c_ifndef
));
1603 /* "Ifeq" or "ifneq". */
1606 char termin
= *line
== '(' ? ',' : *line
;
1608 if (termin
!= ',' && termin
!= '"' && termin
!= '\'')
1612 /* Find the end of the first string. */
1616 for (; *line
!= '\0'; ++line
)
1619 else if (*line
== ')')
1621 else if (*line
== ',' && count
<= 0)
1625 while (*line
!= '\0' && *line
!= termin
)
1633 /* Strip blanks after the first string. */
1635 while (isblank ((unsigned char)p
[-1]))
1642 s2
= variable_expand (s1
);
1643 /* We must allocate a new copy of the expanded string because
1644 variable_expand re-uses the same buffer. */
1646 s1
= (char *) alloca (len
+ 1);
1647 bcopy (s2
, s1
, len
+ 1);
1650 /* Find the start of the second string. */
1651 line
= next_token (line
);
1653 termin
= termin
== ',' ? ')' : *line
;
1654 if (termin
!= ')' && termin
!= '"' && termin
!= '\'')
1657 /* Find the end of the second string. */
1660 register int count
= 0;
1661 s2
= next_token (line
);
1662 for (line
= s2
; *line
!= '\0'; ++line
)
1666 else if (*line
== ')')
1679 while (*line
!= '\0' && *line
!= termin
)
1687 line
= next_token (++line
);
1691 s2
= variable_expand (s2
);
1692 conditionals
->ignoring
[o
] = (streq (s1
, s2
) == (cmdtype
== c_ifneq
));
1696 /* Search through the stack to see if we're ignoring. */
1697 for (i
= 0; i
< conditionals
->if_cmds
; ++i
)
1698 if (conditionals
->ignoring
[i
])
1703 /* Remove duplicate dependencies in CHAIN. */
1705 static unsigned long
1706 dep_hash_1 (const void *key
)
1708 return_STRING_HASH_1 (dep_name ((struct dep
const *) key
));
1711 static unsigned long
1712 dep_hash_2 (const void *key
)
1714 return_STRING_HASH_2 (dep_name ((struct dep
const *) key
));
1718 dep_hash_cmp (const void *x
, const void *y
)
1720 struct dep
*dx
= (struct dep
*) x
;
1721 struct dep
*dy
= (struct dep
*) y
;
1722 int cmp
= strcmp (dep_name (dx
), dep_name (dy
));
1724 /* If the names are the same but ignore_mtimes are not equal, one of these
1725 is an order-only prerequisite and one isn't. That means that we should
1726 remove the one that isn't and keep the one that is. */
1728 if (!cmp
&& dx
->ignore_mtime
!= dy
->ignore_mtime
)
1729 dx
->ignore_mtime
= dy
->ignore_mtime
= 0;
1736 uniquize_deps (struct dep
*chain
)
1738 struct hash_table deps
;
1739 register struct dep
**depp
;
1741 hash_init (&deps
, 500, dep_hash_1
, dep_hash_2
, dep_hash_cmp
);
1743 /* Make sure that no dependencies are repeated. This does not
1744 really matter for the purpose of updating targets, but it
1745 might make some names be listed twice for $^ and $?. */
1750 struct dep
*dep
= *depp
;
1751 struct dep
**dep_slot
= (struct dep
**) hash_find_slot (&deps
, dep
);
1752 if (HASH_VACANT (*dep_slot
))
1754 hash_insert_at (&deps
, dep
, dep_slot
);
1759 /* Don't bother freeing duplicates.
1760 It's dangerous and little benefit accrues. */
1765 hash_free (&deps
, 0);
1768 /* Record target-specific variable values for files FILENAMES.
1769 TWO_COLON is nonzero if a double colon was used.
1771 The links of FILENAMES are freed, and so are any names in it
1772 that are not incorporated into other data structures.
1774 If the target is a pattern, add the variable to the pattern-specific
1775 variable value list. */
1778 record_target_var (struct nameseq
*filenames
, char *defn
,
1779 enum variable_origin origin
, int exported
,
1780 const struct floc
*flocp
)
1782 struct nameseq
*nextf
;
1783 struct variable_set_list
*global
;
1785 global
= current_variable_set_list
;
1787 /* If the variable is an append version, store that but treat it as a
1788 normal recursive variable. */
1790 for (; filenames
!= 0; filenames
= nextf
)
1793 register char *name
= filenames
->name
;
1796 struct pattern_var
*p
;
1798 nextf
= filenames
->next
;
1799 free ((char *) filenames
);
1801 /* If it's a pattern target, then add it to the pattern-specific
1803 percent
= find_percent (name
);
1806 /* Get a reference for this pattern-specific variable struct. */
1807 p
= create_pattern_var (name
, percent
);
1808 p
->variable
.fileinfo
= *flocp
;
1809 /* I don't think this can fail since we already determined it was a
1810 variable definition. */
1811 v
= parse_variable_definition (&p
->variable
, defn
);
1814 if (v
->flavor
== f_simple
)
1815 v
->value
= allocated_variable_expand (v
->value
);
1817 v
->value
= xstrdup (v
->value
);
1825 /* Get a file reference for this file, and initialize it.
1826 We don't want to just call enter_file() because that allocates a
1827 new entry if the file is a double-colon, which we don't want in
1829 f
= lookup_file (name
);
1831 f
= enter_file (name
);
1832 else if (f
->double_colon
)
1833 f
= f
->double_colon
;
1835 initialize_file_variables (f
, 1);
1838 current_variable_set_list
= f
->variables
;
1839 v
= try_variable_definition (flocp
, defn
, origin
, 1);
1841 error (flocp
, _("Malformed target-specific variable definition"));
1842 current_variable_set_list
= global
;
1845 /* Set up the variable to be *-specific. */
1849 v
->export
= v_export
;
1851 /* If it's not an override, check to see if there was a command-line
1852 setting. If so, reset the value. */
1853 if (origin
!= o_override
)
1855 struct variable
*gv
;
1856 int len
= strlen(v
->name
);
1858 gv
= lookup_variable (v
->name
, len
);
1859 if (gv
&& (gv
->origin
== o_env_override
|| gv
->origin
== o_command
))
1863 v
->value
= xstrdup (gv
->value
);
1864 v
->origin
= gv
->origin
;
1865 v
->recursive
= gv
->recursive
;
1870 /* Free name if not needed further. */
1871 if (name
!= fname
&& (name
< fname
|| name
> fname
+ strlen (fname
)))
1876 /* Record a description line for files FILENAMES,
1877 with dependencies DEPS, commands to execute described
1878 by COMMANDS and COMMANDS_IDX, coming from FILENAME:COMMANDS_STARTED.
1879 TWO_COLON is nonzero if a double colon was used.
1880 If not nil, PATTERN is the `%' pattern to make this
1881 a static pattern rule, and PATTERN_PERCENT is a pointer
1882 to the `%' within it.
1884 The links of FILENAMES are freed, and so are any names in it
1885 that are not incorporated into other data structures. */
1888 record_files (struct nameseq
*filenames
, char *pattern
, char *pattern_percent
,
1889 struct dep
*deps
, unsigned int cmds_started
, char *commands
,
1890 unsigned int commands_idx
, int two_colon
,
1891 const struct floc
*flocp
)
1893 struct nameseq
*nextf
;
1895 unsigned int max_targets
= 0, target_idx
= 0;
1896 char **targets
= 0, **target_percents
= 0;
1897 struct commands
*cmds
;
1899 /* If we've already snapped deps, that means we're in an eval being
1900 resolved after the makefiles have been read in. We can't add more rules
1901 at this time, since they won't get snapped and we'll get core dumps.
1902 See Savannah bug # 12124. */
1904 fatal (flocp
, _("prerequisites cannot be defined in command scripts"));
1906 if (commands_idx
> 0)
1908 cmds
= (struct commands
*) xmalloc (sizeof (struct commands
));
1909 cmds
->fileinfo
.filenm
= flocp
->filenm
;
1910 cmds
->fileinfo
.lineno
= cmds_started
;
1911 cmds
->commands
= savestring (commands
, commands_idx
);
1912 cmds
->command_lines
= 0;
1917 for (; filenames
!= 0; filenames
= nextf
)
1919 char *name
= filenames
->name
;
1923 char *implicit_percent
;
1925 nextf
= filenames
->next
;
1928 /* Check for .POSIX. We used to do this in snap_deps() but that's not
1929 good enough: it doesn't happen until after the makefile is read,
1930 which means we cannot use its value during parsing. */
1932 if (streq (name
, ".POSIX"))
1935 implicit_percent
= find_percent (name
);
1936 implicit
|= implicit_percent
!= 0;
1938 if (implicit
&& pattern
!= 0)
1939 fatal (flocp
, _("mixed implicit and static pattern rules"));
1941 if (implicit
&& implicit_percent
== 0)
1942 fatal (flocp
, _("mixed implicit and normal rules"));
1949 targets
= (char **) xmalloc (5 * sizeof (char *));
1950 target_percents
= (char **) xmalloc (5 * sizeof (char *));
1953 else if (target_idx
== max_targets
- 1)
1956 targets
= (char **) xrealloc ((char *) targets
,
1957 max_targets
* sizeof (char *));
1959 = (char **) xrealloc ((char *) target_percents
,
1960 max_targets
* sizeof (char *));
1962 targets
[target_idx
] = name
;
1963 target_percents
[target_idx
] = implicit_percent
;
1968 /* If there are multiple filenames, copy the chain DEPS
1969 for all but the last one. It is not safe for the same deps
1970 to go in more than one place in the database. */
1971 this = nextf
!= 0 ? copy_dep_chain (deps
) : deps
;
1975 /* If this is an extended static rule:
1976 `targets: target%pattern: dep%pattern; cmds',
1977 translate each dependency pattern into a plain filename
1978 using the target pattern and this target's name. */
1979 if (!pattern_matches (pattern
, pattern_percent
, name
))
1981 /* Give a warning if the rule is meaningless. */
1983 _("target `%s' doesn't match the target pattern"), name
);
1987 /* We use subst_expand to do the work of translating % to $* in
1988 the dependency line. */
1990 if (this != 0 && find_percent (this->name
) != 0)
1993 char *buffer
= variable_expand ("");
1995 o
= subst_expand (buffer
, this->name
, "%", "$*", 1, 2, 0);
1998 this->name
= savestring (buffer
, o
- buffer
);
1999 this->need_2nd_expansion
= 1;
2005 /* Single-colon. Combine these dependencies
2006 with others in file's existing record, if any. */
2007 f
= enter_file (name
);
2009 if (f
->double_colon
)
2011 _("target file `%s' has both : and :: entries"), f
->name
);
2013 /* If CMDS == F->CMDS, this target was listed in this rule
2014 more than once. Just give a warning since this is harmless. */
2015 if (cmds
!= 0 && cmds
== f
->cmds
)
2017 _("target `%s' given more than once in the same rule."),
2020 /* Check for two single-colon entries both with commands.
2021 Check is_target so that we don't lose on files such as .c.o
2022 whose commands were preinitialized. */
2023 else if (cmds
!= 0 && f
->cmds
!= 0 && f
->is_target
)
2025 error (&cmds
->fileinfo
,
2026 _("warning: overriding commands for target `%s'"),
2028 error (&f
->cmds
->fileinfo
,
2029 _("warning: ignoring old commands for target `%s'"),
2035 /* Defining .DEFAULT with no deps or cmds clears it. */
2036 if (f
== default_file
&& this == 0 && cmds
== 0)
2041 /* Defining .SUFFIXES with no dependencies
2042 clears out the list of suffixes. */
2043 if (f
== suffix_file
&& this == 0)
2048 struct dep
*nextd
= d
->next
;
2057 /* Add the file's old deps and the new ones in THIS together. */
2061 struct dep
**d_ptr
= &f
->deps
;
2063 while ((*d_ptr
)->next
!= 0)
2064 d_ptr
= &(*d_ptr
)->next
;
2068 /* This is the rule with commands, so put its deps
2069 last. The rationale behind this is that $< expands
2070 to the first dep in the chain, and commands use $<
2071 expecting to get the dep that rule specifies.
2072 However the second expansion algorithm reverses
2073 the order thus we need to make it last here. */
2075 (*d_ptr
)->next
= this;
2079 /* This is the rule without commands. Put its
2080 dependencies at the end but before dependencies
2081 from the rule with commands (if any). This way
2082 everything appears in makefile order. */
2086 this->next
= *d_ptr
;
2090 (*d_ptr
)->next
= this;
2096 /* This is a hack. I need a way to communicate to snap_deps()
2097 that the last dependency line in this file came with commands
2098 (so that logic in snap_deps() can put it in front and all
2099 this $< -logic works). I cannot simply rely on file->cmds
2100 being not 0 because of the cases like the following:
2106 I am going to temporarily "borrow" UPDATING member in
2107 `struct file' for this. */
2113 /* If this is a static pattern rule, set the file's stem to
2114 the part of its name that matched the `%' in the pattern,
2115 so you can use $* in the commands. */
2118 static char *percent
= "%";
2119 char *buffer
= variable_expand ("");
2120 char *o
= patsubst_expand (buffer
, name
, pattern
, percent
,
2121 pattern_percent
+1, percent
+1);
2122 f
->stem
= savestring (buffer
, o
- buffer
);
2127 /* Double-colon. Make a new record
2128 even if the file already has one. */
2129 f
= lookup_file (name
);
2130 /* Check for both : and :: rules. Check is_target so
2131 we don't lose on default suffix rules or makefiles. */
2132 if (f
!= 0 && f
->is_target
&& !f
->double_colon
)
2134 _("target file `%s' has both : and :: entries"), f
->name
);
2135 f
= enter_file (name
);
2136 /* If there was an existing entry and it was a double-colon
2137 entry, enter_file will have returned a new one, making it the
2138 prev pointer of the old one, and setting its double_colon
2139 pointer to the first one. */
2140 if (f
->double_colon
== 0)
2141 /* This is the first entry for this name, so we must
2142 set its double_colon pointer to itself. */
2143 f
->double_colon
= f
;
2149 /* Free name if not needed further. */
2150 if (f
!= 0 && name
!= f
->name
2151 && (name
< f
->name
|| name
> f
->name
+ strlen (f
->name
)))
2157 /* If this target is a default target, update DEFAULT_GOAL_FILE. */
2158 if (strcmp (*default_goal_name
, name
) == 0
2159 && (default_goal_file
== 0
2160 || strcmp (default_goal_file
->name
, name
) != 0))
2161 default_goal_file
= f
;
2166 targets
[target_idx
] = 0;
2167 target_percents
[target_idx
] = 0;
2168 create_pattern_rule (targets
, target_percents
, two_colon
, deps
, cmds
, 1);
2169 free ((char *) target_percents
);
2173 /* Search STRING for an unquoted STOPCHAR or blank (if BLANK is nonzero).
2174 Backslashes quote STOPCHAR, blanks if BLANK is nonzero, and backslash.
2175 Quoting backslashes are removed from STRING by compacting it into
2176 itself. Returns a pointer to the first unquoted STOPCHAR if there is
2177 one, or nil if there are none. STOPCHARs inside variable references are
2178 ignored if IGNOREVARS is true.
2180 STOPCHAR _cannot_ be '$' if IGNOREVARS is true. */
2183 find_char_unquote (char *string
, int stop1
, int stop2
, int blank
,
2186 unsigned int string_len
= 0;
2187 register char *p
= string
;
2195 while (*p
!= '\0' && *p
!= ignorevars
&& *p
!= stop1
&& *p
!= stop2
2196 && ! isblank ((unsigned char) *p
))
2199 while (*p
!= '\0' && *p
!= ignorevars
&& *p
!= stop1
&& *p
!= stop2
)
2202 while (*p
!= '\0' && *p
!= ignorevars
&& *p
!= stop1
2203 && ! isblank ((unsigned char) *p
))
2206 while (*p
!= '\0' && *p
!= ignorevars
&& *p
!= stop1
)
2212 /* If we stopped due to a variable reference, skip over its contents. */
2213 if (*p
== ignorevars
)
2215 char openparen
= p
[1];
2219 /* Skip the contents of a non-quoted, multi-char variable ref. */
2220 if (openparen
== '(' || openparen
== '{')
2222 unsigned int pcount
= 1;
2223 char closeparen
= (openparen
== '(' ? ')' : '}');
2227 if (*p
== openparen
)
2229 else if (*p
== closeparen
)
2239 /* Skipped the variable reference: look for STOPCHARS again. */
2243 if (p
> string
&& p
[-1] == '\\')
2245 /* Search for more backslashes. */
2246 register int i
= -2;
2247 while (&p
[i
] >= string
&& p
[i
] == '\\')
2250 /* Only compute the length if really needed. */
2251 if (string_len
== 0)
2252 string_len
= strlen (string
);
2253 /* The number of backslashes is now -I.
2254 Copy P over itself to swallow half of them. */
2255 bcopy (&p
[i
/ 2], &p
[i
], (string_len
- (p
- string
)) - (i
/ 2) + 1);
2258 /* All the backslashes quoted each other; the STOPCHAR was
2262 /* The STOPCHAR was quoted by a backslash. Look for another. */
2265 /* No backslash in sight. */
2269 /* Never hit a STOPCHAR or blank (with BLANK nonzero). */
2273 /* Search PATTERN for an unquoted %. */
2276 find_percent (char *pattern
)
2278 return find_char_unquote (pattern
, '%', 0, 0, 0);
2281 /* Parse a string into a sequence of filenames represented as a
2282 chain of struct nameseq's in reverse order and return that chain.
2284 The string is passed as STRINGP, the address of a string pointer.
2285 The string pointer is updated to point at the first character
2286 not parsed, which either is a null char or equals STOPCHAR.
2288 SIZE is how big to construct chain elements.
2289 This is useful if we want them actually to be other structures
2290 that have room for additional info.
2292 If STRIP is nonzero, strip `./'s off the beginning. */
2295 parse_file_seq (char **stringp
, int stopchar
, unsigned int size
, int strip
)
2297 register struct nameseq
*new = 0;
2298 register struct nameseq
*new1
, *lastnew1
;
2299 register char *p
= *stringp
;
2304 # define VMS_COMMA ','
2306 # define VMS_COMMA 0
2311 /* Skip whitespace; see if any more names are left. */
2318 /* Yes, find end of next name. */
2320 p
= find_char_unquote (q
, stopchar
, VMS_COMMA
, 1, 0);
2322 /* convert comma separated list to space separated */
2327 if (stopchar
== ':' && p
&& *p
== ':'
2328 && !(isspace ((unsigned char)p
[1]) || !p
[1]
2329 || isspace ((unsigned char)p
[-1])))
2331 p
= find_char_unquote (p
+1, stopchar
, VMS_COMMA
, 1, 0);
2334 #ifdef HAVE_DOS_PATHS
2335 /* For DOS paths, skip a "C:\..." or a "C:/..." until we find the
2336 first colon which isn't followed by a slash or a backslash.
2337 Note that tokens separated by spaces should be treated as separate
2338 tokens since make doesn't allow path names with spaces */
2339 if (stopchar
== ':')
2340 while (p
!= 0 && !isspace ((unsigned char)*p
) &&
2341 (p
[1] == '\\' || p
[1] == '/') && isalpha ((unsigned char)p
[-1]))
2342 p
= find_char_unquote (p
+ 1, stopchar
, VMS_COMMA
, 1, 0);
2349 /* Skip leading `[]'s. */
2350 while (p
- q
> 2 && q
[0] == '[' && q
[1] == ']')
2352 /* Skip leading `./'s. */
2353 while (p
- q
> 2 && q
[0] == '.' && q
[1] == '/')
2356 q
+= 2; /* Skip "./". */
2357 while (q
< p
&& *q
== '/')
2358 /* Skip following slashes: ".//foo" is "foo", not "/foo". */
2362 /* Extract the filename just found, and skip it. */
2365 /* ".///" was stripped to "". */
2370 name
= savestring ("", 0);
2372 name
= savestring ("./", 2);
2377 /* VMS filenames can have a ':' in them but they have to be '\'ed but we need
2378 * to remove this '\' before we can use the filename.
2379 * Savestring called because q may be read-only string constant.
2382 char *qbase
= xstrdup (q
);
2383 char *pbase
= qbase
+ (p
-q
);
2390 if (*q1
== '\\' && *(q1
+1) == ':')
2397 name
= savestring (qbase
, p1
- qbase
);
2401 name
= savestring (q
, p
- q
);
2404 /* Add it to the front of the chain. */
2405 new1
= (struct nameseq
*) xmalloc (size
);
2413 /* Look for multi-word archive references.
2414 They are indicated by a elt ending with an unmatched `)' and
2415 an elt further down the chain (i.e., previous in the file list)
2416 with an unmatched `(' (e.g., "lib(mem"). */
2421 if (new1
->name
[0] != '(' /* Don't catch "(%)" and suchlike. */
2422 && new1
->name
[strlen (new1
->name
) - 1] == ')'
2423 && strchr (new1
->name
, '(') == 0)
2425 /* NEW1 ends with a `)' but does not contain a `('.
2426 Look back for an elt with an opening `(' but no closing `)'. */
2428 struct nameseq
*n
= new1
->next
, *lastn
= new1
;
2430 while (n
!= 0 && (paren
= strchr (n
->name
, '(')) == 0)
2436 /* Ignore something starting with `(', as that cannot actually
2437 be an archive-member reference (and treating it as such
2438 results in an empty file name, which causes much lossage). */
2439 && n
->name
[0] != '(')
2441 /* N is the first element in the archive group.
2442 Its name looks like "lib(mem" (with no closing `)'). */
2446 /* Copy "lib(" into LIBNAME. */
2448 libname
= (char *) alloca (paren
- n
->name
+ 1);
2449 bcopy (n
->name
, libname
, paren
- n
->name
);
2450 libname
[paren
- n
->name
] = '\0';
2454 /* N was just "lib(", part of something like "lib( a b)".
2455 Edit it out of the chain and free its storage. */
2456 lastn
->next
= n
->next
;
2459 /* LASTN->next is the new stopping elt for the loop below. */
2464 /* Replace N's name with the full archive reference. */
2465 name
= concat (libname
, paren
, ")");
2470 if (new1
->name
[1] == '\0')
2472 /* NEW1 is just ")", part of something like "lib(a b )".
2473 Omit it from the chain and free its storage. */
2477 lastnew1
->next
= new1
->next
;
2481 free ((char *) lastn
);
2485 /* Replace also NEW1->name, which already has closing `)'. */
2486 name
= concat (libname
, new1
->name
, "");
2492 /* Trace back from NEW1 (the end of the list) until N
2493 (the beginning of the list), rewriting each name
2494 with the full archive reference. */
2498 name
= concat (libname
, new1
->name
, ")");
2507 /* No frobnication happening. Just step down the list. */
2524 /* Find the next line of text in an eval buffer, combining continuation lines
2526 Return the number of actual lines read (> 1 if continuation lines).
2527 Returns -1 if there's nothing left in the buffer.
2529 After this function, ebuf->buffer points to the first character of the
2533 /* Read a line of text from a STRING.
2534 Since we aren't really reading from a file, don't bother with linenumbers.
2537 static unsigned long
2538 readstring (struct ebuffer
*ebuf
)
2542 /* If there is nothing left in this buffer, return 0. */
2543 if (ebuf
->bufnext
>= ebuf
->bufstart
+ ebuf
->size
)
2546 /* Set up a new starting point for the buffer, and find the end of the
2547 next logical line (taking into account backslash/newline pairs). */
2549 eol
= ebuf
->buffer
= ebuf
->bufnext
;
2557 /* Find the next newline. At EOS, stop. */
2558 eol
= p
= strchr (eol
, '\n');
2561 ebuf
->bufnext
= ebuf
->bufstart
+ ebuf
->size
+ 1;
2565 /* Found a newline; if it's escaped continue; else we're done. */
2566 while (p
> bol
&& *(--p
) == '\\')
2567 backslash
= !backslash
;
2573 /* Overwrite the newline char. */
2575 ebuf
->bufnext
= eol
+1;
2581 readline (struct ebuffer
*ebuf
)
2588 /* The behaviors between string and stream buffers are different enough to
2589 warrant different functions. Do the Right Thing. */
2592 return readstring (ebuf
);
2594 /* When reading from a file, we always start over at the beginning of the
2595 buffer for each new line. */
2597 p
= start
= ebuf
->bufstart
;
2598 end
= p
+ ebuf
->size
;
2601 while (fgets (p
, end
- p
, ebuf
->fp
) != 0)
2610 /* This only happens when the first thing on the line is a '\0'.
2611 It is a pretty hopeless case, but (wonder of wonders) Athena
2612 lossage strikes again! (xmkmf puts NULs in its makefiles.)
2613 There is nothing really to be done; we synthesize a newline so
2614 the following line doesn't appear to be part of this line. */
2616 _("warning: NUL character seen; rest of line ignored"));
2621 /* Jump past the text we just read. */
2624 /* If the last char isn't a newline, the whole line didn't fit into the
2625 buffer. Get some more buffer and try again. */
2629 /* We got a newline, so add one to the count of lines. */
2632 #if !defined(WINDOWS32) && !defined(__MSDOS__) && !defined(__EMX__)
2633 /* Check to see if the line was really ended with CRLF; if so ignore
2635 if ((p
- start
) > 1 && p
[-2] == '\r')
2643 for (p2
= p
- 2; p2
>= start
; --p2
)
2647 backslash
= !backslash
;
2656 /* It was a backslash/newline combo. If we have more space, read
2661 /* We need more space at the end of our buffer, so realloc it.
2662 Make sure to preserve the current offset of p. */
2665 unsigned long off
= p
- start
;
2667 start
= ebuf
->buffer
= ebuf
->bufstart
= (char *) xrealloc (start
,
2670 end
= start
+ ebuf
->size
;
2675 if (ferror (ebuf
->fp
))
2676 pfatal_with_name (ebuf
->floc
.filenm
);
2678 /* If we found some lines, return how many.
2679 If we didn't, but we did find _something_, that indicates we read the last
2680 line of a file with no final newline; return 1.
2681 If we read nothing, we're at EOF; return -1. */
2683 return nlines
? nlines
: p
== ebuf
->bufstart
? -1 : 1;
2686 /* Parse the next "makefile word" from the input buffer, and return info
2689 A "makefile word" is one of:
2691 w_bogus Should never happen
2693 w_static A static word; cannot be expanded
2694 w_variable A word containing one or more variables/functions
2696 w_dcolon A double-colon
2697 w_semicolon A semicolon
2698 w_varassign A variable assignment operator (=, :=, +=, or ?=)
2700 Note that this function is only used when reading certain parts of the
2701 makefile. Don't use it where special rules hold sway (RHS of a variable,
2702 in a command list, etc.) */
2704 static enum make_word_type
2705 get_next_mword (char *buffer
, char *delim
, char **startp
, unsigned int *length
)
2707 enum make_word_type wtype
= w_bogus
;
2708 char *p
= buffer
, *beg
;
2711 /* Skip any leading whitespace. */
2712 while (isblank ((unsigned char)*p
))
2724 wtype
= w_semicolon
;
2728 wtype
= w_varassign
;
2742 wtype
= w_varassign
;
2752 wtype
= w_varassign
;
2757 if (delim
&& strchr (delim
, c
))
2762 /* Did we find something? If so, return now. */
2763 if (wtype
!= w_bogus
)
2766 /* This is some non-operator word. A word consists of the longest
2767 string of characters that doesn't contain whitespace, one of [:=#],
2768 or [?+]=, or one of the chars in the DELIM string. */
2770 /* We start out assuming a static word; if we see a variable we'll
2771 adjust our assumptions then. */
2774 /* We already found the first value of "c", above. */
2789 #ifdef HAVE_DOS_PATHS
2790 /* A word CAN include a colon in its drive spec. The drive
2791 spec is allowed either at the beginning of a word, or as part
2792 of the archive member name, like in "libfoo.a(d:/foo/bar.o)". */
2794 && (*p
== '/' || *p
== '\\') && isalpha ((unsigned char)p
[-2])
2795 && (p
- beg
== 2 || p
[-3] == '(')))
2804 /* This is a variable reference, so note that it's expandable.
2805 Then read it to the matching close paren. */
2813 /* This is a single-letter variable reference. */
2816 for (count
=0; *p
!= '\0'; ++p
)
2820 else if (*p
== closeparen
&& --count
< 0)
2847 if (delim
&& strchr (delim
, c
))
2865 /* Construct the list of include directories
2866 from the arguments and the default list. */
2869 construct_include_path (char **arg_dirs
)
2871 register unsigned int i
;
2872 #ifdef VAXC /* just don't ask ... */
2877 /* Table to hold the dirs. */
2879 register unsigned int defsize
= (sizeof (default_include_directories
)
2880 / sizeof (default_include_directories
[0]));
2881 register unsigned int max
= 5;
2882 register char **dirs
= (char **) xmalloc ((5 + defsize
) * sizeof (char *));
2883 register unsigned int idx
= 0;
2889 /* First consider any dirs specified with -I switches.
2890 Ignore dirs that don't exist. */
2893 while (*arg_dirs
!= 0)
2895 char *dir
= *arg_dirs
++;
2900 char *expanded
= tilde_expand (dir
);
2905 EINTRLOOP (e
, stat (dir
, &stbuf
));
2906 if (e
== 0 && S_ISDIR (stbuf
.st_mode
))
2912 xrealloc ((char *) dirs
, (max
+ defsize
) * sizeof (char *));
2916 else if (dir
!= arg_dirs
[-1])
2920 /* Now add at the end the standard default dirs. */
2924 /* The environment variable $DJDIR holds the root of the
2925 DJGPP directory tree; add ${DJDIR}/include. */
2926 struct variable
*djdir
= lookup_variable ("DJDIR", 5);
2930 char *defdir
= (char *) xmalloc (strlen (djdir
->value
) + 8 + 1);
2932 strcat (strcpy (defdir
, djdir
->value
), "/include");
2933 dirs
[idx
++] = defdir
;
2938 for (i
= 0; default_include_directories
[i
] != 0; ++i
)
2942 EINTRLOOP (e
, stat (default_include_directories
[i
], &stbuf
));
2943 if (e
== 0 && S_ISDIR (stbuf
.st_mode
))
2944 dirs
[idx
++] = default_include_directories
[i
];
2949 /* Now compute the maximum length of any name in it. */
2952 for (i
= 0; i
< idx
; ++i
)
2954 unsigned int len
= strlen (dirs
[i
]);
2955 /* If dir name is written with a trailing slash, discard it. */
2956 if (dirs
[i
][len
- 1] == '/')
2957 /* We can't just clobber a null in because it may have come from
2958 a literal string and literal strings may not be writable. */
2959 dirs
[i
] = savestring (dirs
[i
], len
- 1);
2960 if (len
> max_incl_len
)
2964 include_directories
= dirs
;
2967 /* Expand ~ or ~USER at the beginning of NAME.
2968 Return a newly malloc'd string or 0. */
2971 tilde_expand (char *name
)
2974 if (name
[1] == '/' || name
[1] == '\0')
2976 extern char *getenv ();
2981 /* Turn off --warn-undefined-variables while we expand HOME. */
2982 int save
= warn_undefined_variables_flag
;
2983 warn_undefined_variables_flag
= 0;
2985 home_dir
= allocated_variable_expand ("$(HOME)");
2987 warn_undefined_variables_flag
= save
;
2990 is_variable
= home_dir
[0] != '\0';
2994 home_dir
= getenv ("HOME");
2996 #if !defined(_AMIGA) && !defined(WINDOWS32)
2997 if (home_dir
== 0 || home_dir
[0] == '\0')
2999 extern char *getlogin ();
3000 char *logname
= getlogin ();
3004 struct passwd
*p
= getpwnam (logname
);
3006 home_dir
= p
->pw_dir
;
3009 #endif /* !AMIGA && !WINDOWS32 */
3012 char *new = concat (home_dir
, "", name
+ 1);
3018 #if !defined(_AMIGA) && !defined(WINDOWS32)
3021 struct passwd
*pwent
;
3022 char *userend
= strchr (name
+ 1, '/');
3025 pwent
= getpwnam (name
+ 1);
3029 return xstrdup (pwent
->pw_dir
);
3031 return concat (pwent
->pw_dir
, "/", userend
+ 1);
3033 else if (userend
!= 0)
3036 #endif /* !AMIGA && !WINDOWS32 */
3041 /* Given a chain of struct nameseq's describing a sequence of filenames,
3042 in reverse of the intended order, return a new chain describing the
3043 result of globbing the filenames. The new chain is in forward order.
3044 The links of the old chain are freed or used in the new chain.
3045 Likewise for the names in the old chain.
3047 SIZE is how big to construct chain elements.
3048 This is useful if we want them actually to be other structures
3049 that have room for additional info. */
3052 multi_glob (struct nameseq
*chain
, unsigned int size
)
3054 extern void dir_setup_glob ();
3055 register struct nameseq
*new = 0;
3056 register struct nameseq
*old
;
3057 struct nameseq
*nexto
;
3060 dir_setup_glob (&gl
);
3062 for (old
= chain
; old
!= 0; old
= nexto
)
3070 if (old
->name
[0] == '~')
3072 char *newname
= tilde_expand (old
->name
);
3076 old
->name
= newname
;
3081 if (ar_name (old
->name
))
3083 /* OLD->name is an archive member reference.
3084 Replace it with the archive file name,
3085 and save the member name in MEMNAME.
3086 We will glob on the archive name and then
3087 reattach MEMNAME later. */
3089 ar_parse_name (old
->name
, &arname
, &memname
);
3095 #endif /* !NO_ARCHIVES */
3097 switch (glob (old
->name
, GLOB_NOCHECK
|GLOB_ALTDIRFUNC
, NULL
, &gl
))
3099 case 0: /* Success. */
3101 register int i
= gl
.gl_pathc
;
3107 /* Try to glob on MEMNAME within the archive. */
3108 struct nameseq
*found
3109 = ar_glob (gl
.gl_pathv
[i
], memname
, size
);
3112 /* No matches. Use MEMNAME as-is. */
3113 unsigned int alen
= strlen (gl
.gl_pathv
[i
]);
3114 unsigned int mlen
= strlen (memname
);
3116 = (struct nameseq
*) xmalloc (size
);
3117 if (size
> sizeof (struct nameseq
))
3118 bzero (((char *) elt
) + sizeof (struct nameseq
),
3119 size
- sizeof (struct nameseq
));
3120 elt
->name
= (char *) xmalloc (alen
+ 1 + mlen
+ 2);
3121 bcopy (gl
.gl_pathv
[i
], elt
->name
, alen
);
3122 elt
->name
[alen
] = '(';
3123 bcopy (memname
, &elt
->name
[alen
+ 1], mlen
);
3124 elt
->name
[alen
+ 1 + mlen
] = ')';
3125 elt
->name
[alen
+ 1 + mlen
+ 1] = '\0';
3131 /* Find the end of the FOUND chain. */
3132 struct nameseq
*f
= found
;
3133 while (f
->next
!= 0)
3136 /* Attach the chain being built to the end of the FOUND
3137 chain, and make FOUND the new NEW chain. */
3145 #endif /* !NO_ARCHIVES */
3147 struct nameseq
*elt
= (struct nameseq
*) xmalloc (size
);
3148 if (size
> sizeof (struct nameseq
))
3149 bzero (((char *) elt
) + sizeof (struct nameseq
),
3150 size
- sizeof (struct nameseq
));
3151 elt
->name
= xstrdup (gl
.gl_pathv
[i
]);
3163 fatal (NILF
, _("virtual memory exhausted"));