1 /* Reading and parsing of makefiles for GNU Make.
2 Copyright (C) 1988,89,90,91,92,93,94,95,96,97 Free Software Foundation, Inc.
3 This file is part of GNU Make.
5 GNU Make is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2, or (at your option)
10 GNU Make is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GNU Make; see the file COPYING. If not, write to
17 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA. */
40 struct passwd
*getpwnam
PARAMS ((char *name
));
43 #endif /* !WINDOWS32 */
45 /* A `struct linebuffer' is a structure which holds a line of text.
46 `readline' reads a line from a stream into a linebuffer
47 and works regardless of the length of the line. */
51 /* Note: This is the number of bytes malloc'ed for `buffer'
52 It does not indicate `buffer's real length.
53 Instead, a null char indicates end-of-string. */
58 #define initbuffer(lb) (lb)->buffer = (char *) xmalloc ((lb)->size = 200)
59 #define freebuffer(lb) free ((lb)->buffer)
62 /* Types of "words" that can be read in a makefile. */
65 w_bogus
, w_eol
, w_static
, w_variable
, w_colon
, w_dcolon
, w_semicolon
,
66 w_comment
, w_varassign
70 /* A `struct conditionals' contains the information describing
71 all the active conditionals in a makefile.
73 The global variable `conditionals' contains the conditionals
74 information for the current makefile. It is initialized from
75 the static structure `toplevel_conditionals' and is later changed
76 to new structures for included makefiles. */
80 unsigned int if_cmds
; /* Depth of conditional nesting. */
81 unsigned int allocated
; /* Elts allocated in following arrays. */
82 char *ignoring
; /* Are we ignoring or interepreting? */
83 char *seen_else
; /* Have we already seen an `else'? */
86 static struct conditionals toplevel_conditionals
;
87 static struct conditionals
*conditionals
= &toplevel_conditionals
;
90 /* Default directories to search for include files in */
92 static char *default_include_directories
[] =
94 #if defined(WINDOWS32) && !defined(INCLUDEDIR)
96 * This completly up to the user when they install MSVC or other packages.
97 * This is defined as a placeholder.
99 #define INCLUDEDIR "."
104 "/usr/local/include",
110 /* List of directories to search for include files in */
112 static char **include_directories
;
114 /* Maximum length of an element of the above. */
116 static unsigned int max_incl_len
;
118 /* The filename and pointer to line number of the
119 makefile currently being read in. */
121 const struct floc
*reading_file
;
123 /* The chain of makefiles read by read_makefile. */
125 static struct dep
*read_makefiles
= 0;
127 static int read_makefile
PARAMS ((char *filename
, int flags
));
128 static unsigned long readline
PARAMS ((struct linebuffer
*linebuffer
,
129 FILE *stream
, const struct floc
*flocp
));
130 static void do_define
PARAMS ((char *name
, unsigned int namelen
,
131 enum variable_origin origin
, FILE *infile
,
132 struct floc
*flocp
));
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
,
137 const struct floc
*flocp
, int set_default
));
138 static void record_target_var
PARAMS ((struct nameseq
*filenames
, char *defn
,
140 enum variable_origin origin
,
141 const struct floc
*flocp
));
142 static enum make_word_type get_next_mword
PARAMS ((char *buffer
, char *delim
,
143 char **startp
, unsigned int *length
));
145 /* Read in all the makefiles and return the chain of their names. */
148 read_all_makefiles (makefiles
)
151 unsigned int num_makefiles
= 0;
153 DB (DB_BASIC
, (_("Reading makefiles...\n")));
155 /* If there's a non-null variable MAKEFILES, its value is a list of
156 files to read first thing. But don't let it prevent reading the
157 default makefiles and don't let the default goal come from there. */
165 /* Turn off --warn-undefined-variables while we expand MAKEFILES. */
166 int save
= warn_undefined_variables_flag
;
167 warn_undefined_variables_flag
= 0;
169 value
= allocated_variable_expand ("$(MAKEFILES)");
171 warn_undefined_variables_flag
= save
;
174 /* Set NAME to the start of next token and LENGTH to its length.
175 MAKEFILES is updated for finding remaining tokens. */
178 while ((name
= find_next_token (&p
, &length
)) != 0)
182 name
= xstrdup (name
);
183 if (read_makefile (name
,
184 RM_NO_DEFAULT_GOAL
|RM_INCLUDED
|RM_DONTCARE
) < 2)
191 /* Read makefiles specified with -f switches. */
194 while (*makefiles
!= 0)
196 struct dep
*tail
= read_makefiles
;
197 register struct dep
*d
;
199 if (! read_makefile (*makefiles
, 0))
200 perror_with_name ("", *makefiles
);
202 /* Find the right element of read_makefiles. */
204 while (d
->next
!= tail
)
207 /* Use the storage read_makefile allocates. */
208 *makefiles
= dep_name (d
);
213 /* If there were no -f switches, try the default names. */
215 if (num_makefiles
== 0)
217 static char *default_makefiles
[] =
219 /* all lower case since readdir() (the vms version) 'lowercasifies' */
220 { "makefile.vms", "gnumakefile.", "makefile.", 0 };
223 { "GNUmakefile", "Makefile", "SMakefile", 0 };
224 #else /* !Amiga && !VMS */
225 { "GNUmakefile", "makefile", "Makefile", 0 };
228 register char **p
= default_makefiles
;
229 while (*p
!= 0 && !file_exists_p (*p
))
234 if (! read_makefile (*p
, 0))
235 perror_with_name ("", *p
);
239 /* No default makefile was found. Add the default makefiles to the
240 `read_makefiles' chain so they will be updated if possible. */
241 struct dep
*tail
= read_makefiles
;
242 /* Add them to the tail, after any MAKEFILES variable makefiles. */
243 while (tail
!= 0 && tail
->next
!= 0)
245 for (p
= default_makefiles
; *p
!= 0; ++p
)
247 struct dep
*d
= (struct dep
*) xmalloc (sizeof (struct dep
));
249 d
->file
= enter_file (*p
);
250 d
->file
->dontcare
= 1;
251 /* Tell update_goal_chain to bail out as soon as this file is
252 made, and main not to die if we can't make this file. */
253 d
->changed
= RM_DONTCARE
;
265 return read_makefiles
;
268 /* Read file FILENAME as a makefile and add its contents to the data base.
270 FLAGS contains bits as above.
272 FILENAME is added to the `read_makefiles' chain.
274 Returns 0 if a file was not found or not read.
275 Returns 1 if FILENAME was found and read.
276 Returns 2 if FILENAME was read, and we kept a reference (don't free it). */
279 read_makefile (filename
, flags
)
283 static char *collapsed
= 0;
284 static unsigned int collapsed_length
= 0;
285 register FILE *infile
;
286 struct linebuffer lb
;
287 unsigned int commands_len
= 200;
289 unsigned int commands_idx
= 0;
290 unsigned int cmds_started
, tgts_started
;
293 int len
, reading_target
;
294 int ignoring
= 0, in_ignored_define
= 0;
295 int no_targets
= 0; /* Set when reading a rule without targets. */
296 struct floc fileinfo
;
297 char *passed_filename
= filename
;
299 struct nameseq
*filenames
= 0;
301 unsigned int nlines
= 0;
303 char *pattern
= 0, *pattern_percent
;
306 #if defined (WINDOWS32) || defined (__MSDOS__)
310 #define record_waiting_files() \
313 if (filenames != 0) \
316 fi.filenm = fileinfo.filenm; \
317 fi.lineno = tgts_started; \
318 record_files (filenames, pattern, pattern_percent, deps, \
319 cmds_started, commands, commands_idx, two_colon, \
320 &fi, !(flags & RM_NO_DEFAULT_GOAL)); \
324 if (pattern) { free(pattern); pattern = 0; } \
327 fileinfo
.filenm
= filename
;
331 cmds_started
= tgts_started
= fileinfo
.lineno
;
333 if (ISDB (DB_VERBOSE
))
335 printf (_("Reading makefile `%s'"), fileinfo
.filenm
);
336 if (flags
& RM_NO_DEFAULT_GOAL
)
337 printf (_(" (no default goal)"));
338 if (flags
& RM_INCLUDED
)
339 printf (_(" (search path)"));
340 if (flags
& RM_DONTCARE
)
341 printf (_(" (don't care)"));
342 if (flags
& RM_NO_TILDE
)
343 printf (_(" (no ~ expansion)"));
347 /* First, get a stream to read. */
349 /* Expand ~ in FILENAME unless it came from `include',
350 in which case it was already done. */
351 if (!(flags
& RM_NO_TILDE
) && filename
[0] == '~')
353 char *expanded
= tilde_expand (filename
);
358 infile
= fopen (filename
, "r");
359 /* Save the error code so we print the right message later. */
360 makefile_errno
= errno
;
362 /* If the makefile wasn't found and it's either a makefile from
363 the `MAKEFILES' variable or an included makefile,
364 search the included makefile search path for this makefile. */
365 if (infile
== 0 && (flags
& RM_INCLUDED
) && *filename
!= '/')
367 register unsigned int i
;
368 for (i
= 0; include_directories
[i
] != 0; ++i
)
370 char *name
= concat (include_directories
[i
], "/", filename
);
371 infile
= fopen (name
, "r");
382 /* Add FILENAME to the chain of read makefiles. */
383 deps
= (struct dep
*) xmalloc (sizeof (struct dep
));
384 deps
->next
= read_makefiles
;
385 read_makefiles
= deps
;
387 deps
->file
= lookup_file (filename
);
390 deps
->file
= enter_file (xstrdup (filename
));
391 if (flags
& RM_DONTCARE
)
392 deps
->file
->dontcare
= 1;
394 if (filename
!= passed_filename
)
396 filename
= deps
->file
->name
;
397 deps
->changed
= flags
;
400 /* If the makefile can't be found at all, give up entirely. */
404 /* If we did some searching, errno has the error from the last
405 attempt, rather from FILENAME itself. Restore it in case the
406 caller wants to use it in a message. */
407 errno
= makefile_errno
;
411 reading_file
= &fileinfo
;
413 /* Loop over lines in the file.
414 The strategy is to accumulate target names in FILENAMES, dependencies
415 in DEPS and commands in COMMANDS. These are used to define a rule
416 when the start of the next rule (or eof) is encountered. */
419 commands
= xmalloc (200);
421 while (!feof (infile
))
423 fileinfo
.lineno
+= nlines
;
424 nlines
= readline (&lb
, infile
, &fileinfo
);
426 /* Check for a shell command line first.
427 If it is not one, we can stop treating tab specially. */
428 if (lb
.buffer
[0] == '\t')
430 /* This line is a probably shell command. */
434 /* Ignore the commands in a rule with no targets. */
437 /* If there is no preceding rule line, don't treat this line
438 as a command, even though it begins with a tab character.
439 SunOS 4 make appears to behave this way. */
444 /* Yep, this is a shell command, and we don't care. */
447 /* Append this command line to the line being accumulated. */
449 if (commands_idx
== 0)
450 cmds_started
= fileinfo
.lineno
;
452 if (len
+ 1 + commands_idx
> commands_len
)
454 commands_len
= (len
+ 1 + commands_idx
) * 2;
455 commands
= (char *) xrealloc (commands
, commands_len
);
457 bcopy (p
, &commands
[commands_idx
], len
);
459 commands
[commands_idx
++] = '\n';
465 /* This line is not a shell command line. Don't worry about tabs. */
467 if (collapsed_length
< lb
.size
)
469 collapsed_length
= lb
.size
;
472 collapsed
= (char *) xmalloc (collapsed_length
);
474 strcpy (collapsed
, lb
.buffer
);
475 /* Collapse continuation lines. */
476 collapse_continuations (collapsed
);
477 remove_comments (collapsed
);
479 /* Compare a word, both length and contents. */
480 #define word1eq(s, l) (len == l && strneq (s, p, l))
482 while (isspace ((unsigned char)*p
))
485 /* This line is completely empty. */
488 /* Find the end of the first token. Note we don't need to worry about
489 * ":" here since we compare tokens by length (so "export" will never
490 * be equal to "export:").
492 for (p2
= p
+1; *p2
!= '\0' && !isspace ((unsigned char)*p2
); ++p2
)
496 /* Find the start of the second token. If it's a `:' remember it,
497 since it can't be a preprocessor token--this allows targets named
498 `ifdef', `export', etc. */
500 while (isspace ((unsigned char)*p2
))
504 else if (p2
[0] == ':' && p2
[1] == '\0')
507 goto skip_conditionals
;
510 /* We must first check for conditional and `define' directives before
511 ignoring anything, since they control what we will do with
514 if (!in_ignored_define
515 && (word1eq ("ifdef", 5) || word1eq ("ifndef", 6)
516 || word1eq ("ifeq", 4) || word1eq ("ifneq", 5)
517 || word1eq ("else", 4) || word1eq ("endif", 5)))
519 int i
= conditional_line (p
, &fileinfo
);
523 fatal (&fileinfo
, _("invalid syntax in conditional"));
527 if (word1eq ("endef", 5))
529 if (in_ignored_define
)
530 in_ignored_define
= 0;
532 fatal (&fileinfo
, _("extraneous `endef'"));
536 if (word1eq ("define", 6))
539 in_ignored_define
= 1;
542 p2
= next_token (p
+ 6);
544 fatal (&fileinfo
, _("empty variable name"));
546 /* Let the variable name be the whole rest of the line,
547 with trailing blanks stripped (comments have already been
548 removed), so it could be a complex variable/function
549 reference that might contain blanks. */
550 p
= strchr (p2
, '\0');
551 while (isblank ((unsigned char)p
[-1]))
553 do_define (p2
, p
- p2
, o_file
, infile
, &fileinfo
);
558 if (word1eq ("override", 8))
560 p2
= next_token (p
+ 8);
562 error (&fileinfo
, _("empty `override' directive"));
563 if (strneq (p2
, "define", 6)
564 && (isblank ((unsigned char)p2
[6]) || p2
[6] == '\0'))
567 in_ignored_define
= 1;
570 p2
= next_token (p2
+ 6);
572 fatal (&fileinfo
, _("empty variable name"));
574 /* Let the variable name be the whole rest of the line,
575 with trailing blanks stripped (comments have already been
576 removed), so it could be a complex variable/function
577 reference that might contain blanks. */
578 p
= strchr (p2
, '\0');
579 while (isblank ((unsigned char)p
[-1]))
581 do_define (p2
, p
- p2
, o_override
, infile
, &fileinfo
);
585 && !try_variable_definition (&fileinfo
, p2
, o_override
, 0))
586 error (&fileinfo
, _("invalid `override' directive"));
593 /* Ignore the line. We continue here so conditionals
594 can appear in the middle of a rule. */
597 if (!reading_target
&& word1eq ("export", 6))
600 p2
= next_token (p
+ 6);
602 export_all_variables
= 1;
603 v
= try_variable_definition (&fileinfo
, p2
, o_file
, 0);
605 v
->export
= v_export
;
609 for (p
= find_next_token (&p2
, &len
); p
!= 0;
610 p
= find_next_token (&p2
, &len
))
612 v
= lookup_variable (p
, len
);
614 v
= define_variable_loc (p
, len
, "", o_file
, 0, &fileinfo
);
615 v
->export
= v_export
;
619 else if (!reading_target
&& word1eq ("unexport", 8))
623 p2
= next_token (p
+ 8);
625 export_all_variables
= 0;
626 for (p
= find_next_token (&p2
, &len
); p
!= 0;
627 p
= find_next_token (&p2
, &len
))
629 v
= lookup_variable (p
, len
);
631 v
= define_variable_loc (p
, len
, "", o_file
, 0, &fileinfo
);
632 v
->export
= v_noexport
;
635 else if (word1eq ("vpath", 5))
639 p2
= variable_expand (p
+ 5);
640 p
= find_next_token (&p2
, &len
);
643 pattern
= savestring (p
, len
);
644 p
= find_next_token (&p2
, &len
);
645 /* No searchpath means remove all previous
646 selective VPATH's with the same pattern. */
649 /* No pattern means remove all previous selective VPATH's. */
651 construct_vpath_list (pattern
, p
);
655 else if (word1eq ("include", 7) || word1eq ("-include", 8)
656 || word1eq ("sinclude", 8))
658 /* We have found an `include' line specifying a nested
659 makefile to be read at this point. */
660 struct conditionals
*save
, new_conditionals
;
661 struct nameseq
*files
;
662 /* "-include" (vs "include") says no error if the file does not
663 exist. "sinclude" is an alias for this from SGI. */
664 int noerror
= p
[0] != 'i';
666 p
= allocated_variable_expand (next_token (p
+ (noerror
? 8 : 7)));
670 _("no file name for `%sinclude'"), noerror
? "-" : "");
674 /* Parse the list of file names. */
676 files
= multi_glob (parse_file_seq (&p2
, '\0',
677 sizeof (struct nameseq
),
679 sizeof (struct nameseq
));
682 /* Save the state of conditionals and start
683 the included makefile with a clean slate. */
685 bzero ((char *) &new_conditionals
, sizeof new_conditionals
);
686 conditionals
= &new_conditionals
;
688 /* Record the rules that are waiting so they will determine
689 the default goal before those in the included makefile. */
690 record_waiting_files ();
692 /* Read each included makefile. */
695 struct nameseq
*next
= files
->next
;
696 char *name
= files
->name
;
699 free ((char *)files
);
702 r
= read_makefile (name
, (RM_INCLUDED
| RM_NO_TILDE
703 | (noerror
? RM_DONTCARE
: 0)));
707 error (&fileinfo
, "%s: %s", name
, strerror (errno
));
712 /* Free any space allocated by conditional_line. */
713 if (conditionals
->ignoring
)
714 free (conditionals
->ignoring
);
715 if (conditionals
->seen_else
)
716 free (conditionals
->seen_else
);
720 reading_file
= &fileinfo
;
723 else if (try_variable_definition (&fileinfo
, p
, o_file
, 0))
724 /* This line has been dealt with. */
726 else if (lb
.buffer
[0] == '\t')
728 p
= collapsed
; /* Ignore comments. */
729 while (isblank ((unsigned char)*p
))
732 /* The line is completely blank; that is harmless. */
734 /* This line starts with a tab but was not caught above
735 because there was no preceding target, and the line
736 might have been usable as a variable definition.
737 But now it is definitely lossage. */
738 fatal(&fileinfo
, _("commands commence before first target"));
742 /* This line describes some target files. This is complicated by
743 the existence of target-specific variables, because we can't
744 expand the entire line until we know if we have one or not. So
745 we expand the line word by word until we find the first `:',
746 then check to see if it's a target-specific variable.
748 In this algorithm, `lb_next' will point to the beginning of the
749 unexpanded parts of the input buffer, while `p2' points to the
750 parts of the expanded buffer we haven't searched yet. */
752 enum make_word_type wtype
;
753 enum variable_origin v_origin
;
754 char *cmdleft
, *semip
, *lb_next
;
755 unsigned int len
, plen
= 0;
758 /* Record the previous rule. */
760 record_waiting_files ();
761 tgts_started
= fileinfo
.lineno
;
763 /* Search the line for an unquoted ; that is not after an
765 cmdleft
= find_char_unquote (lb
.buffer
, ";#", 0);
766 if (cmdleft
!= 0 && *cmdleft
== '#')
768 /* We found a comment before a semicolon. */
772 else if (cmdleft
!= 0)
773 /* Found one. Cut the line short there before expanding it. */
777 collapse_continuations (lb
.buffer
);
779 /* We can't expand the entire line, since if it's a per-target
780 variable we don't want to expand it. So, walk from the
781 beginning, expanding as we go, and looking for "interesting"
782 chars. The first word is always expandable. */
783 wtype
= get_next_mword(lb
.buffer
, NULL
, &lb_next
, &len
);
788 fatal(&fileinfo
, _("missing rule before commands"));
789 /* This line contained something but turned out to be nothing
790 but whitespace (a comment?). */
795 /* We accept and ignore rules without targets for
796 compatibility with SunOS 4 make. */
804 p2
= variable_expand_string(NULL
, lb_next
, len
);
810 /* Look for a semicolon in the expanded line. */
811 cmdleft
= find_char_unquote (p2
, ";", 0);
815 unsigned long p2_off
= p2
- variable_buffer
;
816 unsigned long cmd_off
= cmdleft
- variable_buffer
;
817 char *pend
= p2
+ strlen(p2
);
819 /* Append any remnants of lb, then cut the line short
823 /* One school of thought says that you shouldn't expand
824 here, but merely copy, since now you're beyond a ";"
825 and into a command script. However, the old parser
826 expanded the whole line, so we continue that for
827 backwards-compatiblity. Also, it wouldn't be
828 entirely consistent, since we do an unconditional
829 expand below once we know we don't have a
830 target-specific variable. */
831 (void)variable_expand_string(pend
, lb_next
, (long)-1);
832 lb_next
+= strlen(lb_next
);
833 p2
= variable_buffer
+ p2_off
;
834 cmdleft
= variable_buffer
+ cmd_off
+ 1;
838 colonp
= find_char_unquote(p2
, ":", 0);
839 #if defined(__MSDOS__) || defined(WINDOWS32)
840 /* The drive spec brain-damage strikes again... */
841 /* Note that the only separators of targets in this context
842 are whitespace and a left paren. If others are possible,
843 they should be added to the string in the call to index. */
844 while (colonp
&& (colonp
[1] == '/' || colonp
[1] == '\\') &&
845 colonp
> p2
&& isalpha ((unsigned char)colonp
[-1]) &&
846 (colonp
== p2
+ 1 || strchr (" \t(", colonp
[-2]) != 0))
847 colonp
= find_char_unquote(colonp
+ 1, ":", 0);
852 wtype
= get_next_mword(lb_next
, NULL
, &lb_next
, &len
);
858 p2
= variable_expand_string(p2
, lb_next
, len
);
859 /* We don't need to worry about cmdleft here, because if it was
860 found in the variable_buffer the entire buffer has already
861 been expanded... we'll never get here. */
864 p2
= next_token (variable_buffer
);
866 /* If the word we're looking at is EOL, see if there's _anything_
867 on the line. If not, a variable expanded to nothing, so ignore
868 it. If so, we can't parse this line so punt. */
872 /* There's no need to be ivory-tower about this: check for
873 one of the most common bugs found in makefiles... */
874 fatal (&fileinfo
, _("missing separator%s"),
875 !strneq(lb
.buffer
, " ", 8) ? ""
876 : _(" (did you mean TAB instead of 8 spaces?)"));
880 /* Make the colon the end-of-string so we know where to stop
881 looking for targets. */
883 filenames
= multi_glob (parse_file_seq (&p2
, '\0',
884 sizeof (struct nameseq
),
886 sizeof (struct nameseq
));
891 /* We accept and ignore rules without targets for
892 compatibility with SunOS 4 make. */
896 /* This should never be possible; we handled it above. */
897 assert (*p2
!= '\0');
900 /* Is this a one-colon or two-colon entry? */
901 two_colon
= *p2
== ':';
905 /* Test to see if it's a target-specific variable. Copy the rest
906 of the buffer over, possibly temporarily (we'll expand it later
907 if it's not a target-specific variable). PLEN saves the length
908 of the unparsed section of p2, for later. */
909 if (*lb_next
!= '\0')
911 unsigned int l
= p2
- variable_buffer
;
913 (void) variable_buffer_output (p2
+plen
,
914 lb_next
, strlen (lb_next
)+1);
915 p2
= variable_buffer
+ l
;
918 /* See if it's an "override" keyword; if so see if what comes after
919 it looks like a variable definition. */
921 wtype
= get_next_mword (p2
, NULL
, &p
, &len
);
924 if (wtype
== w_static
&& (len
== (sizeof ("override")-1)
925 && strneq (p
, "override", len
)))
927 v_origin
= o_override
;
928 wtype
= get_next_mword (p
+len
, NULL
, &p
, &len
);
932 wtype
= get_next_mword (p
+len
, NULL
, NULL
, NULL
);
934 if (wtype
== w_varassign
)
936 /* If there was a semicolon found, add it back, plus anything
941 variable_buffer_output (p2
+ strlen (p2
),
942 semip
, strlen (semip
)+1);
944 record_target_var (filenames
, p
, two_colon
, v_origin
, &fileinfo
);
949 /* This is a normal target, _not_ a target-specific variable.
950 Unquote any = in the dependency list. */
951 find_char_unquote (lb_next
, "=", 0);
953 /* We have some targets, so don't ignore the following commands. */
956 /* Expand the dependencies, etc. */
957 if (*lb_next
!= '\0')
959 unsigned int l
= p2
- variable_buffer
;
960 (void) variable_expand_string (p2
+ plen
, lb_next
, (long)-1);
961 p2
= variable_buffer
+ l
;
963 /* Look for a semicolon in the expanded line. */
966 cmdleft
= find_char_unquote (p2
, ";", 0);
972 /* Is this a static pattern rule: `target: %targ: %dep; ...'? */
973 p
= strchr (p2
, ':');
974 while (p
!= 0 && p
[-1] == '\\')
976 register char *q
= &p
[-1];
977 register int backslash
= 0;
979 backslash
= !backslash
;
981 p
= strchr (p
+ 1, ':');
986 /* Here, the situation is quite complicated. Let's have a look
987 at a couple of targets:
995 The rule is that it's only a target, if there are TWO :'s
996 OR a space around the :.
998 if (p
&& !(isspace ((unsigned char)p
[1]) || !p
[1]
999 || isspace ((unsigned char)p
[-1])))
1002 #if defined (WINDOWS32) || defined (__MSDOS__)
1005 /* For MSDOS and WINDOWS32, skip a "C:\..." or a "C:/..." */
1006 if (p
!= 0 && (p
[1] == '\\' || p
[1] == '/') &&
1007 isalpha ((unsigned char)p
[-1]) &&
1008 (p
== p2
+ 1 || strchr (" \t:(", p
[-2]) != 0)) {
1009 p
= strchr (p
+ 1, ':');
1012 } while (check_again
);
1016 struct nameseq
*target
;
1017 target
= parse_file_seq (&p2
, ':', sizeof (struct nameseq
), 1);
1020 fatal (&fileinfo
, _("missing target pattern"));
1021 else if (target
->next
!= 0)
1022 fatal (&fileinfo
, _("multiple target patterns"));
1023 pattern
= target
->name
;
1024 pattern_percent
= find_percent (pattern
);
1025 if (pattern_percent
== 0)
1026 fatal (&fileinfo
, _("target pattern contains no `%%'"));
1027 free((char *)target
);
1032 /* Parse the dependencies. */
1033 deps
= (struct dep
*)
1034 multi_glob (parse_file_seq (&p2
, '\0', sizeof (struct dep
), 1),
1035 sizeof (struct dep
));
1040 /* Semicolon means rest of line is a command. */
1041 unsigned int len
= strlen (cmdleft
);
1043 cmds_started
= fileinfo
.lineno
;
1045 /* Add this command line to the buffer. */
1046 if (len
+ 2 > commands_len
)
1048 commands_len
= (len
+ 2) * 2;
1049 commands
= (char *) xrealloc (commands
, commands_len
);
1051 bcopy (cmdleft
, commands
, len
);
1052 commands_idx
+= len
;
1053 commands
[commands_idx
++] = '\n';
1059 /* We get here except in the case that we just read a rule line.
1060 Record now the last rule we read, so following spurious
1061 commands are properly diagnosed. */
1062 record_waiting_files ();
1066 if (conditionals
->if_cmds
)
1067 fatal (&fileinfo
, _("missing `endif'"));
1069 /* At eof, record the last rule. */
1070 record_waiting_files ();
1073 free ((char *) commands
);
1081 /* Execute a `define' directive.
1082 The first line has already been read, and NAME is the name of
1083 the variable to be defined. The following lines remain to be read.
1084 LINENO, INFILE and FILENAME refer to the makefile being read.
1085 The value returned is LINENO, updated for lines read here. */
1088 do_define (name
, namelen
, origin
, infile
, flocp
)
1090 unsigned int namelen
;
1091 enum variable_origin origin
;
1095 struct linebuffer lb
;
1096 unsigned int nlines
= 0;
1097 unsigned int length
= 100;
1098 char *definition
= (char *) xmalloc (100);
1099 register unsigned int idx
= 0;
1102 /* Expand the variable name. */
1103 char *var
= (char *) alloca (namelen
+ 1);
1104 bcopy (name
, var
, namelen
);
1105 var
[namelen
] = '\0';
1106 var
= variable_expand (var
);
1109 while (!feof (infile
))
1113 flocp
->lineno
+= nlines
;
1114 nlines
= readline (&lb
, infile
, flocp
);
1116 collapse_continuations (lb
.buffer
);
1118 p
= next_token (lb
.buffer
);
1120 if ((len
== 5 || (len
> 5 && isblank ((unsigned char)p
[5])))
1121 && strneq (p
, "endef", 5))
1124 remove_comments (p
);
1125 if (*next_token (p
) != '\0')
1126 error (flocp
, _("Extraneous text after `endef' directive"));
1127 /* Define the variable. */
1129 definition
[0] = '\0';
1131 definition
[idx
- 1] = '\0';
1132 (void) define_variable_loc (var
, strlen (var
), definition
, origin
,
1140 len
= strlen (lb
.buffer
);
1141 /* Increase the buffer size if necessary. */
1142 if (idx
+ len
+ 1 > length
)
1144 length
= (idx
+ len
) * 2;
1145 definition
= (char *) xrealloc (definition
, length
+ 1);
1148 bcopy (lb
.buffer
, &definition
[idx
], len
);
1150 /* Separate lines with a newline. */
1151 definition
[idx
++] = '\n';
1156 fatal (flocp
, _("missing `endef', unterminated `define'"));
1162 /* Interpret conditional commands "ifdef", "ifndef", "ifeq",
1163 "ifneq", "else" and "endif".
1164 LINE is the input line, with the command as its first word.
1166 FILENAME and LINENO are the filename and line number in the
1167 current makefile. They are used for error messages.
1169 Value is -1 if the line is invalid,
1170 0 if following text should be interpreted,
1171 1 if following text should be ignored. */
1174 conditional_line (line
, flocp
)
1176 const struct floc
*flocp
;
1180 register unsigned int i
;
1184 /* It's an "if..." command. */
1185 notdef
= line
[2] == 'n';
1188 cmdname
= line
[3] == 'd' ? "ifndef" : "ifneq";
1189 line
+= cmdname
[3] == 'd' ? 7 : 6;
1193 cmdname
= line
[2] == 'd' ? "ifdef" : "ifeq";
1194 line
+= cmdname
[2] == 'd' ? 6 : 5;
1199 /* It's an "else" or "endif" command. */
1200 notdef
= line
[1] == 'n';
1201 cmdname
= notdef
? "endif" : "else";
1202 line
+= notdef
? 5 : 4;
1205 line
= next_token (line
);
1207 if (*cmdname
== 'e')
1210 error (flocp
, _("Extraneous text after `%s' directive"), cmdname
);
1211 /* "Else" or "endif". */
1212 if (conditionals
->if_cmds
== 0)
1213 fatal (flocp
, _("extraneous `%s'"), cmdname
);
1214 /* NOTDEF indicates an `endif' command. */
1216 --conditionals
->if_cmds
;
1217 else if (conditionals
->seen_else
[conditionals
->if_cmds
- 1])
1218 fatal (flocp
, _("only one `else' per conditional"));
1221 /* Toggle the state of ignorance. */
1222 conditionals
->ignoring
[conditionals
->if_cmds
- 1]
1223 = !conditionals
->ignoring
[conditionals
->if_cmds
- 1];
1224 /* Record that we have seen an `else' in this conditional.
1225 A second `else' will be erroneous. */
1226 conditionals
->seen_else
[conditionals
->if_cmds
- 1] = 1;
1228 for (i
= 0; i
< conditionals
->if_cmds
; ++i
)
1229 if (conditionals
->ignoring
[i
])
1234 if (conditionals
->allocated
== 0)
1236 conditionals
->allocated
= 5;
1237 conditionals
->ignoring
= (char *) xmalloc (conditionals
->allocated
);
1238 conditionals
->seen_else
= (char *) xmalloc (conditionals
->allocated
);
1241 ++conditionals
->if_cmds
;
1242 if (conditionals
->if_cmds
> conditionals
->allocated
)
1244 conditionals
->allocated
+= 5;
1245 conditionals
->ignoring
= (char *)
1246 xrealloc (conditionals
->ignoring
, conditionals
->allocated
);
1247 conditionals
->seen_else
= (char *)
1248 xrealloc (conditionals
->seen_else
, conditionals
->allocated
);
1251 /* Record that we have seen an `if...' but no `else' so far. */
1252 conditionals
->seen_else
[conditionals
->if_cmds
- 1] = 0;
1254 /* Search through the stack to see if we're already ignoring. */
1255 for (i
= 0; i
< conditionals
->if_cmds
- 1; ++i
)
1256 if (conditionals
->ignoring
[i
])
1258 /* We are already ignoring, so just push a level
1259 to match the next "else" or "endif", and keep ignoring.
1260 We don't want to expand variables in the condition. */
1261 conditionals
->ignoring
[conditionals
->if_cmds
- 1] = 1;
1265 if (cmdname
[notdef
? 3 : 2] == 'd')
1267 /* "Ifdef" or "ifndef". */
1269 register char *p
= end_of_token (line
);
1274 v
= lookup_variable (line
, i
);
1275 conditionals
->ignoring
[conditionals
->if_cmds
- 1]
1276 = (v
!= 0 && *v
->value
!= '\0') == notdef
;
1280 /* "Ifeq" or "ifneq". */
1283 char termin
= *line
== '(' ? ',' : *line
;
1285 if (termin
!= ',' && termin
!= '"' && termin
!= '\'')
1289 /* Find the end of the first string. */
1292 register int count
= 0;
1293 for (; *line
!= '\0'; ++line
)
1296 else if (*line
== ')')
1298 else if (*line
== ',' && count
<= 0)
1302 while (*line
!= '\0' && *line
!= termin
)
1310 /* Strip blanks after the first string. */
1312 while (isblank ((unsigned char)p
[-1]))
1319 s2
= variable_expand (s1
);
1320 /* We must allocate a new copy of the expanded string because
1321 variable_expand re-uses the same buffer. */
1323 s1
= (char *) alloca (len
+ 1);
1324 bcopy (s2
, s1
, len
+ 1);
1327 /* Find the start of the second string. */
1328 line
= next_token (line
);
1330 termin
= termin
== ',' ? ')' : *line
;
1331 if (termin
!= ')' && termin
!= '"' && termin
!= '\'')
1334 /* Find the end of the second string. */
1337 register int count
= 0;
1338 s2
= next_token (line
);
1339 for (line
= s2
; *line
!= '\0'; ++line
)
1343 else if (*line
== ')')
1356 while (*line
!= '\0' && *line
!= termin
)
1364 line
= next_token (++line
);
1366 error (flocp
, _("Extraneous text after `%s' directive"), cmdname
);
1368 s2
= variable_expand (s2
);
1369 conditionals
->ignoring
[conditionals
->if_cmds
- 1]
1370 = streq (s1
, s2
) == notdef
;
1373 /* Search through the stack to see if we're ignoring. */
1374 for (i
= 0; i
< conditionals
->if_cmds
; ++i
)
1375 if (conditionals
->ignoring
[i
])
1380 /* Remove duplicate dependencies in CHAIN. */
1383 uniquize_deps (chain
)
1386 register struct dep
*d
;
1388 /* Make sure that no dependencies are repeated. This does not
1389 really matter for the purpose of updating targets, but it
1390 might make some names be listed twice for $^ and $?. */
1392 for (d
= chain
; d
!= 0; d
= d
->next
)
1394 struct dep
*last
, *next
;
1399 if (streq (dep_name (d
), dep_name (next
)))
1401 struct dep
*n
= next
->next
;
1403 if (next
->name
!= 0 && next
->name
!= d
->name
)
1406 free ((char *) next
);
1417 /* Record target-specific variable values for files FILENAMES.
1418 TWO_COLON is nonzero if a double colon was used.
1420 The links of FILENAMES are freed, and so are any names in it
1421 that are not incorporated into other data structures.
1423 If the target is a pattern, add the variable to the pattern-specific
1424 variable value list. */
1427 record_target_var (filenames
, defn
, two_colon
, origin
, flocp
)
1428 struct nameseq
*filenames
;
1431 enum variable_origin origin
;
1432 const struct floc
*flocp
;
1434 struct nameseq
*nextf
;
1435 struct variable_set_list
*global
;
1437 global
= current_variable_set_list
;
1439 /* If the variable is an append version, store that but treat it as a
1440 normal recursive variable. */
1442 for (; filenames
!= 0; filenames
= nextf
)
1445 register char *name
= filenames
->name
;
1446 struct variable_set_list
*vlist
;
1450 nextf
= filenames
->next
;
1451 free ((char *) filenames
);
1453 /* If it's a pattern target, then add it to the pattern-specific
1455 percent
= find_percent (name
);
1458 struct pattern_var
*p
;
1460 /* Get a reference for this pattern-specific variable struct. */
1461 p
= create_pattern_var(name
, percent
);
1469 /* Get a file reference for this file, and initialize it. */
1470 f
= enter_file (name
);
1471 initialize_file_variables (f
, 1);
1472 vlist
= f
->variables
;
1476 /* Make the new variable context current and define the variable. */
1477 current_variable_set_list
= vlist
;
1478 v
= try_variable_definition (flocp
, defn
, origin
, 1);
1480 error (flocp
, _("Malformed per-target variable definition"));
1483 /* If it's not an override, check to see if there was a command-line
1484 setting. If so, reset the value. */
1485 if (origin
!= o_override
)
1487 struct variable
*gv
;
1488 int len
= strlen(v
->name
);
1490 current_variable_set_list
= global
;
1491 gv
= lookup_variable (v
->name
, len
);
1492 if (gv
&& (gv
->origin
== o_env_override
|| gv
->origin
== o_command
))
1493 define_variable_in_set (v
->name
, len
, gv
->value
, gv
->origin
,
1494 gv
->recursive
, vlist
->set
, flocp
);
1497 /* Free name if not needed further. */
1498 if (name
!= fname
&& (name
< fname
|| name
> fname
+ strlen (fname
)))
1502 current_variable_set_list
= global
;
1505 /* Record a description line for files FILENAMES,
1506 with dependencies DEPS, commands to execute described
1507 by COMMANDS and COMMANDS_IDX, coming from FILENAME:COMMANDS_STARTED.
1508 TWO_COLON is nonzero if a double colon was used.
1509 If not nil, PATTERN is the `%' pattern to make this
1510 a static pattern rule, and PATTERN_PERCENT is a pointer
1511 to the `%' within it.
1513 The links of FILENAMES are freed, and so are any names in it
1514 that are not incorporated into other data structures. */
1517 record_files (filenames
, pattern
, pattern_percent
, deps
, cmds_started
,
1518 commands
, commands_idx
, two_colon
, flocp
, set_default
)
1519 struct nameseq
*filenames
;
1520 char *pattern
, *pattern_percent
;
1522 unsigned int cmds_started
;
1524 unsigned int commands_idx
;
1526 const struct floc
*flocp
;
1529 struct nameseq
*nextf
;
1531 unsigned int max_targets
= 0, target_idx
= 0;
1532 char **targets
= 0, **target_percents
= 0;
1533 struct commands
*cmds
;
1535 if (commands_idx
> 0)
1537 cmds
= (struct commands
*) xmalloc (sizeof (struct commands
));
1538 cmds
->fileinfo
.filenm
= flocp
->filenm
;
1539 cmds
->fileinfo
.lineno
= cmds_started
;
1540 cmds
->commands
= savestring (commands
, commands_idx
);
1541 cmds
->command_lines
= 0;
1546 for (; filenames
!= 0; filenames
= nextf
)
1549 register char *name
= filenames
->name
;
1550 register struct file
*f
;
1551 register struct dep
*d
;
1553 char *implicit_percent
;
1555 nextf
= filenames
->next
;
1558 implicit_percent
= find_percent (name
);
1559 implicit
|= implicit_percent
!= 0;
1561 if (implicit
&& pattern
!= 0)
1562 fatal (flocp
, _("mixed implicit and static pattern rules"));
1564 if (implicit
&& implicit_percent
== 0)
1565 fatal (flocp
, _("mixed implicit and normal rules"));
1572 targets
= (char **) xmalloc (5 * sizeof (char *));
1573 target_percents
= (char **) xmalloc (5 * sizeof (char *));
1576 else if (target_idx
== max_targets
- 1)
1579 targets
= (char **) xrealloc ((char *) targets
,
1580 max_targets
* sizeof (char *));
1582 = (char **) xrealloc ((char *) target_percents
,
1583 max_targets
* sizeof (char *));
1585 targets
[target_idx
] = name
;
1586 target_percents
[target_idx
] = implicit_percent
;
1591 /* If there are multiple filenames, copy the chain DEPS
1592 for all but the last one. It is not safe for the same deps
1593 to go in more than one place in the data base. */
1594 this = nextf
!= 0 ? copy_dep_chain (deps
) : deps
;
1598 /* If this is an extended static rule:
1599 `targets: target%pattern: dep%pattern; cmds',
1600 translate each dependency pattern into a plain filename
1601 using the target pattern and this target's name. */
1602 if (!pattern_matches (pattern
, pattern_percent
, name
))
1604 /* Give a warning if the rule is meaningless. */
1606 _("target `%s' doesn't match the target pattern"), name
);
1611 /* We use patsubst_expand to do the work of translating
1612 the target pattern, the target's name and the dependencies'
1613 patterns into plain dependency names. */
1614 char *buffer
= variable_expand ("");
1616 for (d
= this; d
!= 0; d
= d
->next
)
1619 char *percent
= find_percent (d
->name
);
1622 o
= patsubst_expand (buffer
, name
, pattern
, d
->name
,
1623 pattern_percent
, percent
);
1624 /* If the name expanded to the empty string, that's
1628 _("target `%s' leaves prerequisite pattern empty"),
1631 d
->name
= savestring (buffer
, o
- buffer
);
1638 /* Single-colon. Combine these dependencies
1639 with others in file's existing record, if any. */
1640 f
= enter_file (name
);
1642 if (f
->double_colon
)
1644 _("target file `%s' has both : and :: entries"), f
->name
);
1646 /* If CMDS == F->CMDS, this target was listed in this rule
1647 more than once. Just give a warning since this is harmless. */
1648 if (cmds
!= 0 && cmds
== f
->cmds
)
1650 _("target `%s' given more than once in the same rule."),
1653 /* Check for two single-colon entries both with commands.
1654 Check is_target so that we don't lose on files such as .c.o
1655 whose commands were preinitialized. */
1656 else if (cmds
!= 0 && f
->cmds
!= 0 && f
->is_target
)
1658 error (&cmds
->fileinfo
,
1659 _("warning: overriding commands for target `%s'"),
1661 error (&f
->cmds
->fileinfo
,
1662 _("warning: ignoring old commands for target `%s'"),
1668 /* Defining .DEFAULT with no deps or cmds clears it. */
1669 if (f
== default_file
&& this == 0 && cmds
== 0)
1673 /* Defining .SUFFIXES with no dependencies
1674 clears out the list of suffixes. */
1675 if (f
== suffix_file
&& this == 0)
1680 struct dep
*nextd
= d
->next
;
1687 else if (f
->deps
!= 0)
1689 /* Add the file's old deps and the new ones in THIS together. */
1691 struct dep
*firstdeps
, *moredeps
;
1694 /* This is the rule with commands, so put its deps first.
1695 The rationale behind this is that $< expands to the
1696 first dep in the chain, and commands use $< expecting
1697 to get the dep that rule specifies. */
1703 /* Append the new deps to the old ones. */
1704 firstdeps
= f
->deps
;
1709 firstdeps
= moredeps
;
1713 while (d
->next
!= 0)
1718 f
->deps
= firstdeps
;
1723 /* If this is a static pattern rule, set the file's stem to
1724 the part of its name that matched the `%' in the pattern,
1725 so you can use $* in the commands. */
1728 static char *percent
= "%";
1729 char *buffer
= variable_expand ("");
1730 char *o
= patsubst_expand (buffer
, name
, pattern
, percent
,
1731 pattern_percent
, percent
);
1732 f
->stem
= savestring (buffer
, o
- buffer
);
1737 /* Double-colon. Make a new record
1738 even if the file already has one. */
1739 f
= lookup_file (name
);
1740 /* Check for both : and :: rules. Check is_target so
1741 we don't lose on default suffix rules or makefiles. */
1742 if (f
!= 0 && f
->is_target
&& !f
->double_colon
)
1744 _("target file `%s' has both : and :: entries"), f
->name
);
1745 f
= enter_file (name
);
1746 /* If there was an existing entry and it was a double-colon
1747 entry, enter_file will have returned a new one, making it the
1748 prev pointer of the old one, and setting its double_colon
1749 pointer to the first one. */
1750 if (f
->double_colon
== 0)
1751 /* This is the first entry for this name, so we must
1752 set its double_colon pointer to itself. */
1753 f
->double_colon
= f
;
1759 /* Free name if not needed further. */
1760 if (f
!= 0 && name
!= f
->name
1761 && (name
< f
->name
|| name
> f
->name
+ strlen (f
->name
)))
1767 /* See if this is first target seen whose name does
1768 not start with a `.', unless it contains a slash. */
1769 if (default_goal_file
== 0 && set_default
1770 && (*name
!= '.' || strchr (name
, '/') != 0
1771 #if defined(__MSDOS__) || defined(WINDOWS32)
1772 || strchr (name
, '\\') != 0
1778 /* If this file is a suffix, don't
1779 let it be the default goal file. */
1781 for (d
= suffix_file
->deps
; d
!= 0; d
= d
->next
)
1783 register struct dep
*d2
;
1784 if (*dep_name (d
) != '.' && streq (name
, dep_name (d
)))
1789 for (d2
= suffix_file
->deps
; d2
!= 0; d2
= d2
->next
)
1791 register unsigned int len
= strlen (dep_name (d2
));
1792 if (!strneq (name
, dep_name (d2
), len
))
1794 if (streq (name
+ len
, dep_name (d
)))
1805 default_goal_file
= f
;
1811 targets
[target_idx
] = 0;
1812 target_percents
[target_idx
] = 0;
1813 create_pattern_rule (targets
, target_percents
, two_colon
, deps
, cmds
, 1);
1814 free ((char *) target_percents
);
1818 /* Search STRING for an unquoted STOPCHAR or blank (if BLANK is nonzero).
1819 Backslashes quote STOPCHAR, blanks if BLANK is nonzero, and backslash.
1820 Quoting backslashes are removed from STRING by compacting it into
1821 itself. Returns a pointer to the first unquoted STOPCHAR if there is
1822 one, or nil if there are none. */
1825 find_char_unquote (string
, stopchars
, blank
)
1830 unsigned int string_len
= 0;
1831 register char *p
= string
;
1835 while (*p
!= '\0' && strchr (stopchars
, *p
) == 0
1836 && (!blank
|| !isblank ((unsigned char)*p
)))
1841 if (p
> string
&& p
[-1] == '\\')
1843 /* Search for more backslashes. */
1844 register int i
= -2;
1845 while (&p
[i
] >= string
&& p
[i
] == '\\')
1848 /* Only compute the length if really needed. */
1849 if (string_len
== 0)
1850 string_len
= strlen (string
);
1851 /* The number of backslashes is now -I.
1852 Copy P over itself to swallow half of them. */
1853 bcopy (&p
[i
/ 2], &p
[i
], (string_len
- (p
- string
)) - (i
/ 2) + 1);
1856 /* All the backslashes quoted each other; the STOPCHAR was
1860 /* The STOPCHAR was quoted by a backslash. Look for another. */
1863 /* No backslash in sight. */
1867 /* Never hit a STOPCHAR or blank (with BLANK nonzero). */
1871 /* Search PATTERN for an unquoted %. */
1874 find_percent (pattern
)
1877 return find_char_unquote (pattern
, "%", 0);
1880 /* Parse a string into a sequence of filenames represented as a
1881 chain of struct nameseq's in reverse order and return that chain.
1883 The string is passed as STRINGP, the address of a string pointer.
1884 The string pointer is updated to point at the first character
1885 not parsed, which either is a null char or equals STOPCHAR.
1887 SIZE is how big to construct chain elements.
1888 This is useful if we want them actually to be other structures
1889 that have room for additional info.
1891 If STRIP is nonzero, strip `./'s off the beginning. */
1894 parse_file_seq (stringp
, stopchar
, size
, strip
)
1900 register struct nameseq
*new = 0;
1901 register struct nameseq
*new1
, *lastnew1
;
1902 register char *p
= *stringp
;
1909 stopchars
[1] = stopchar
;
1910 stopchars
[2] = '\0';
1912 stopchars
[0] = stopchar
;
1913 stopchars
[1] = '\0';
1918 /* Skip whitespace; see if any more names are left. */
1925 /* Yes, find end of next name. */
1927 p
= find_char_unquote (q
, stopchars
, 1);
1929 /* convert comma separated list to space separated */
1934 if (stopchar
== ':' && p
&& *p
== ':'
1935 && !(isspace ((unsigned char)p
[1]) || !p
[1]
1936 || isspace ((unsigned char)p
[-1])))
1938 p
= find_char_unquote (p
+1, stopchars
, 1);
1941 #if defined(WINDOWS32) || defined(__MSDOS__)
1942 /* For WINDOWS32, skip a "C:\..." or a "C:/..." until we find the
1943 first colon which isn't followed by a slash or a backslash.
1944 Note that tokens separated by spaces should be treated as separate
1945 tokens since make doesn't allow path names with spaces */
1946 if (stopchar
== ':')
1947 while (p
!= 0 && !isspace ((unsigned char)*p
) &&
1948 (p
[1] == '\\' || p
[1] == '/') && isalpha ((unsigned char)p
[-1]))
1949 p
= find_char_unquote (p
+ 1, stopchars
, 1);
1956 /* Skip leading `[]'s. */
1957 while (p
- q
> 2 && q
[0] == '[' && q
[1] == ']')
1959 /* Skip leading `./'s. */
1960 while (p
- q
> 2 && q
[0] == '.' && q
[1] == '/')
1963 q
+= 2; /* Skip "./". */
1964 while (q
< p
&& *q
== '/')
1965 /* Skip following slashes: ".//foo" is "foo", not "/foo". */
1969 /* Extract the filename just found, and skip it. */
1972 /* ".///" was stripped to "". */
1977 name
= savestring ("", 0);
1979 name
= savestring ("./", 2);
1984 /* VMS filenames can have a ':' in them but they have to be '\'ed but we need
1985 * to remove this '\' before we can use the filename.
1986 * Savestring called because q may be read-only string constant.
1989 char *qbase
= xstrdup (q
);
1990 char *pbase
= qbase
+ (p
-q
);
1997 if (*q1
== '\\' && *(q1
+1) == ':')
2004 name
= savestring (qbase
, p1
- qbase
);
2008 name
= savestring (q
, p
- q
);
2011 /* Add it to the front of the chain. */
2012 new1
= (struct nameseq
*) xmalloc (size
);
2020 /* Look for multi-word archive references.
2021 They are indicated by a elt ending with an unmatched `)' and
2022 an elt further down the chain (i.e., previous in the file list)
2023 with an unmatched `(' (e.g., "lib(mem"). */
2028 if (new1
->name
[0] != '(' /* Don't catch "(%)" and suchlike. */
2029 && new1
->name
[strlen (new1
->name
) - 1] == ')'
2030 && strchr (new1
->name
, '(') == 0)
2032 /* NEW1 ends with a `)' but does not contain a `('.
2033 Look back for an elt with an opening `(' but no closing `)'. */
2035 struct nameseq
*n
= new1
->next
, *lastn
= new1
;
2037 while (n
!= 0 && (paren
= strchr (n
->name
, '(')) == 0)
2043 /* Ignore something starting with `(', as that cannot actually
2044 be an archive-member reference (and treating it as such
2045 results in an empty file name, which causes much lossage). */
2046 && n
->name
[0] != '(')
2048 /* N is the first element in the archive group.
2049 Its name looks like "lib(mem" (with no closing `)'). */
2053 /* Copy "lib(" into LIBNAME. */
2055 libname
= (char *) alloca (paren
- n
->name
+ 1);
2056 bcopy (n
->name
, libname
, paren
- n
->name
);
2057 libname
[paren
- n
->name
] = '\0';
2061 /* N was just "lib(", part of something like "lib( a b)".
2062 Edit it out of the chain and free its storage. */
2063 lastn
->next
= n
->next
;
2066 /* LASTN->next is the new stopping elt for the loop below. */
2071 /* Replace N's name with the full archive reference. */
2072 name
= concat (libname
, paren
, ")");
2077 if (new1
->name
[1] == '\0')
2079 /* NEW1 is just ")", part of something like "lib(a b )".
2080 Omit it from the chain and free its storage. */
2084 lastnew1
->next
= new1
->next
;
2088 free ((char *) lastn
);
2092 /* Replace also NEW1->name, which already has closing `)'. */
2093 name
= concat (libname
, new1
->name
, "");
2099 /* Trace back from NEW1 (the end of the list) until N
2100 (the beginning of the list), rewriting each name
2101 with the full archive reference. */
2105 name
= concat (libname
, new1
->name
, ")");
2114 /* No frobnication happening. Just step down the list. */
2131 /* Read a line of text from STREAM into LINEBUFFER.
2132 Combine continuation lines into one line.
2133 Return the number of actual lines read (> 1 if hacked continuation lines).
2136 static unsigned long
2137 readline (linebuffer
, stream
, flocp
)
2138 struct linebuffer
*linebuffer
;
2140 const struct floc
*flocp
;
2142 char *buffer
= linebuffer
->buffer
;
2143 register char *p
= linebuffer
->buffer
;
2144 register char *end
= p
+ linebuffer
->size
;
2145 register int len
, lastlen
= 0;
2147 register unsigned int nlines
= 0;
2148 register int backslash
;
2152 while (fgets (p
, end
- p
, stream
) != 0)
2157 /* This only happens when the first thing on the line is a '\0'.
2158 It is a pretty hopeless case, but (wonder of wonders) Athena
2159 lossage strikes again! (xmkmf puts NULs in its makefiles.)
2160 There is nothing really to be done; we synthesize a newline so
2161 the following line doesn't appear to be part of this line. */
2162 error (flocp
, _("warning: NUL character seen; rest of line ignored"));
2170 /* Probably ran out of buffer space. */
2171 register unsigned int p_off
= p
- buffer
;
2172 linebuffer
->size
*= 2;
2173 buffer
= (char *) xrealloc (buffer
, linebuffer
->size
);
2175 end
= buffer
+ linebuffer
->size
;
2176 linebuffer
->buffer
= buffer
;
2184 #if !defined(WINDOWS32) && !defined(__MSDOS__)
2185 /* Check to see if the line was really ended with CRLF; if so ignore
2187 if (len
> 1 && p
[-2] == '\r')
2195 if (len
== 1 && p
> buffer
)
2196 /* P is pointing at a newline and it's the beginning of
2197 the buffer returned by the last fgets call. However,
2198 it is not necessarily the beginning of a line if P is
2199 pointing past the beginning of the holding buffer.
2200 If the buffer was just enlarged (right before the newline),
2201 we must account for that, so we pretend that the two lines
2206 for (p2
= p
- 2; --len
> 0; --p2
)
2209 backslash
= !backslash
;
2222 /* Enlarge the buffer. */
2223 register unsigned int p_off
= p
- buffer
;
2224 linebuffer
->size
*= 2;
2225 buffer
= (char *) xrealloc (buffer
, linebuffer
->size
);
2227 end
= buffer
+ linebuffer
->size
;
2228 linebuffer
->buffer
= buffer
;
2232 if (ferror (stream
))
2233 pfatal_with_name (flocp
->filenm
);
2238 /* Parse the next "makefile word" from the input buffer, and return info
2241 A "makefile word" is one of:
2243 w_bogus Should never happen
2245 w_static A static word; cannot be expanded
2246 w_variable A word containing one or more variables/functions
2248 w_dcolon A double-colon
2249 w_semicolon A semicolon
2250 w_comment A comment character
2251 w_varassign A variable assignment operator (=, :=, +=, or ?=)
2253 Note that this function is only used when reading certain parts of the
2254 makefile. Don't use it where special rules hold sway (RHS of a variable,
2255 in a command list, etc.) */
2257 static enum make_word_type
2258 get_next_mword (buffer
, delim
, startp
, length
)
2262 unsigned int *length
;
2264 enum make_word_type wtype
= w_bogus
;
2265 char *p
= buffer
, *beg
;
2268 /* Skip any leading whitespace. */
2269 while (isblank ((unsigned char)*p
))
2285 wtype
= w_semicolon
;
2289 wtype
= w_varassign
;
2303 wtype
= w_varassign
;
2313 wtype
= w_varassign
;
2318 if (delim
&& strchr (delim
, c
))
2323 /* Did we find something? If so, return now. */
2324 if (wtype
!= w_bogus
)
2327 /* This is some non-operator word. A word consists of the longest
2328 string of characters that doesn't contain whitespace, one of [:=#],
2329 or [?+]=, or one of the chars in the DELIM string. */
2331 /* We start out assuming a static word; if we see a variable we'll
2332 adjust our assumptions then. */
2335 /* We already found the first value of "c", above. */
2351 #if defined(__MSDOS__) || defined(WINDOWS32)
2352 /* A word CAN include a colon in its drive spec. The drive
2353 spec is allowed either at the beginning of a word, or as part
2354 of the archive member name, like in "libfoo.a(d:/foo/bar.o)". */
2356 && (*p
== '/' || *p
== '\\') && isalpha ((unsigned char)p
[-2])
2357 && (p
- beg
== 2 || p
[-3] == '(')))
2366 /* This is a variable reference, so note that it's expandable.
2367 Then read it to the matching close paren. */
2375 /* This is a single-letter variable reference. */
2378 for (count
=0; *p
!= '\0'; ++p
)
2382 else if (*p
== closeparen
&& --count
< 0)
2409 if (delim
&& strchr (delim
, c
))
2427 /* Construct the list of include directories
2428 from the arguments and the default list. */
2431 construct_include_path (arg_dirs
)
2434 register unsigned int i
;
2435 #ifdef VAXC /* just don't ask ... */
2440 /* Table to hold the dirs. */
2442 register unsigned int defsize
= (sizeof (default_include_directories
)
2443 / sizeof (default_include_directories
[0]));
2444 register unsigned int max
= 5;
2445 register char **dirs
= (char **) xmalloc ((5 + defsize
) * sizeof (char *));
2446 register unsigned int idx
= 0;
2452 /* First consider any dirs specified with -I switches.
2453 Ignore dirs that don't exist. */
2456 while (*arg_dirs
!= 0)
2458 char *dir
= *arg_dirs
++;
2462 char *expanded
= tilde_expand (dir
);
2467 if (stat (dir
, &stbuf
) == 0 && S_ISDIR (stbuf
.st_mode
))
2473 xrealloc ((char *) dirs
, (max
+ defsize
) * sizeof (char *));
2477 else if (dir
!= arg_dirs
[-1])
2481 /* Now add at the end the standard default dirs. */
2485 /* The environment variable $DJDIR holds the root of the
2486 DJGPP directory tree; add ${DJDIR}/include. */
2487 struct variable
*djdir
= lookup_variable ("DJDIR", 5);
2491 char *defdir
= (char *) xmalloc (strlen (djdir
->value
) + 8 + 1);
2493 strcat (strcpy (defdir
, djdir
->value
), "/include");
2494 dirs
[idx
++] = defdir
;
2499 for (i
= 0; default_include_directories
[i
] != 0; ++i
)
2500 if (stat (default_include_directories
[i
], &stbuf
) == 0
2501 && S_ISDIR (stbuf
.st_mode
))
2502 dirs
[idx
++] = default_include_directories
[i
];
2506 /* Now compute the maximum length of any name in it. */
2509 for (i
= 0; i
< idx
; ++i
)
2511 unsigned int len
= strlen (dirs
[i
]);
2512 /* If dir name is written with a trailing slash, discard it. */
2513 if (dirs
[i
][len
- 1] == '/')
2514 /* We can't just clobber a null in because it may have come from
2515 a literal string and literal strings may not be writable. */
2516 dirs
[i
] = savestring (dirs
[i
], len
- 1);
2517 if (len
> max_incl_len
)
2521 include_directories
= dirs
;
2524 /* Expand ~ or ~USER at the beginning of NAME.
2525 Return a newly malloc'd string or 0. */
2532 if (name
[1] == '/' || name
[1] == '\0')
2534 extern char *getenv ();
2539 /* Turn off --warn-undefined-variables while we expand HOME. */
2540 int save
= warn_undefined_variables_flag
;
2541 warn_undefined_variables_flag
= 0;
2543 home_dir
= allocated_variable_expand ("$(HOME)");
2545 warn_undefined_variables_flag
= save
;
2548 is_variable
= home_dir
[0] != '\0';
2552 home_dir
= getenv ("HOME");
2554 #if !defined(_AMIGA) && !defined(WINDOWS32)
2555 if (home_dir
== 0 || home_dir
[0] == '\0')
2557 extern char *getlogin ();
2558 char *logname
= getlogin ();
2562 struct passwd
*p
= getpwnam (logname
);
2564 home_dir
= p
->pw_dir
;
2567 #endif /* !AMIGA && !WINDOWS32 */
2570 char *new = concat (home_dir
, "", name
+ 1);
2576 #if !defined(_AMIGA) && !defined(WINDOWS32)
2579 struct passwd
*pwent
;
2580 char *userend
= strchr (name
+ 1, '/');
2583 pwent
= getpwnam (name
+ 1);
2587 return xstrdup (pwent
->pw_dir
);
2589 return concat (pwent
->pw_dir
, "/", userend
+ 1);
2591 else if (userend
!= 0)
2594 #endif /* !AMIGA && !WINDOWS32 */
2599 /* Given a chain of struct nameseq's describing a sequence of filenames,
2600 in reverse of the intended order, return a new chain describing the
2601 result of globbing the filenames. The new chain is in forward order.
2602 The links of the old chain are freed or used in the new chain.
2603 Likewise for the names in the old chain.
2605 SIZE is how big to construct chain elements.
2606 This is useful if we want them actually to be other structures
2607 that have room for additional info. */
2610 multi_glob (chain
, size
)
2611 struct nameseq
*chain
;
2614 extern void dir_setup_glob ();
2615 register struct nameseq
*new = 0;
2616 register struct nameseq
*old
;
2617 struct nameseq
*nexto
;
2620 dir_setup_glob (&gl
);
2622 for (old
= chain
; old
!= 0; old
= nexto
)
2630 if (old
->name
[0] == '~')
2632 char *newname
= tilde_expand (old
->name
);
2636 old
->name
= newname
;
2641 if (ar_name (old
->name
))
2643 /* OLD->name is an archive member reference.
2644 Replace it with the archive file name,
2645 and save the member name in MEMNAME.
2646 We will glob on the archive name and then
2647 reattach MEMNAME later. */
2649 ar_parse_name (old
->name
, &arname
, &memname
);
2655 #endif /* !NO_ARCHIVES */
2657 switch (glob (old
->name
, GLOB_NOCHECK
|GLOB_ALTDIRFUNC
, NULL
, &gl
))
2659 case 0: /* Success. */
2661 register int i
= gl
.gl_pathc
;
2667 /* Try to glob on MEMNAME within the archive. */
2668 struct nameseq
*found
2669 = ar_glob (gl
.gl_pathv
[i
], memname
, size
);
2672 /* No matches. Use MEMNAME as-is. */
2674 = (struct nameseq
*) xmalloc (size
);
2675 unsigned int alen
= strlen (gl
.gl_pathv
[i
]);
2676 unsigned int mlen
= strlen (memname
);
2677 elt
->name
= (char *) xmalloc (alen
+ 1 + mlen
+ 2);
2678 bcopy (gl
.gl_pathv
[i
], elt
->name
, alen
);
2679 elt
->name
[alen
] = '(';
2680 bcopy (memname
, &elt
->name
[alen
+ 1], mlen
);
2681 elt
->name
[alen
+ 1 + mlen
] = ')';
2682 elt
->name
[alen
+ 1 + mlen
+ 1] = '\0';
2688 /* Find the end of the FOUND chain. */
2689 struct nameseq
*f
= found
;
2690 while (f
->next
!= 0)
2693 /* Attach the chain being built to the end of the FOUND
2694 chain, and make FOUND the new NEW chain. */
2702 #endif /* !NO_ARCHIVES */
2704 struct nameseq
*elt
= (struct nameseq
*) xmalloc (size
);
2705 elt
->name
= xstrdup (gl
.gl_pathv
[i
]);
2717 fatal (NILF
, _("virtual memory exhausted"));