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
,
65 w_comment
, w_varassign
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 interepreting? */
82 char *seen_else
; /* Have we already seen an `else'? */
85 static struct conditionals toplevel_conditionals
;
86 static struct conditionals
*conditionals
= &toplevel_conditionals
;
89 /* Default directories to search for include files in */
91 static char *default_include_directories
[] =
93 #if defined(WINDOWS32) && !defined(INCLUDEDIR)
95 * This completely up to the user when they install MSVC or other packages.
96 * This is defined as a placeholder.
98 #define INCLUDEDIR "."
103 "/usr/local/include",
109 /* List of directories to search for include files in */
111 static char **include_directories
;
113 /* Maximum length of an element of the above. */
115 static unsigned int max_incl_len
;
117 /* The filename and pointer to line number of the
118 makefile currently being read in. */
120 const struct floc
*reading_file
= 0;
122 /* The chain of makefiles read by read_makefile. */
124 static struct dep
*read_makefiles
= 0;
126 static int eval_makefile
PARAMS ((char *filename
, int flags
));
127 static int eval
PARAMS ((struct ebuffer
*buffer
, int flags
));
129 static long readline
PARAMS ((struct ebuffer
*ebuf
));
130 static void do_define
PARAMS ((char *name
, unsigned int namelen
,
131 enum variable_origin origin
,
132 struct ebuffer
*ebuf
));
133 static int conditional_line
PARAMS ((char *line
, const struct floc
*flocp
));
134 static void record_files
PARAMS ((struct nameseq
*filenames
, char *pattern
, char *pattern_percent
,
135 struct dep
*deps
, unsigned int cmds_started
, char *commands
,
136 unsigned int commands_idx
, int two_colon
,
138 const struct floc
*flocp
, int set_default
));
139 static void record_target_var
PARAMS ((struct nameseq
*filenames
, char *defn
,
141 enum variable_origin origin
,
142 const struct floc
*flocp
));
143 static enum make_word_type get_next_mword
PARAMS ((char *buffer
, char *delim
,
144 char **startp
, unsigned int *length
));
146 /* Read in all the makefiles and return the chain of their names. */
149 read_all_makefiles (makefiles
)
152 unsigned int num_makefiles
= 0;
154 /* Create *_LIST variables, to hold the makefiles, targets, and variables
155 we will be reading. */
157 define_variable ("MAKEFILE_LIST", sizeof ("MAKEFILE_LIST")-1, "", o_file
, 0);
159 DB (DB_BASIC
, (_("Reading makefiles...\n")));
161 /* If there's a non-null variable MAKEFILES, its value is a list of
162 files to read first thing. But don't let it prevent reading the
163 default makefiles and don't let the default goal come from there. */
171 /* Turn off --warn-undefined-variables while we expand MAKEFILES. */
172 int save
= warn_undefined_variables_flag
;
173 warn_undefined_variables_flag
= 0;
175 value
= allocated_variable_expand ("$(MAKEFILES)");
177 warn_undefined_variables_flag
= save
;
180 /* Set NAME to the start of next token and LENGTH to its length.
181 MAKEFILES is updated for finding remaining tokens. */
184 while ((name
= find_next_token (&p
, &length
)) != 0)
188 name
= xstrdup (name
);
189 if (eval_makefile (name
,
190 RM_NO_DEFAULT_GOAL
|RM_INCLUDED
|RM_DONTCARE
) < 2)
197 /* Read makefiles specified with -f switches. */
200 while (*makefiles
!= 0)
202 struct dep
*tail
= read_makefiles
;
203 register struct dep
*d
;
205 if (! eval_makefile (*makefiles
, 0))
206 perror_with_name ("", *makefiles
);
208 /* Find the right element of read_makefiles. */
210 while (d
->next
!= tail
)
213 /* Use the storage read_makefile allocates. */
214 *makefiles
= dep_name (d
);
219 /* If there were no -f switches, try the default names. */
221 if (num_makefiles
== 0)
223 static char *default_makefiles
[] =
225 /* all lower case since readdir() (the vms version) 'lowercasifies' */
226 { "makefile.vms", "gnumakefile.", "makefile.", 0 };
229 { "GNUmakefile", "Makefile", "SMakefile", 0 };
230 #else /* !Amiga && !VMS */
231 { "GNUmakefile", "makefile", "Makefile", 0 };
234 register char **p
= default_makefiles
;
235 while (*p
!= 0 && !file_exists_p (*p
))
240 if (! eval_makefile (*p
, 0))
241 perror_with_name ("", *p
);
245 /* No default makefile was found. Add the default makefiles to the
246 `read_makefiles' chain so they will be updated if possible. */
247 struct dep
*tail
= read_makefiles
;
248 /* Add them to the tail, after any MAKEFILES variable makefiles. */
249 while (tail
!= 0 && tail
->next
!= 0)
251 for (p
= default_makefiles
; *p
!= 0; ++p
)
253 struct dep
*d
= (struct dep
*) xmalloc (sizeof (struct dep
));
255 d
->file
= enter_file (*p
);
256 d
->file
->dontcare
= 1;
258 /* Tell update_goal_chain to bail out as soon as this file is
259 made, and main not to die if we can't make this file. */
260 d
->changed
= RM_DONTCARE
;
272 return read_makefiles
;
276 eval_makefile (filename
, flags
)
282 const struct floc
*curfile
;
286 ebuf
.floc
.filenm
= filename
;
287 ebuf
.floc
.lineno
= 1;
289 if (ISDB (DB_VERBOSE
))
291 printf (_("Reading makefile `%s'"), filename
);
292 if (flags
& RM_NO_DEFAULT_GOAL
)
293 printf (_(" (no default goal)"));
294 if (flags
& RM_INCLUDED
)
295 printf (_(" (search path)"));
296 if (flags
& RM_DONTCARE
)
297 printf (_(" (don't care)"));
298 if (flags
& RM_NO_TILDE
)
299 printf (_(" (no ~ expansion)"));
303 /* First, get a stream to read. */
305 /* Expand ~ in FILENAME unless it came from `include',
306 in which case it was already done. */
307 if (!(flags
& RM_NO_TILDE
) && filename
[0] == '~')
309 char *expanded
= tilde_expand (filename
);
314 ebuf
.fp
= fopen (filename
, "r");
315 /* Save the error code so we print the right message later. */
316 makefile_errno
= errno
;
318 /* If the makefile wasn't found and it's either a makefile from
319 the `MAKEFILES' variable or an included makefile,
320 search the included makefile search path for this makefile. */
321 if (ebuf
.fp
== 0 && (flags
& RM_INCLUDED
) && *filename
!= '/')
323 register unsigned int i
;
324 for (i
= 0; include_directories
[i
] != 0; ++i
)
326 char *name
= concat (include_directories
[i
], "/", filename
);
327 ebuf
.fp
= fopen (name
, "r");
338 /* Add FILENAME to the chain of read makefiles. */
339 deps
= (struct dep
*) xmalloc (sizeof (struct dep
));
340 deps
->next
= read_makefiles
;
341 read_makefiles
= deps
;
343 deps
->file
= lookup_file (filename
);
346 deps
->file
= enter_file (xstrdup (filename
));
347 if (flags
& RM_DONTCARE
)
348 deps
->file
->dontcare
= 1;
350 if (filename
!= ebuf
.floc
.filenm
)
352 filename
= deps
->file
->name
;
353 deps
->changed
= flags
;
354 deps
->ignore_mtime
= 0;
356 /* If the makefile can't be found at all, give up entirely. */
360 /* If we did some searching, errno has the error from the last
361 attempt, rather from FILENAME itself. Restore it in case the
362 caller wants to use it in a message. */
363 errno
= makefile_errno
;
367 /* Add this makefile to the list. */
368 do_variable_definition (&ebuf
.floc
, "MAKEFILE_LIST", filename
, o_file
,
371 /* Evaluate the makefile */
374 ebuf
.buffer
= ebuf
.bufnext
= ebuf
.bufstart
= xmalloc (ebuf
.size
);
376 curfile
= reading_file
;
377 reading_file
= &ebuf
.floc
;
379 r
= eval (&ebuf
, !(flags
& RM_NO_DEFAULT_GOAL
));
381 reading_file
= curfile
;
385 free (ebuf
.bufstart
);
394 const struct floc
*curfile
;
397 /* Evaluate the buffer */
399 ebuf
.size
= strlen (buffer
);
400 ebuf
.buffer
= ebuf
.bufnext
= ebuf
.bufstart
= buffer
;
403 ebuf
.floc
= *reading_file
;
405 curfile
= reading_file
;
406 reading_file
= &ebuf
.floc
;
410 reading_file
= curfile
;
416 /* Read file FILENAME as a makefile and add its contents to the data base.
418 SET_DEFAULT is true if we are allowed to set the default goal.
420 FILENAME is added to the `read_makefiles' chain.
422 Returns 0 if a file was not found or not read.
423 Returns 1 if FILENAME was found and read.
424 Returns 2 if FILENAME was read, and we kept a reference (don't free it). */
427 eval (ebuf
, set_default
)
428 struct ebuffer
*ebuf
;
431 static char *collapsed
= 0;
432 static unsigned int collapsed_length
= 0;
433 unsigned int commands_len
= 200;
435 unsigned int commands_idx
= 0;
436 unsigned int cmds_started
, tgts_started
;
437 int ignoring
= 0, in_ignored_define
= 0;
438 int no_targets
= 0; /* Set when reading a rule without targets. */
439 int have_sysv_atvar
= 0;
440 struct nameseq
*filenames
= 0;
441 struct dep
*deps
= 0;
444 char *pattern
= 0, *pattern_percent
;
448 #define record_waiting_files() \
451 if (filenames != 0) \
453 fi.lineno = tgts_started; \
454 record_files (filenames, pattern, pattern_percent, deps, \
455 cmds_started, commands, commands_idx, two_colon, \
456 have_sysv_atvar, &fi, set_default); \
461 if (pattern) { free(pattern); pattern = 0; } \
465 cmds_started
= tgts_started
= 1;
467 fstart
= &ebuf
->floc
;
468 fi
.filenm
= ebuf
->floc
.filenm
;
470 /* Loop over lines in the file.
471 The strategy is to accumulate target names in FILENAMES, dependencies
472 in DEPS and commands in COMMANDS. These are used to define a rule
473 when the start of the next rule (or eof) is encountered.
475 When you see a "continue" in the loop below, that means we are moving on
476 to the next line _without_ ending any rule that we happen to be working
477 with at the moment. If you see a "goto rule_complete", then the
478 statement we just parsed also finishes the previous rule. */
480 commands
= xmalloc (200);
490 /* Grab the next line to be evaluated */
491 ebuf
->floc
.lineno
+= nlines
;
492 nlines
= readline (ebuf
);
494 /* If there is nothing left to eval, we're done. */
498 /* If this line is empty, skip it. */
503 linelen
= strlen (line
);
505 /* Check for a shell command line first.
506 If it is not one, we can stop treating tab specially. */
510 /* Ignore the commands in a rule with no targets. */
513 /* If there is no preceding rule line, don't treat this line
514 as a command, even though it begins with a tab character.
515 SunOS 4 make appears to behave this way. */
520 /* Yep, this is a shell command, and we don't care. */
523 /* Append this command line to the line being accumulated. */
524 if (commands_idx
== 0)
525 cmds_started
= ebuf
->floc
.lineno
;
527 if (linelen
+ 1 + commands_idx
> commands_len
)
529 commands_len
= (linelen
+ 1 + commands_idx
) * 2;
530 commands
= xrealloc (commands
, commands_len
);
532 bcopy (line
, &commands
[commands_idx
], linelen
);
533 commands_idx
+= linelen
;
534 commands
[commands_idx
++] = '\n';
540 /* This line is not a shell command line. Don't worry about tabs. */
542 if (collapsed_length
< linelen
+1)
544 collapsed_length
= linelen
+1;
547 collapsed
= (char *) xmalloc (collapsed_length
);
549 strcpy (collapsed
, line
);
550 /* Collapse continuation lines. */
551 collapse_continuations (collapsed
);
552 remove_comments (collapsed
);
554 /* Compare a word, both length and contents. */
555 #define word1eq(s) (len == sizeof(s)-1 && strneq (s, p, sizeof(s)-1))
557 while (isspace ((unsigned char)*p
))
561 /* This line is completely empty--ignore it. */
564 /* Find the end of the first token. Note we don't need to worry about
565 * ":" here since we compare tokens by length (so "export" will never
566 * be equal to "export:").
568 for (p2
= p
+1; *p2
!= '\0' && !isspace ((unsigned char)*p2
); ++p2
)
572 /* Find the start of the second token. If it looks like a target or
573 variable definition it can't be a preprocessor token so skip
574 them--this allows variables/targets named `ifdef', `export', etc. */
575 while (isspace ((unsigned char)*p2
))
578 if ((p2
[0] == ':' || p2
[0] == '+' || p2
[0] == '=') && p2
[1] == '\0')
580 /* It can't be a preprocessor token so skip it if we're ignoring */
584 goto skip_conditionals
;
587 /* We must first check for conditional and `define' directives before
588 ignoring anything, since they control what we will do with
591 if (!in_ignored_define
592 && (word1eq ("ifdef") || word1eq ("ifndef")
593 || word1eq ("ifeq") || word1eq ("ifneq")
594 || word1eq ("else") || word1eq ("endif")))
596 int i
= conditional_line (p
, fstart
);
598 fatal (fstart
, _("invalid syntax in conditional"));
604 if (word1eq ("endef"))
606 if (!in_ignored_define
)
607 fatal (fstart
, _("extraneous `endef'"));
608 in_ignored_define
= 0;
612 if (word1eq ("define"))
615 in_ignored_define
= 1;
619 fatal (fstart
, _("empty variable name"));
621 /* Let the variable name be the whole rest of the line,
622 with trailing blanks stripped (comments have already been
623 removed), so it could be a complex variable/function
624 reference that might contain blanks. */
625 p
= strchr (p2
, '\0');
626 while (isblank ((unsigned char)p
[-1]))
628 do_define (p2
, p
- p2
, o_file
, ebuf
);
633 if (word1eq ("override"))
636 error (fstart
, _("empty `override' directive"));
638 if (strneq (p2
, "define", 6)
639 && (isblank ((unsigned char)p2
[6]) || p2
[6] == '\0'))
642 in_ignored_define
= 1;
645 p2
= next_token (p2
+ 6);
647 fatal (fstart
, _("empty variable name"));
649 /* Let the variable name be the whole rest of the line,
650 with trailing blanks stripped (comments have already been
651 removed), so it could be a complex variable/function
652 reference that might contain blanks. */
653 p
= strchr (p2
, '\0');
654 while (isblank ((unsigned char)p
[-1]))
656 do_define (p2
, p
- p2
, o_override
, ebuf
);
660 && !try_variable_definition (fstart
, p2
, o_override
, 0))
661 error (fstart
, _("invalid `override' directive"));
667 /* Ignore the line. We continue here so conditionals
668 can appear in the middle of a rule. */
671 if (word1eq ("export"))
673 /* 'export' by itself causes everything to be exported. */
675 export_all_variables
= 1;
680 v
= try_variable_definition (fstart
, p2
, o_file
, 0);
682 v
->export
= v_export
;
686 for (p
= find_next_token (&p2
, &len
); p
!= 0;
687 p
= find_next_token (&p2
, &len
))
692 /* Expand the thing we're looking up, so we can use
693 indirect and constructed variable names. */
695 var
= allocated_variable_expand (p
);
698 v
= lookup_variable (var
, l
);
700 v
= define_variable_loc (var
, l
, "", o_file
, 0,
702 v
->export
= v_export
;
710 if (word1eq ("unexport"))
713 export_all_variables
= 0;
718 for (p
= find_next_token (&p2
, &len
); p
!= 0;
719 p
= find_next_token (&p2
, &len
))
724 /* Expand the thing we're looking up, so we can use
725 indirect and constructed variable names. */
727 var
= allocated_variable_expand (p
);
730 v
= lookup_variable (var
, l
);
732 v
= define_variable_loc (var
, l
, "", o_file
, 0, fstart
);
734 v
->export
= v_noexport
;
743 if (word1eq ("vpath"))
747 p2
= variable_expand (p2
);
748 p
= find_next_token (&p2
, &len
);
751 pattern
= savestring (p
, len
);
752 p
= find_next_token (&p2
, &len
);
753 /* No searchpath means remove all previous
754 selective VPATH's with the same pattern. */
757 /* No pattern means remove all previous selective VPATH's. */
759 construct_vpath_list (pattern
, p
);
766 if (word1eq ("include") || word1eq ("-include") || word1eq ("sinclude"))
768 /* We have found an `include' line specifying a nested
769 makefile to be read at this point. */
770 struct conditionals
*save
;
771 struct conditionals new_conditionals
;
772 struct nameseq
*files
;
773 /* "-include" (vs "include") says no error if the file does not
774 exist. "sinclude" is an alias for this from SGI. */
775 int noerror
= (p
[0] != 'i');
777 p
= allocated_variable_expand (p2
);
781 _("no file name for `%sinclude'"), noerror
? "-" : "");
785 /* Parse the list of file names. */
787 files
= multi_glob (parse_file_seq (&p2
, '\0',
788 sizeof (struct nameseq
),
790 sizeof (struct nameseq
));
793 /* Save the state of conditionals and start
794 the included makefile with a clean slate. */
796 bzero ((char *) &new_conditionals
, sizeof new_conditionals
);
797 conditionals
= &new_conditionals
;
799 /* Record the rules that are waiting so they will determine
800 the default goal before those in the included makefile. */
801 record_waiting_files ();
803 /* Read each included makefile. */
806 struct nameseq
*next
= files
->next
;
807 char *name
= files
->name
;
810 free ((char *)files
);
813 r
= eval_makefile (name
, (RM_INCLUDED
| RM_NO_TILDE
814 | (noerror
? RM_DONTCARE
: 0)));
818 error (fstart
, "%s: %s", name
, strerror (errno
));
823 /* Free any space allocated by conditional_line. */
824 if (conditionals
->ignoring
)
825 free (conditionals
->ignoring
);
826 if (conditionals
->seen_else
)
827 free (conditionals
->seen_else
);
835 if (try_variable_definition (fstart
, p
, o_file
, 0))
836 /* This line has been dealt with. */
841 p
= collapsed
; /* Ignore comments, etc. */
842 while (isblank ((unsigned char)*p
))
845 /* The line is completely blank; that is harmless. */
848 /* This line starts with a tab but was not caught above
849 because there was no preceding target, and the line
850 might have been usable as a variable definition.
851 But now we know it is definitely lossage. */
852 fatal(fstart
, _("commands commence before first target"));
855 /* This line describes some target files. This is complicated by
856 the existence of target-specific variables, because we can't
857 expand the entire line until we know if we have one or not. So
858 we expand the line word by word until we find the first `:',
859 then check to see if it's a target-specific variable.
861 In this algorithm, `lb_next' will point to the beginning of the
862 unexpanded parts of the input buffer, while `p2' points to the
863 parts of the expanded buffer we haven't searched yet. */
866 enum make_word_type wtype
;
867 enum variable_origin v_origin
;
868 char *cmdleft
, *semip
, *lb_next
;
869 unsigned int len
, plen
= 0;
872 /* Record the previous rule. */
874 record_waiting_files ();
875 tgts_started
= fstart
->lineno
;
877 /* Search the line for an unquoted ; that is not after an
879 cmdleft
= find_char_unquote (line
, ';', '#', 0);
880 if (cmdleft
!= 0 && *cmdleft
== '#')
882 /* We found a comment before a semicolon. */
886 else if (cmdleft
!= 0)
887 /* Found one. Cut the line short there before expanding it. */
891 collapse_continuations (line
);
893 /* We can't expand the entire line, since if it's a per-target
894 variable we don't want to expand it. So, walk from the
895 beginning, expanding as we go, and looking for "interesting"
896 chars. The first word is always expandable. */
897 wtype
= get_next_mword(line
, NULL
, &lb_next
, &len
);
902 fatal(fstart
, _("missing rule before commands"));
903 /* This line contained something but turned out to be nothing
904 but whitespace (a comment?). */
909 /* We accept and ignore rules without targets for
910 compatibility with SunOS 4 make. */
918 p2
= variable_expand_string(NULL
, lb_next
, len
);
924 /* Look for a semicolon in the expanded line. */
925 cmdleft
= find_char_unquote (p2
, ';', 0, 0);
929 unsigned long p2_off
= p2
- variable_buffer
;
930 unsigned long cmd_off
= cmdleft
- variable_buffer
;
931 char *pend
= p2
+ strlen(p2
);
933 /* Append any remnants of lb, then cut the line short
937 /* One school of thought says that you shouldn't expand
938 here, but merely copy, since now you're beyond a ";"
939 and into a command script. However, the old parser
940 expanded the whole line, so we continue that for
941 backwards-compatiblity. Also, it wouldn't be
942 entirely consistent, since we do an unconditional
943 expand below once we know we don't have a
944 target-specific variable. */
945 (void)variable_expand_string(pend
, lb_next
, (long)-1);
946 lb_next
+= strlen(lb_next
);
947 p2
= variable_buffer
+ p2_off
;
948 cmdleft
= variable_buffer
+ cmd_off
+ 1;
952 colonp
= find_char_unquote(p2
, ':', 0, 0);
953 #ifdef HAVE_DOS_PATHS
954 /* The drive spec brain-damage strikes again... */
955 /* Note that the only separators of targets in this context
956 are whitespace and a left paren. If others are possible,
957 they should be added to the string in the call to index. */
958 while (colonp
&& (colonp
[1] == '/' || colonp
[1] == '\\') &&
959 colonp
> p2
&& isalpha ((unsigned char)colonp
[-1]) &&
960 (colonp
== p2
+ 1 || strchr (" \t(", colonp
[-2]) != 0))
961 colonp
= find_char_unquote(colonp
+ 1, ':', 0, 0);
966 wtype
= get_next_mword(lb_next
, NULL
, &lb_next
, &len
);
972 p2
= variable_expand_string(p2
, lb_next
, len
);
973 /* We don't need to worry about cmdleft here, because if it was
974 found in the variable_buffer the entire buffer has already
975 been expanded... we'll never get here. */
978 p2
= next_token (variable_buffer
);
980 /* If the word we're looking at is EOL, see if there's _anything_
981 on the line. If not, a variable expanded to nothing, so ignore
982 it. If so, we can't parse this line so punt. */
986 /* There's no need to be ivory-tower about this: check for
987 one of the most common bugs found in makefiles... */
988 fatal (fstart
, _("missing separator%s"),
989 !strneq(line
, " ", 8) ? ""
990 : _(" (did you mean TAB instead of 8 spaces?)"));
994 /* Make the colon the end-of-string so we know where to stop
995 looking for targets. */
997 filenames
= multi_glob (parse_file_seq (&p2
, '\0',
998 sizeof (struct nameseq
),
1000 sizeof (struct nameseq
));
1005 /* We accept and ignore rules without targets for
1006 compatibility with SunOS 4 make. */
1010 /* This should never be possible; we handled it above. */
1011 assert (*p2
!= '\0');
1014 /* Is this a one-colon or two-colon entry? */
1015 two_colon
= *p2
== ':';
1019 /* Test to see if it's a target-specific variable. Copy the rest
1020 of the buffer over, possibly temporarily (we'll expand it later
1021 if it's not a target-specific variable). PLEN saves the length
1022 of the unparsed section of p2, for later. */
1023 if (*lb_next
!= '\0')
1025 unsigned int l
= p2
- variable_buffer
;
1027 (void) variable_buffer_output (p2
+plen
,
1028 lb_next
, strlen (lb_next
)+1);
1029 p2
= variable_buffer
+ l
;
1032 /* See if it's an "override" keyword; if so see if what comes after
1033 it looks like a variable definition. */
1035 wtype
= get_next_mword (p2
, NULL
, &p
, &len
);
1038 if (wtype
== w_static
&& word1eq ("override"))
1040 v_origin
= o_override
;
1041 wtype
= get_next_mword (p
+len
, NULL
, &p
, &len
);
1045 wtype
= get_next_mword (p
+len
, NULL
, NULL
, NULL
);
1047 if (wtype
== w_varassign
)
1049 /* If there was a semicolon found, add it back, plus anything
1054 variable_buffer_output (p2
+ strlen (p2
),
1055 semip
, strlen (semip
)+1);
1057 record_target_var (filenames
, p
, two_colon
, v_origin
, fstart
);
1062 /* This is a normal target, _not_ a target-specific variable.
1063 Unquote any = in the dependency list. */
1064 find_char_unquote (lb_next
, '=', 0, 0);
1066 /* We have some targets, so don't ignore the following commands. */
1069 /* Expand the dependencies, etc. */
1070 if (*lb_next
!= '\0')
1072 unsigned int l
= p2
- variable_buffer
;
1073 (void) variable_expand_string (p2
+ plen
, lb_next
, (long)-1);
1074 p2
= variable_buffer
+ l
;
1076 /* Look for a semicolon in the expanded line. */
1079 cmdleft
= find_char_unquote (p2
, ';', 0, 0);
1081 *(cmdleft
++) = '\0';
1085 /* Do any of the prerequisites appear to have $@ etc.? */
1086 have_sysv_atvar
= 0;
1087 if (!posix_pedantic
)
1088 for (p
= strchr (p2
, '$'); p
!= 0; p
= strchr (p
+1, '$'))
1089 if (p
[1] == '@' || (p
[1] == '(' && p
[2] == '@'))
1091 have_sysv_atvar
= 1;
1095 /* Is this a static pattern rule: `target: %targ: %dep; ...'? */
1096 p
= strchr (p2
, ':');
1097 while (p
!= 0 && p
[-1] == '\\')
1099 register char *q
= &p
[-1];
1100 register int backslash
= 0;
1101 while (*q
-- == '\\')
1102 backslash
= !backslash
;
1104 p
= strchr (p
+ 1, ':');
1109 /* Here, the situation is quite complicated. Let's have a look
1110 at a couple of targets:
1118 The rule is that it's only a target, if there are TWO :'s
1119 OR a space around the :.
1121 if (p
&& !(isspace ((unsigned char)p
[1]) || !p
[1]
1122 || isspace ((unsigned char)p
[-1])))
1125 #ifdef HAVE_DOS_PATHS
1131 /* For DOS paths, skip a "C:\..." or a "C:/..." */
1132 if (p
!= 0 && (p
[1] == '\\' || p
[1] == '/') &&
1133 isalpha ((unsigned char)p
[-1]) &&
1134 (p
== p2
+ 1 || strchr (" \t:(", p
[-2]) != 0)) {
1135 p
= strchr (p
+ 1, ':');
1138 } while (check_again
);
1143 struct nameseq
*target
;
1144 target
= parse_file_seq (&p2
, ':', sizeof (struct nameseq
), 1);
1147 fatal (fstart
, _("missing target pattern"));
1148 else if (target
->next
!= 0)
1149 fatal (fstart
, _("multiple target patterns"));
1150 pattern
= target
->name
;
1151 pattern_percent
= find_percent (pattern
);
1152 if (pattern_percent
== 0)
1153 fatal (fstart
, _("target pattern contains no `%%'"));
1154 free((char *)target
);
1159 /* Parse the dependencies. */
1160 deps
= (struct dep
*)
1161 multi_glob (parse_file_seq (&p2
, '|', sizeof (struct dep
), 1),
1162 sizeof (struct dep
));
1165 /* Files that follow '|' are special prerequisites that
1166 need only exist in order to satisfy the dependency.
1167 Their modification times are irrelevant. */
1168 struct dep
**deps_ptr
= &deps
;
1170 for (deps_ptr
= &deps
; *deps_ptr
; deps_ptr
= &(*deps_ptr
)->next
)
1173 *deps_ptr
= (struct dep
*)
1174 multi_glob (parse_file_seq (&p2
, '\0', sizeof (struct dep
), 1),
1175 sizeof (struct dep
));
1176 for (d
= *deps_ptr
; d
!= 0; d
= d
->next
)
1177 d
->ignore_mtime
= 1;
1183 /* Semicolon means rest of line is a command. */
1184 unsigned int len
= strlen (cmdleft
);
1186 cmds_started
= fstart
->lineno
;
1188 /* Add this command line to the buffer. */
1189 if (len
+ 2 > commands_len
)
1191 commands_len
= (len
+ 2) * 2;
1192 commands
= (char *) xrealloc (commands
, commands_len
);
1194 bcopy (cmdleft
, commands
, len
);
1195 commands_idx
+= len
;
1196 commands
[commands_idx
++] = '\n';
1202 /* We get here except in the case that we just read a rule line.
1203 Record now the last rule we read, so following spurious
1204 commands are properly diagnosed. */
1206 record_waiting_files ();
1211 if (conditionals
->if_cmds
)
1212 fatal (fstart
, _("missing `endif'"));
1214 /* At eof, record the last rule. */
1215 record_waiting_files ();
1217 free ((char *) commands
);
1223 /* Execute a `define' directive.
1224 The first line has already been read, and NAME is the name of
1225 the variable to be defined. The following lines remain to be read. */
1228 do_define (name
, namelen
, origin
, ebuf
)
1230 unsigned int namelen
;
1231 enum variable_origin origin
;
1232 struct ebuffer
*ebuf
;
1234 struct floc defstart
;
1237 unsigned int length
= 100;
1238 char *definition
= (char *) xmalloc (length
);
1239 unsigned int idx
= 0;
1242 /* Expand the variable name. */
1243 char *var
= (char *) alloca (namelen
+ 1);
1244 bcopy (name
, var
, namelen
);
1245 var
[namelen
] = '\0';
1246 var
= variable_expand (var
);
1248 defstart
= ebuf
->floc
;
1255 ebuf
->floc
.lineno
+= nlines
;
1256 nlines
= readline (ebuf
);
1258 /* If there is nothing left to eval, we're done. */
1262 line
= ebuf
->buffer
;
1264 collapse_continuations (line
);
1266 /* If the line doesn't begin with a tab, test to see if it introduces
1267 another define, or ends one. */
1269 /* Stop if we find an 'endef' */
1270 if (line
[0] != '\t')
1272 p
= next_token (line
);
1275 /* If this is another 'define', increment the level count. */
1276 if ((len
== 6 || (len
> 6 && isblank ((unsigned char)p
[6])))
1277 && strneq (p
, "define", 6))
1280 /* If this is an 'endef', decrement the count. If it's now 0,
1281 we've found the last one. */
1282 else if ((len
== 5 || (len
> 5 && isblank ((unsigned char)p
[5])))
1283 && strneq (p
, "endef", 5))
1286 remove_comments (p
);
1287 if (*next_token (p
) != '\0')
1289 _("Extraneous text after `endef' directive"));
1293 /* Define the variable. */
1295 definition
[0] = '\0';
1297 definition
[idx
- 1] = '\0';
1299 /* Always define these variables in the global set. */
1300 define_variable_global (var
, strlen (var
), definition
,
1301 origin
, 1, &defstart
);
1308 /* Otherwise add this line to the variable definition. */
1309 len
= strlen (line
);
1310 if (idx
+ len
+ 1 > length
)
1312 length
= (idx
+ len
) * 2;
1313 definition
= (char *) xrealloc (definition
, length
+ 1);
1316 bcopy (line
, &definition
[idx
], len
);
1318 /* Separate lines with a newline. */
1319 definition
[idx
++] = '\n';
1323 fatal (&defstart
, _("missing `endef', unterminated `define'"));
1329 /* Interpret conditional commands "ifdef", "ifndef", "ifeq",
1330 "ifneq", "else" and "endif".
1331 LINE is the input line, with the command as its first word.
1333 FILENAME and LINENO are the filename and line number in the
1334 current makefile. They are used for error messages.
1336 Value is -1 if the line is invalid,
1337 0 if following text should be interpreted,
1338 1 if following text should be ignored. */
1341 conditional_line (line
, flocp
)
1343 const struct floc
*flocp
;
1347 register unsigned int i
;
1351 /* It's an "if..." command. */
1352 notdef
= line
[2] == 'n';
1355 cmdname
= line
[3] == 'd' ? "ifndef" : "ifneq";
1356 line
+= cmdname
[3] == 'd' ? 7 : 6;
1360 cmdname
= line
[2] == 'd' ? "ifdef" : "ifeq";
1361 line
+= cmdname
[2] == 'd' ? 6 : 5;
1366 /* It's an "else" or "endif" command. */
1367 notdef
= line
[1] == 'n';
1368 cmdname
= notdef
? "endif" : "else";
1369 line
+= notdef
? 5 : 4;
1372 line
= next_token (line
);
1374 if (*cmdname
== 'e')
1377 error (flocp
, _("Extraneous text after `%s' directive"), cmdname
);
1378 /* "Else" or "endif". */
1379 if (conditionals
->if_cmds
== 0)
1380 fatal (flocp
, _("extraneous `%s'"), cmdname
);
1381 /* NOTDEF indicates an `endif' command. */
1383 --conditionals
->if_cmds
;
1384 else if (conditionals
->seen_else
[conditionals
->if_cmds
- 1])
1385 fatal (flocp
, _("only one `else' per conditional"));
1388 /* Toggle the state of ignorance. */
1389 conditionals
->ignoring
[conditionals
->if_cmds
- 1]
1390 = !conditionals
->ignoring
[conditionals
->if_cmds
- 1];
1391 /* Record that we have seen an `else' in this conditional.
1392 A second `else' will be erroneous. */
1393 conditionals
->seen_else
[conditionals
->if_cmds
- 1] = 1;
1395 for (i
= 0; i
< conditionals
->if_cmds
; ++i
)
1396 if (conditionals
->ignoring
[i
])
1401 if (conditionals
->allocated
== 0)
1403 conditionals
->allocated
= 5;
1404 conditionals
->ignoring
= (char *) xmalloc (conditionals
->allocated
);
1405 conditionals
->seen_else
= (char *) xmalloc (conditionals
->allocated
);
1408 ++conditionals
->if_cmds
;
1409 if (conditionals
->if_cmds
> conditionals
->allocated
)
1411 conditionals
->allocated
+= 5;
1412 conditionals
->ignoring
= (char *)
1413 xrealloc (conditionals
->ignoring
, conditionals
->allocated
);
1414 conditionals
->seen_else
= (char *)
1415 xrealloc (conditionals
->seen_else
, conditionals
->allocated
);
1418 /* Record that we have seen an `if...' but no `else' so far. */
1419 conditionals
->seen_else
[conditionals
->if_cmds
- 1] = 0;
1421 /* Search through the stack to see if we're already ignoring. */
1422 for (i
= 0; i
< conditionals
->if_cmds
- 1; ++i
)
1423 if (conditionals
->ignoring
[i
])
1425 /* We are already ignoring, so just push a level
1426 to match the next "else" or "endif", and keep ignoring.
1427 We don't want to expand variables in the condition. */
1428 conditionals
->ignoring
[conditionals
->if_cmds
- 1] = 1;
1432 if (cmdname
[notdef
? 3 : 2] == 'd')
1434 /* "Ifdef" or "ifndef". */
1437 register char *p
= end_of_token (line
);
1443 /* Expand the thing we're looking up, so we can use indirect and
1444 constructed variable names. */
1446 var
= allocated_variable_expand (line
);
1448 v
= lookup_variable (var
, strlen (var
));
1449 conditionals
->ignoring
[conditionals
->if_cmds
- 1]
1450 = (v
!= 0 && *v
->value
!= '\0') == notdef
;
1456 /* "Ifeq" or "ifneq". */
1459 char termin
= *line
== '(' ? ',' : *line
;
1461 if (termin
!= ',' && termin
!= '"' && termin
!= '\'')
1465 /* Find the end of the first string. */
1468 register int count
= 0;
1469 for (; *line
!= '\0'; ++line
)
1472 else if (*line
== ')')
1474 else if (*line
== ',' && count
<= 0)
1478 while (*line
!= '\0' && *line
!= termin
)
1486 /* Strip blanks after the first string. */
1488 while (isblank ((unsigned char)p
[-1]))
1495 s2
= variable_expand (s1
);
1496 /* We must allocate a new copy of the expanded string because
1497 variable_expand re-uses the same buffer. */
1499 s1
= (char *) alloca (len
+ 1);
1500 bcopy (s2
, s1
, len
+ 1);
1503 /* Find the start of the second string. */
1504 line
= next_token (line
);
1506 termin
= termin
== ',' ? ')' : *line
;
1507 if (termin
!= ')' && termin
!= '"' && termin
!= '\'')
1510 /* Find the end of the second string. */
1513 register int count
= 0;
1514 s2
= next_token (line
);
1515 for (line
= s2
; *line
!= '\0'; ++line
)
1519 else if (*line
== ')')
1532 while (*line
!= '\0' && *line
!= termin
)
1540 line
= next_token (++line
);
1542 error (flocp
, _("Extraneous text after `%s' directive"), cmdname
);
1544 s2
= variable_expand (s2
);
1545 conditionals
->ignoring
[conditionals
->if_cmds
- 1]
1546 = streq (s1
, s2
) == notdef
;
1549 /* Search through the stack to see if we're ignoring. */
1550 for (i
= 0; i
< conditionals
->if_cmds
; ++i
)
1551 if (conditionals
->ignoring
[i
])
1556 /* Remove duplicate dependencies in CHAIN. */
1558 static unsigned long
1559 dep_hash_1 (void const *key
)
1561 return_STRING_HASH_1 (dep_name ((struct dep
const *) key
));
1564 static unsigned long
1565 dep_hash_2 (void const *key
)
1567 return_STRING_HASH_2 (dep_name ((struct dep
const *) key
));
1571 dep_hash_cmp (void const *x
, void const *y
)
1573 struct dep
*dx
= (struct dep
*) x
;
1574 struct dep
*dy
= (struct dep
*) y
;
1575 int cmp
= strcmp (dep_name (dx
), dep_name (dy
));
1577 /* If the names are the same but ignore_mtimes are not equal, one of these
1578 is an order-only prerequisite and one isn't. That means that we should
1579 remove the one that isn't and keep the one that is. */
1581 if (!cmp
&& dx
->ignore_mtime
!= dy
->ignore_mtime
)
1582 dx
->ignore_mtime
= dy
->ignore_mtime
= 0;
1589 uniquize_deps (chain
)
1592 struct hash_table deps
;
1593 register struct dep
**depp
;
1595 hash_init (&deps
, 500, dep_hash_1
, dep_hash_2
, dep_hash_cmp
);
1597 /* Make sure that no dependencies are repeated. This does not
1598 really matter for the purpose of updating targets, but it
1599 might make some names be listed twice for $^ and $?. */
1604 struct dep
*dep
= *depp
;
1605 struct dep
**dep_slot
= (struct dep
**) hash_find_slot (&deps
, dep
);
1606 if (HASH_VACANT (*dep_slot
))
1608 hash_insert_at (&deps
, dep
, dep_slot
);
1613 /* Don't bother freeing duplicates.
1614 It's dangerous and little benefit accrues. */
1619 hash_free (&deps
, 0);
1622 /* Record target-specific variable values for files FILENAMES.
1623 TWO_COLON is nonzero if a double colon was used.
1625 The links of FILENAMES are freed, and so are any names in it
1626 that are not incorporated into other data structures.
1628 If the target is a pattern, add the variable to the pattern-specific
1629 variable value list. */
1632 record_target_var (filenames
, defn
, two_colon
, origin
, flocp
)
1633 struct nameseq
*filenames
;
1636 enum variable_origin origin
;
1637 const struct floc
*flocp
;
1639 struct nameseq
*nextf
;
1640 struct variable_set_list
*global
;
1642 global
= current_variable_set_list
;
1644 /* If the variable is an append version, store that but treat it as a
1645 normal recursive variable. */
1647 for (; filenames
!= 0; filenames
= nextf
)
1650 register char *name
= filenames
->name
;
1651 struct variable_set_list
*vlist
;
1655 nextf
= filenames
->next
;
1656 free ((char *) filenames
);
1658 /* If it's a pattern target, then add it to the pattern-specific
1660 percent
= find_percent (name
);
1663 struct pattern_var
*p
;
1665 /* Get a reference for this pattern-specific variable struct. */
1666 p
= create_pattern_var(name
, percent
);
1674 /* Get a file reference for this file, and initialize it.
1675 We don't want to just call enter_file() because that allocates a
1676 new entry if the file is a double-colon, which we don't want in
1678 f
= lookup_file (name
);
1680 f
= enter_file (name
);
1681 else if (f
->double_colon
)
1682 f
= f
->double_colon
;
1684 initialize_file_variables (f
, 1);
1685 vlist
= f
->variables
;
1689 /* Make the new variable context current and define the variable. */
1690 current_variable_set_list
= vlist
;
1691 v
= try_variable_definition (flocp
, defn
, origin
, 1);
1693 error (flocp
, _("Malformed per-target variable definition"));
1696 /* If it's not an override, check to see if there was a command-line
1697 setting. If so, reset the value. */
1698 if (origin
!= o_override
)
1700 struct variable
*gv
;
1701 int len
= strlen(v
->name
);
1703 current_variable_set_list
= global
;
1704 gv
= lookup_variable (v
->name
, len
);
1705 if (gv
&& (gv
->origin
== o_env_override
|| gv
->origin
== o_command
))
1707 v
= define_variable_in_set (v
->name
, len
, gv
->value
, gv
->origin
,
1708 gv
->recursive
, vlist
->set
, flocp
);
1713 /* Free name if not needed further. */
1714 if (name
!= fname
&& (name
< fname
|| name
> fname
+ strlen (fname
)))
1718 current_variable_set_list
= global
;
1721 /* Record a description line for files FILENAMES,
1722 with dependencies DEPS, commands to execute described
1723 by COMMANDS and COMMANDS_IDX, coming from FILENAME:COMMANDS_STARTED.
1724 TWO_COLON is nonzero if a double colon was used.
1725 If not nil, PATTERN is the `%' pattern to make this
1726 a static pattern rule, and PATTERN_PERCENT is a pointer
1727 to the `%' within it.
1729 The links of FILENAMES are freed, and so are any names in it
1730 that are not incorporated into other data structures. */
1733 record_files (filenames
, pattern
, pattern_percent
, deps
, cmds_started
,
1734 commands
, commands_idx
, two_colon
, have_sysv_atvar
,
1736 struct nameseq
*filenames
;
1737 char *pattern
, *pattern_percent
;
1739 unsigned int cmds_started
;
1741 unsigned int commands_idx
;
1743 int have_sysv_atvar
;
1744 const struct floc
*flocp
;
1747 struct nameseq
*nextf
;
1749 unsigned int max_targets
= 0, target_idx
= 0;
1750 char **targets
= 0, **target_percents
= 0;
1751 struct commands
*cmds
;
1753 if (commands_idx
> 0)
1755 cmds
= (struct commands
*) xmalloc (sizeof (struct commands
));
1756 cmds
->fileinfo
.filenm
= flocp
->filenm
;
1757 cmds
->fileinfo
.lineno
= cmds_started
;
1758 cmds
->commands
= savestring (commands
, commands_idx
);
1759 cmds
->command_lines
= 0;
1764 for (; filenames
!= 0; filenames
= nextf
)
1766 char *name
= filenames
->name
;
1770 char *implicit_percent
;
1772 nextf
= filenames
->next
;
1775 /* Check for .POSIX. We used to do this in snap_deps() but that's not
1776 good enough: it doesn't happen until after the makefile is read,
1777 which means we cannot use its value during parsing. */
1779 if (streq (name
, ".POSIX"))
1782 implicit_percent
= find_percent (name
);
1783 implicit
|= implicit_percent
!= 0;
1785 if (implicit
&& pattern
!= 0)
1786 fatal (flocp
, _("mixed implicit and static pattern rules"));
1788 if (implicit
&& implicit_percent
== 0)
1789 fatal (flocp
, _("mixed implicit and normal rules"));
1796 targets
= (char **) xmalloc (5 * sizeof (char *));
1797 target_percents
= (char **) xmalloc (5 * sizeof (char *));
1800 else if (target_idx
== max_targets
- 1)
1803 targets
= (char **) xrealloc ((char *) targets
,
1804 max_targets
* sizeof (char *));
1806 = (char **) xrealloc ((char *) target_percents
,
1807 max_targets
* sizeof (char *));
1809 targets
[target_idx
] = name
;
1810 target_percents
[target_idx
] = implicit_percent
;
1815 /* If there are multiple filenames, copy the chain DEPS
1816 for all but the last one. It is not safe for the same deps
1817 to go in more than one place in the data base. */
1818 this = nextf
!= 0 ? copy_dep_chain (deps
) : deps
;
1822 /* If this is an extended static rule:
1823 `targets: target%pattern: dep%pattern; cmds',
1824 translate each dependency pattern into a plain filename
1825 using the target pattern and this target's name. */
1826 if (!pattern_matches (pattern
, pattern_percent
, name
))
1828 /* Give a warning if the rule is meaningless. */
1830 _("target `%s' doesn't match the target pattern"), name
);
1835 /* We use patsubst_expand to do the work of translating
1836 the target pattern, the target's name and the dependencies'
1837 patterns into plain dependency names. */
1838 char *buffer
= variable_expand ("");
1840 for (d
= this; d
!= 0; d
= d
->next
)
1843 char *percent
= find_percent (d
->name
);
1846 o
= patsubst_expand (buffer
, name
, pattern
, d
->name
,
1847 pattern_percent
, percent
);
1848 /* If the name expanded to the empty string, that's
1852 _("target `%s' leaves prerequisite pattern empty"),
1855 d
->name
= savestring (buffer
, o
- buffer
);
1860 /* If at least one of the dependencies uses $$@ etc. deal with that.
1861 It would be very nice and very simple to just expand everything, but
1862 it would break a lot of backward compatibility. Maybe that's OK
1863 since we're just emulating a SysV function, and if we do that then
1864 why not emulate it completely (that's what SysV make does: it
1865 re-expands the entire prerequisite list, all the time, with $@
1866 etc. in scope. But, it would be a pain indeed to document this
1867 ("iff you use $$@, your prerequisite lists is expanded twice...")
1868 Ouch. Maybe better to make the code more complex. */
1870 if (have_sysv_atvar
)
1873 int tlen
= strlen (name
);
1874 char *fnp
= strrchr (name
, '/');
1882 flen
= strlen (fnp
);
1892 for (d
= this; d
!= 0; d
= d
->next
)
1893 for (p
= strchr (d
->name
, '$'); p
!= 0; p
= strchr (p
+1, '$'))
1899 /* If it's a '$@' or '$(@', it's escaped */
1901 && (p
[1] == '@' || (p
[1] == '(' && p
[2] == '@')))
1903 bcopy (p
, s
, strlen (p
)+1);
1907 /* Maybe found one. Check. p will point to '@' [for $@] or
1908 ')' [for $(@)] or 'D' [for $(@D)] or 'F' [for $(@F)]. */
1910 && (p
[0] != '(' || (++p
)[0] != '@'
1912 && (p
[1] != ')' || (p
[0] != 'D' && p
[0] != 'F')))))
1915 /* Found one. Compute the length and string ptr. Move p
1916 past the variable reference. */
1938 /* Get more space. */
1940 int soff
= s
- d
->name
;
1941 int poff
= p
- d
->name
;
1942 d
->name
= (char *) xrealloc (d
->name
,
1943 strlen (d
->name
) + atlen
+ 1);
1948 /* Copy the string over. */
1949 bcopy(p
, s
+atlen
, strlen (p
)+1);
1950 bcopy(at
, s
, atlen
);
1957 /* Single-colon. Combine these dependencies
1958 with others in file's existing record, if any. */
1959 f
= enter_file (name
);
1961 if (f
->double_colon
)
1963 _("target file `%s' has both : and :: entries"), f
->name
);
1965 /* If CMDS == F->CMDS, this target was listed in this rule
1966 more than once. Just give a warning since this is harmless. */
1967 if (cmds
!= 0 && cmds
== f
->cmds
)
1969 _("target `%s' given more than once in the same rule."),
1972 /* Check for two single-colon entries both with commands.
1973 Check is_target so that we don't lose on files such as .c.o
1974 whose commands were preinitialized. */
1975 else if (cmds
!= 0 && f
->cmds
!= 0 && f
->is_target
)
1977 error (&cmds
->fileinfo
,
1978 _("warning: overriding commands for target `%s'"),
1980 error (&f
->cmds
->fileinfo
,
1981 _("warning: ignoring old commands for target `%s'"),
1987 /* Defining .DEFAULT with no deps or cmds clears it. */
1988 if (f
== default_file
&& this == 0 && cmds
== 0)
1992 /* Defining .SUFFIXES with no dependencies
1993 clears out the list of suffixes. */
1994 if (f
== suffix_file
&& this == 0)
1999 struct dep
*nextd
= d
->next
;
2006 else if (f
->deps
!= 0)
2008 /* Add the file's old deps and the new ones in THIS together. */
2010 struct dep
*firstdeps
, *moredeps
;
2013 /* This is the rule with commands, so put its deps first.
2014 The rationale behind this is that $< expands to the
2015 first dep in the chain, and commands use $< expecting
2016 to get the dep that rule specifies. */
2022 /* Append the new deps to the old ones. */
2023 firstdeps
= f
->deps
;
2028 firstdeps
= moredeps
;
2032 while (d
->next
!= 0)
2037 f
->deps
= firstdeps
;
2042 /* If this is a static pattern rule, set the file's stem to
2043 the part of its name that matched the `%' in the pattern,
2044 so you can use $* in the commands. */
2047 static char *percent
= "%";
2048 char *buffer
= variable_expand ("");
2049 char *o
= patsubst_expand (buffer
, name
, pattern
, percent
,
2050 pattern_percent
, percent
);
2051 f
->stem
= savestring (buffer
, o
- buffer
);
2056 /* Double-colon. Make a new record
2057 even if the file already has one. */
2058 f
= lookup_file (name
);
2059 /* Check for both : and :: rules. Check is_target so
2060 we don't lose on default suffix rules or makefiles. */
2061 if (f
!= 0 && f
->is_target
&& !f
->double_colon
)
2063 _("target file `%s' has both : and :: entries"), f
->name
);
2064 f
= enter_file (name
);
2065 /* If there was an existing entry and it was a double-colon
2066 entry, enter_file will have returned a new one, making it the
2067 prev pointer of the old one, and setting its double_colon
2068 pointer to the first one. */
2069 if (f
->double_colon
== 0)
2070 /* This is the first entry for this name, so we must
2071 set its double_colon pointer to itself. */
2072 f
->double_colon
= f
;
2078 /* Free name if not needed further. */
2079 if (f
!= 0 && name
!= f
->name
2080 && (name
< f
->name
|| name
> f
->name
+ strlen (f
->name
)))
2086 /* See if this is first target seen whose name does
2087 not start with a `.', unless it contains a slash. */
2088 if (default_goal_file
== 0 && set_default
2089 && (*name
!= '.' || strchr (name
, '/') != 0
2090 #ifdef HAVE_DOS_PATHS
2091 || strchr (name
, '\\') != 0
2097 /* If this file is a suffix, don't
2098 let it be the default goal file. */
2100 for (d
= suffix_file
->deps
; d
!= 0; d
= d
->next
)
2102 register struct dep
*d2
;
2103 if (*dep_name (d
) != '.' && streq (name
, dep_name (d
)))
2108 for (d2
= suffix_file
->deps
; d2
!= 0; d2
= d2
->next
)
2110 register unsigned int len
= strlen (dep_name (d2
));
2111 if (!strneq (name
, dep_name (d2
), len
))
2113 if (streq (name
+ len
, dep_name (d
)))
2124 default_goal_file
= f
;
2130 targets
[target_idx
] = 0;
2131 target_percents
[target_idx
] = 0;
2132 create_pattern_rule (targets
, target_percents
, two_colon
, deps
, cmds
, 1);
2133 free ((char *) target_percents
);
2137 /* Search STRING for an unquoted STOPCHAR or blank (if BLANK is nonzero).
2138 Backslashes quote STOPCHAR, blanks if BLANK is nonzero, and backslash.
2139 Quoting backslashes are removed from STRING by compacting it into
2140 itself. Returns a pointer to the first unquoted STOPCHAR if there is
2141 one, or nil if there are none. */
2144 find_char_unquote (string
, stop1
, stop2
, blank
)
2150 unsigned int string_len
= 0;
2151 register char *p
= string
;
2156 while (*p
!= '\0' && *p
!= stop1
&& *p
!= stop2
2157 && ! isblank ((unsigned char) *p
))
2160 while (*p
!= '\0' && *p
!= stop1
&& *p
!= stop2
)
2163 while (*p
!= '\0' && *p
!= stop1
2164 && ! isblank ((unsigned char) *p
))
2167 while (*p
!= '\0' && *p
!= stop1
)
2173 if (p
> string
&& p
[-1] == '\\')
2175 /* Search for more backslashes. */
2176 register int i
= -2;
2177 while (&p
[i
] >= string
&& p
[i
] == '\\')
2180 /* Only compute the length if really needed. */
2181 if (string_len
== 0)
2182 string_len
= strlen (string
);
2183 /* The number of backslashes is now -I.
2184 Copy P over itself to swallow half of them. */
2185 bcopy (&p
[i
/ 2], &p
[i
], (string_len
- (p
- string
)) - (i
/ 2) + 1);
2188 /* All the backslashes quoted each other; the STOPCHAR was
2192 /* The STOPCHAR was quoted by a backslash. Look for another. */
2195 /* No backslash in sight. */
2199 /* Never hit a STOPCHAR or blank (with BLANK nonzero). */
2203 /* Search PATTERN for an unquoted %. */
2206 find_percent (pattern
)
2209 return find_char_unquote (pattern
, '%', 0, 0);
2212 /* Parse a string into a sequence of filenames represented as a
2213 chain of struct nameseq's in reverse order and return that chain.
2215 The string is passed as STRINGP, the address of a string pointer.
2216 The string pointer is updated to point at the first character
2217 not parsed, which either is a null char or equals STOPCHAR.
2219 SIZE is how big to construct chain elements.
2220 This is useful if we want them actually to be other structures
2221 that have room for additional info.
2223 If STRIP is nonzero, strip `./'s off the beginning. */
2226 parse_file_seq (stringp
, stopchar
, size
, strip
)
2232 register struct nameseq
*new = 0;
2233 register struct nameseq
*new1
, *lastnew1
;
2234 register char *p
= *stringp
;
2239 # define VMS_COMMA ','
2241 # define VMS_COMMA 0
2246 /* Skip whitespace; see if any more names are left. */
2253 /* Yes, find end of next name. */
2255 p
= find_char_unquote (q
, stopchar
, VMS_COMMA
, 1);
2257 /* convert comma separated list to space separated */
2262 if (stopchar
== ':' && p
&& *p
== ':'
2263 && !(isspace ((unsigned char)p
[1]) || !p
[1]
2264 || isspace ((unsigned char)p
[-1])))
2266 p
= find_char_unquote (p
+1, stopchar
, VMS_COMMA
, 1);
2269 #ifdef HAVE_DOS_PATHS
2270 /* For DOS paths, skip a "C:\..." or a "C:/..." until we find the
2271 first colon which isn't followed by a slash or a backslash.
2272 Note that tokens separated by spaces should be treated as separate
2273 tokens since make doesn't allow path names with spaces */
2274 if (stopchar
== ':')
2275 while (p
!= 0 && !isspace ((unsigned char)*p
) &&
2276 (p
[1] == '\\' || p
[1] == '/') && isalpha ((unsigned char)p
[-1]))
2277 p
= find_char_unquote (p
+ 1, stopchar
, VMS_COMMA
, 1);
2284 /* Skip leading `[]'s. */
2285 while (p
- q
> 2 && q
[0] == '[' && q
[1] == ']')
2287 /* Skip leading `./'s. */
2288 while (p
- q
> 2 && q
[0] == '.' && q
[1] == '/')
2291 q
+= 2; /* Skip "./". */
2292 while (q
< p
&& *q
== '/')
2293 /* Skip following slashes: ".//foo" is "foo", not "/foo". */
2297 /* Extract the filename just found, and skip it. */
2300 /* ".///" was stripped to "". */
2305 name
= savestring ("", 0);
2307 name
= savestring ("./", 2);
2312 /* VMS filenames can have a ':' in them but they have to be '\'ed but we need
2313 * to remove this '\' before we can use the filename.
2314 * Savestring called because q may be read-only string constant.
2317 char *qbase
= xstrdup (q
);
2318 char *pbase
= qbase
+ (p
-q
);
2325 if (*q1
== '\\' && *(q1
+1) == ':')
2332 name
= savestring (qbase
, p1
- qbase
);
2336 name
= savestring (q
, p
- q
);
2339 /* Add it to the front of the chain. */
2340 new1
= (struct nameseq
*) xmalloc (size
);
2348 /* Look for multi-word archive references.
2349 They are indicated by a elt ending with an unmatched `)' and
2350 an elt further down the chain (i.e., previous in the file list)
2351 with an unmatched `(' (e.g., "lib(mem"). */
2356 if (new1
->name
[0] != '(' /* Don't catch "(%)" and suchlike. */
2357 && new1
->name
[strlen (new1
->name
) - 1] == ')'
2358 && strchr (new1
->name
, '(') == 0)
2360 /* NEW1 ends with a `)' but does not contain a `('.
2361 Look back for an elt with an opening `(' but no closing `)'. */
2363 struct nameseq
*n
= new1
->next
, *lastn
= new1
;
2365 while (n
!= 0 && (paren
= strchr (n
->name
, '(')) == 0)
2371 /* Ignore something starting with `(', as that cannot actually
2372 be an archive-member reference (and treating it as such
2373 results in an empty file name, which causes much lossage). */
2374 && n
->name
[0] != '(')
2376 /* N is the first element in the archive group.
2377 Its name looks like "lib(mem" (with no closing `)'). */
2381 /* Copy "lib(" into LIBNAME. */
2383 libname
= (char *) alloca (paren
- n
->name
+ 1);
2384 bcopy (n
->name
, libname
, paren
- n
->name
);
2385 libname
[paren
- n
->name
] = '\0';
2389 /* N was just "lib(", part of something like "lib( a b)".
2390 Edit it out of the chain and free its storage. */
2391 lastn
->next
= n
->next
;
2394 /* LASTN->next is the new stopping elt for the loop below. */
2399 /* Replace N's name with the full archive reference. */
2400 name
= concat (libname
, paren
, ")");
2405 if (new1
->name
[1] == '\0')
2407 /* NEW1 is just ")", part of something like "lib(a b )".
2408 Omit it from the chain and free its storage. */
2412 lastnew1
->next
= new1
->next
;
2416 free ((char *) lastn
);
2420 /* Replace also NEW1->name, which already has closing `)'. */
2421 name
= concat (libname
, new1
->name
, "");
2427 /* Trace back from NEW1 (the end of the list) until N
2428 (the beginning of the list), rewriting each name
2429 with the full archive reference. */
2433 name
= concat (libname
, new1
->name
, ")");
2442 /* No frobnication happening. Just step down the list. */
2459 /* Find the next line of text in an eval buffer, combining continuation lines
2461 Return the number of actual lines read (> 1 if continuation lines).
2462 Returns -1 if there's nothing left in the buffer.
2464 After this function, ebuf->buffer points to the first character of the
2468 /* Read a line of text from a STRING.
2469 Since we aren't really reading from a file, don't bother with linenumbers.
2472 static unsigned long
2474 struct ebuffer
*ebuf
;
2478 /* If there is nothing left in this buffer, return 0. */
2479 if (ebuf
->bufnext
> ebuf
->bufstart
+ ebuf
->size
)
2482 /* Set up a new starting point for the buffer, and find the end of the
2483 next logical line (taking into account backslash/newline pairs). */
2485 p
= ebuf
->buffer
= ebuf
->bufnext
;
2491 /* Find the next newline. Keep track of backslashes as we look. */
2492 for (; *p
!= '\n' && *p
!= '\0'; ++p
)
2494 backslash
= !backslash
;
2496 /* If we got to the end of the string or a newline with no backslash,
2498 if (*p
== '\0' || !backslash
)
2502 /* Overwrite the newline char. */
2504 ebuf
->bufnext
= p
+1;
2511 struct ebuffer
*ebuf
;
2518 /* The behaviors between string and stream buffers are different enough to
2519 warrant different functions. Do the Right Thing. */
2522 return readstring (ebuf
);
2524 /* When reading from a file, we always start over at the beginning of the
2525 buffer for each new line. */
2527 p
= start
= ebuf
->bufstart
;
2528 end
= p
+ ebuf
->size
;
2531 while (fgets (p
, end
- p
, ebuf
->fp
) != 0)
2540 /* This only happens when the first thing on the line is a '\0'.
2541 It is a pretty hopeless case, but (wonder of wonders) Athena
2542 lossage strikes again! (xmkmf puts NULs in its makefiles.)
2543 There is nothing really to be done; we synthesize a newline so
2544 the following line doesn't appear to be part of this line. */
2546 _("warning: NUL character seen; rest of line ignored"));
2551 /* Jump past the text we just read. */
2554 /* If the last char isn't a newline, the whole line didn't fit into the
2555 buffer. Get some more buffer and try again. */
2559 /* We got a newline, so add one to the count of lines. */
2562 #if !defined(WINDOWS32) && !defined(__MSDOS__)
2563 /* Check to see if the line was really ended with CRLF; if so ignore
2565 if ((p
- start
) > 1 && p
[-2] == '\r')
2573 for (p2
= p
- 2; p2
>= start
; --p2
)
2577 backslash
= !backslash
;
2586 /* It was a backslash/newline combo. If we have more space, read
2591 /* We need more space at the end of our buffer, so realloc it.
2592 Make sure to preserve the current offset of p. */
2595 unsigned long off
= p
- start
;
2597 start
= ebuf
->buffer
= ebuf
->bufstart
= (char *) xrealloc (start
,
2600 end
= start
+ ebuf
->size
;
2605 if (ferror (ebuf
->fp
))
2606 pfatal_with_name (ebuf
->floc
.filenm
);
2608 /* If we found some lines, return how many.
2609 If we didn't, but we did find _something_, that indicates we read the last
2610 line of a file with no final newline; return 1.
2611 If we read nothing, we're at EOF; return -1. */
2613 return nlines
? nlines
: p
== ebuf
->bufstart
? -1 : 1;
2616 /* Parse the next "makefile word" from the input buffer, and return info
2619 A "makefile word" is one of:
2621 w_bogus Should never happen
2623 w_static A static word; cannot be expanded
2624 w_variable A word containing one or more variables/functions
2626 w_dcolon A double-colon
2627 w_semicolon A semicolon
2628 w_comment A comment character
2629 w_varassign A variable assignment operator (=, :=, +=, or ?=)
2631 Note that this function is only used when reading certain parts of the
2632 makefile. Don't use it where special rules hold sway (RHS of a variable,
2633 in a command list, etc.) */
2635 static enum make_word_type
2636 get_next_mword (buffer
, delim
, startp
, length
)
2640 unsigned int *length
;
2642 enum make_word_type wtype
= w_bogus
;
2643 char *p
= buffer
, *beg
;
2646 /* Skip any leading whitespace. */
2647 while (isblank ((unsigned char)*p
))
2663 wtype
= w_semicolon
;
2667 wtype
= w_varassign
;
2681 wtype
= w_varassign
;
2691 wtype
= w_varassign
;
2696 if (delim
&& strchr (delim
, c
))
2701 /* Did we find something? If so, return now. */
2702 if (wtype
!= w_bogus
)
2705 /* This is some non-operator word. A word consists of the longest
2706 string of characters that doesn't contain whitespace, one of [:=#],
2707 or [?+]=, or one of the chars in the DELIM string. */
2709 /* We start out assuming a static word; if we see a variable we'll
2710 adjust our assumptions then. */
2713 /* We already found the first value of "c", above. */
2729 #ifdef HAVE_DOS_PATHS
2730 /* A word CAN include a colon in its drive spec. The drive
2731 spec is allowed either at the beginning of a word, or as part
2732 of the archive member name, like in "libfoo.a(d:/foo/bar.o)". */
2734 && (*p
== '/' || *p
== '\\') && isalpha ((unsigned char)p
[-2])
2735 && (p
- beg
== 2 || p
[-3] == '(')))
2744 /* This is a variable reference, so note that it's expandable.
2745 Then read it to the matching close paren. */
2753 /* This is a single-letter variable reference. */
2756 for (count
=0; *p
!= '\0'; ++p
)
2760 else if (*p
== closeparen
&& --count
< 0)
2787 if (delim
&& strchr (delim
, c
))
2805 /* Construct the list of include directories
2806 from the arguments and the default list. */
2809 construct_include_path (arg_dirs
)
2812 register unsigned int i
;
2813 #ifdef VAXC /* just don't ask ... */
2818 /* Table to hold the dirs. */
2820 register unsigned int defsize
= (sizeof (default_include_directories
)
2821 / sizeof (default_include_directories
[0]));
2822 register unsigned int max
= 5;
2823 register char **dirs
= (char **) xmalloc ((5 + defsize
) * sizeof (char *));
2824 register unsigned int idx
= 0;
2830 /* First consider any dirs specified with -I switches.
2831 Ignore dirs that don't exist. */
2834 while (*arg_dirs
!= 0)
2836 char *dir
= *arg_dirs
++;
2840 char *expanded
= tilde_expand (dir
);
2845 if (stat (dir
, &stbuf
) == 0 && S_ISDIR (stbuf
.st_mode
))
2851 xrealloc ((char *) dirs
, (max
+ defsize
) * sizeof (char *));
2855 else if (dir
!= arg_dirs
[-1])
2859 /* Now add at the end the standard default dirs. */
2863 /* The environment variable $DJDIR holds the root of the
2864 DJGPP directory tree; add ${DJDIR}/include. */
2865 struct variable
*djdir
= lookup_variable ("DJDIR", 5);
2869 char *defdir
= (char *) xmalloc (strlen (djdir
->value
) + 8 + 1);
2871 strcat (strcpy (defdir
, djdir
->value
), "/include");
2872 dirs
[idx
++] = defdir
;
2877 for (i
= 0; default_include_directories
[i
] != 0; ++i
)
2878 if (stat (default_include_directories
[i
], &stbuf
) == 0
2879 && S_ISDIR (stbuf
.st_mode
))
2880 dirs
[idx
++] = default_include_directories
[i
];
2884 /* Now compute the maximum length of any name in it. */
2887 for (i
= 0; i
< idx
; ++i
)
2889 unsigned int len
= strlen (dirs
[i
]);
2890 /* If dir name is written with a trailing slash, discard it. */
2891 if (dirs
[i
][len
- 1] == '/')
2892 /* We can't just clobber a null in because it may have come from
2893 a literal string and literal strings may not be writable. */
2894 dirs
[i
] = savestring (dirs
[i
], len
- 1);
2895 if (len
> max_incl_len
)
2899 include_directories
= dirs
;
2902 /* Expand ~ or ~USER at the beginning of NAME.
2903 Return a newly malloc'd string or 0. */
2910 if (name
[1] == '/' || name
[1] == '\0')
2912 extern char *getenv ();
2917 /* Turn off --warn-undefined-variables while we expand HOME. */
2918 int save
= warn_undefined_variables_flag
;
2919 warn_undefined_variables_flag
= 0;
2921 home_dir
= allocated_variable_expand ("$(HOME)");
2923 warn_undefined_variables_flag
= save
;
2926 is_variable
= home_dir
[0] != '\0';
2930 home_dir
= getenv ("HOME");
2932 #if !defined(_AMIGA) && !defined(WINDOWS32)
2933 if (home_dir
== 0 || home_dir
[0] == '\0')
2935 extern char *getlogin ();
2936 char *logname
= getlogin ();
2940 struct passwd
*p
= getpwnam (logname
);
2942 home_dir
= p
->pw_dir
;
2945 #endif /* !AMIGA && !WINDOWS32 */
2948 char *new = concat (home_dir
, "", name
+ 1);
2954 #if !defined(_AMIGA) && !defined(WINDOWS32)
2957 struct passwd
*pwent
;
2958 char *userend
= strchr (name
+ 1, '/');
2961 pwent
= getpwnam (name
+ 1);
2965 return xstrdup (pwent
->pw_dir
);
2967 return concat (pwent
->pw_dir
, "/", userend
+ 1);
2969 else if (userend
!= 0)
2972 #endif /* !AMIGA && !WINDOWS32 */
2977 /* Given a chain of struct nameseq's describing a sequence of filenames,
2978 in reverse of the intended order, return a new chain describing the
2979 result of globbing the filenames. The new chain is in forward order.
2980 The links of the old chain are freed or used in the new chain.
2981 Likewise for the names in the old chain.
2983 SIZE is how big to construct chain elements.
2984 This is useful if we want them actually to be other structures
2985 that have room for additional info. */
2988 multi_glob (chain
, size
)
2989 struct nameseq
*chain
;
2992 extern void dir_setup_glob ();
2993 register struct nameseq
*new = 0;
2994 register struct nameseq
*old
;
2995 struct nameseq
*nexto
;
2998 dir_setup_glob (&gl
);
3000 for (old
= chain
; old
!= 0; old
= nexto
)
3008 if (old
->name
[0] == '~')
3010 char *newname
= tilde_expand (old
->name
);
3014 old
->name
= newname
;
3019 if (ar_name (old
->name
))
3021 /* OLD->name is an archive member reference.
3022 Replace it with the archive file name,
3023 and save the member name in MEMNAME.
3024 We will glob on the archive name and then
3025 reattach MEMNAME later. */
3027 ar_parse_name (old
->name
, &arname
, &memname
);
3033 #endif /* !NO_ARCHIVES */
3035 switch (glob (old
->name
, GLOB_NOCHECK
|GLOB_ALTDIRFUNC
, NULL
, &gl
))
3037 case 0: /* Success. */
3039 register int i
= gl
.gl_pathc
;
3045 /* Try to glob on MEMNAME within the archive. */
3046 struct nameseq
*found
3047 = ar_glob (gl
.gl_pathv
[i
], memname
, size
);
3050 /* No matches. Use MEMNAME as-is. */
3051 unsigned int alen
= strlen (gl
.gl_pathv
[i
]);
3052 unsigned int mlen
= strlen (memname
);
3054 = (struct nameseq
*) xmalloc (size
);
3055 if (size
> sizeof (struct nameseq
))
3056 bzero (((char *) elt
) + sizeof (struct nameseq
),
3057 size
- sizeof (struct nameseq
));
3058 elt
->name
= (char *) xmalloc (alen
+ 1 + mlen
+ 2);
3059 bcopy (gl
.gl_pathv
[i
], elt
->name
, alen
);
3060 elt
->name
[alen
] = '(';
3061 bcopy (memname
, &elt
->name
[alen
+ 1], mlen
);
3062 elt
->name
[alen
+ 1 + mlen
] = ')';
3063 elt
->name
[alen
+ 1 + mlen
+ 1] = '\0';
3069 /* Find the end of the FOUND chain. */
3070 struct nameseq
*f
= found
;
3071 while (f
->next
!= 0)
3074 /* Attach the chain being built to the end of the FOUND
3075 chain, and make FOUND the new NEW chain. */
3083 #endif /* !NO_ARCHIVES */
3085 struct nameseq
*elt
= (struct nameseq
*) xmalloc (size
);
3086 if (size
> sizeof (struct nameseq
))
3087 bzero (((char *) elt
) + sizeof (struct nameseq
),
3088 size
- sizeof (struct nameseq
));
3089 elt
->name
= xstrdup (gl
.gl_pathv
[i
]);
3101 fatal (NILF
, _("virtual memory exhausted"));