xref: /netbsd-src/usr.bin/make/parse.c (revision 946379e7b37692fc43f68eb0d1c10daa0a7f3b6c)
1 /*	$NetBSD: parse.c,v 1.207 2016/01/09 00:55:17 christos Exp $	*/
2 
3 /*
4  * Copyright (c) 1988, 1989, 1990, 1993
5  *	The Regents of the University of California.  All rights reserved.
6  *
7  * This code is derived from software contributed to Berkeley by
8  * Adam de Boor.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. Neither the name of the University nor the names of its contributors
19  *    may be used to endorse or promote products derived from this software
20  *    without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  */
34 
35 /*
36  * Copyright (c) 1989 by Berkeley Softworks
37  * All rights reserved.
38  *
39  * This code is derived from software contributed to Berkeley by
40  * Adam de Boor.
41  *
42  * Redistribution and use in source and binary forms, with or without
43  * modification, are permitted provided that the following conditions
44  * are met:
45  * 1. Redistributions of source code must retain the above copyright
46  *    notice, this list of conditions and the following disclaimer.
47  * 2. Redistributions in binary form must reproduce the above copyright
48  *    notice, this list of conditions and the following disclaimer in the
49  *    documentation and/or other materials provided with the distribution.
50  * 3. All advertising materials mentioning features or use of this software
51  *    must display the following acknowledgement:
52  *	This product includes software developed by the University of
53  *	California, Berkeley and its contributors.
54  * 4. Neither the name of the University nor the names of its contributors
55  *    may be used to endorse or promote products derived from this software
56  *    without specific prior written permission.
57  *
58  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
59  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
60  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
61  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
62  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
63  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
64  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
65  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
66  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
67  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
68  * SUCH DAMAGE.
69  */
70 
71 #ifndef MAKE_NATIVE
72 static char rcsid[] = "$NetBSD: parse.c,v 1.207 2016/01/09 00:55:17 christos Exp $";
73 #else
74 #include <sys/cdefs.h>
75 #ifndef lint
76 #if 0
77 static char sccsid[] = "@(#)parse.c	8.3 (Berkeley) 3/19/94";
78 #else
79 __RCSID("$NetBSD: parse.c,v 1.207 2016/01/09 00:55:17 christos Exp $");
80 #endif
81 #endif /* not lint */
82 #endif
83 
84 /*-
85  * parse.c --
86  *	Functions to parse a makefile.
87  *
88  *	One function, Parse_Init, must be called before any functions
89  *	in this module are used. After that, the function Parse_File is the
90  *	main entry point and controls most of the other functions in this
91  *	module.
92  *
93  *	Most important structures are kept in Lsts. Directories for
94  *	the .include "..." function are kept in the 'parseIncPath' Lst, while
95  *	those for the .include <...> are kept in the 'sysIncPath' Lst. The
96  *	targets currently being defined are kept in the 'targets' Lst.
97  *
98  *	The variables 'fname' and 'lineno' are used to track the name
99  *	of the current file and the line number in that file so that error
100  *	messages can be more meaningful.
101  *
102  * Interface:
103  *	Parse_Init	    	    Initialization function which must be
104  *	    	  	    	    called before anything else in this module
105  *	    	  	    	    is used.
106  *
107  *	Parse_End		    Cleanup the module
108  *
109  *	Parse_File	    	    Function used to parse a makefile. It must
110  *	    	  	    	    be given the name of the file, which should
111  *	    	  	    	    already have been opened, and a function
112  *	    	  	    	    to call to read a character from the file.
113  *
114  *	Parse_IsVar	    	    Returns TRUE if the given line is a
115  *	    	  	    	    variable assignment. Used by MainParseArgs
116  *	    	  	    	    to determine if an argument is a target
117  *	    	  	    	    or a variable assignment. Used internally
118  *	    	  	    	    for pretty much the same thing...
119  *
120  *	Parse_Error	    	    Function called when an error occurs in
121  *	    	  	    	    parsing. Used by the variable and
122  *	    	  	    	    conditional modules.
123  *	Parse_MainName	    	    Returns a Lst of the main target to create.
124  */
125 
126 #include <sys/types.h>
127 #include <sys/mman.h>
128 #include <sys/stat.h>
129 #include <assert.h>
130 #include <ctype.h>
131 #include <errno.h>
132 #include <fcntl.h>
133 #include <stdarg.h>
134 #include <stdio.h>
135 
136 #ifndef MAP_FILE
137 #define MAP_FILE 0
138 #endif
139 #ifndef MAP_COPY
140 #define MAP_COPY MAP_PRIVATE
141 #endif
142 
143 #include "make.h"
144 #include "hash.h"
145 #include "dir.h"
146 #include "job.h"
147 #include "buf.h"
148 #include "pathnames.h"
149 
150 ////////////////////////////////////////////////////////////
151 // types and constants
152 
153 /*
154  * Structure for a file being read ("included file")
155  */
156 typedef struct IFile {
157     char      	    *fname;         /* name of file */
158     int             lineno;         /* current line number in file */
159     int             first_lineno;   /* line number of start of text */
160     int             cond_depth;     /* 'if' nesting when file opened */
161     char            *P_str;         /* point to base of string buffer */
162     char            *P_ptr;         /* point to next char of string buffer */
163     char            *P_end;         /* point to the end of string buffer */
164     char            *(*nextbuf)(void *, size_t *); /* Function to get more data */
165     void            *nextbuf_arg;   /* Opaque arg for nextbuf() */
166     struct loadedfile *lf;          /* loadedfile object, if any */
167 } IFile;
168 
169 
170 /*
171  * These values are returned by ParseEOF to tell Parse_File whether to
172  * CONTINUE parsing, i.e. it had only reached the end of an include file,
173  * or if it's DONE.
174  */
175 #define CONTINUE	1
176 #define DONE		0
177 
178 /*
179  * Tokens for target attributes
180  */
181 typedef enum {
182     Begin,  	    /* .BEGIN */
183     Default,	    /* .DEFAULT */
184     End,    	    /* .END */
185     dotError,	    /* .ERROR */
186     Ignore,	    /* .IGNORE */
187     Includes,	    /* .INCLUDES */
188     Interrupt,	    /* .INTERRUPT */
189     Libs,	    /* .LIBS */
190     Meta,	    /* .META */
191     MFlags,	    /* .MFLAGS or .MAKEFLAGS */
192     Main,	    /* .MAIN and we don't have anything user-specified to
193 		     * make */
194     NoExport,	    /* .NOEXPORT */
195     NoMeta,	    /* .NOMETA */
196     NoMetaCmp,	    /* .NOMETA_CMP */
197     NoPath,	    /* .NOPATH */
198     Not,	    /* Not special */
199     NotParallel,    /* .NOTPARALLEL */
200     Null,   	    /* .NULL */
201     ExObjdir,	    /* .OBJDIR */
202     Order,  	    /* .ORDER */
203     Parallel,	    /* .PARALLEL */
204     ExPath,	    /* .PATH */
205     Phony,	    /* .PHONY */
206 #ifdef POSIX
207     Posix,	    /* .POSIX */
208 #endif
209     Precious,	    /* .PRECIOUS */
210     ExShell,	    /* .SHELL */
211     Silent,	    /* .SILENT */
212     SingleShell,    /* .SINGLESHELL */
213     Stale,	    /* .STALE */
214     Suffixes,	    /* .SUFFIXES */
215     Wait,	    /* .WAIT */
216     Attribute	    /* Generic attribute */
217 } ParseSpecial;
218 
219 /*
220  * Other tokens
221  */
222 #define LPAREN	'('
223 #define RPAREN	')'
224 
225 
226 ////////////////////////////////////////////////////////////
227 // result data
228 
229 /*
230  * The main target to create. This is the first target on the first
231  * dependency line in the first makefile.
232  */
233 static GNode *mainNode;
234 
235 ////////////////////////////////////////////////////////////
236 // eval state
237 
238 /* targets we're working on */
239 static Lst targets;
240 
241 #ifdef CLEANUP
242 /* command lines for targets */
243 static Lst targCmds;
244 #endif
245 
246 /*
247  * specType contains the SPECial TYPE of the current target. It is
248  * Not if the target is unspecial. If it *is* special, however, the children
249  * are linked as children of the parent but not vice versa. This variable is
250  * set in ParseDoDependency
251  */
252 static ParseSpecial specType;
253 
254 /*
255  * Predecessor node for handling .ORDER. Initialized to NULL when .ORDER
256  * seen, then set to each successive source on the line.
257  */
258 static GNode	*predecessor;
259 
260 ////////////////////////////////////////////////////////////
261 // parser state
262 
263 /* true if currently in a dependency line or its commands */
264 static Boolean inLine;
265 
266 /* number of fatal errors */
267 static int fatals = 0;
268 
269 /*
270  * Variables for doing includes
271  */
272 
273 /* current file being read */
274 static IFile *curFile;
275 
276 /* stack of IFiles generated by .includes */
277 static Lst includes;
278 
279 /* include paths (lists of directories) */
280 Lst parseIncPath;	/* dirs for "..." includes */
281 Lst sysIncPath;		/* dirs for <...> includes */
282 Lst defIncPath;		/* default for sysIncPath */
283 
284 ////////////////////////////////////////////////////////////
285 // parser tables
286 
287 /*
288  * The parseKeywords table is searched using binary search when deciding
289  * if a target or source is special. The 'spec' field is the ParseSpecial
290  * type of the keyword ("Not" if the keyword isn't special as a target) while
291  * the 'op' field is the operator to apply to the list of targets if the
292  * keyword is used as a source ("0" if the keyword isn't special as a source)
293  */
294 static const struct {
295     const char   *name;    	/* Name of keyword */
296     ParseSpecial  spec;	    	/* Type when used as a target */
297     int	    	  op;	    	/* Operator when used as a source */
298 } parseKeywords[] = {
299 { ".BEGIN", 	  Begin,    	0 },
300 { ".DEFAULT",	  Default,  	0 },
301 { ".END",   	  End,	    	0 },
302 { ".ERROR",   	  dotError,    	0 },
303 { ".EXEC",	  Attribute,   	OP_EXEC },
304 { ".IGNORE",	  Ignore,   	OP_IGNORE },
305 { ".INCLUDES",	  Includes, 	0 },
306 { ".INTERRUPT",	  Interrupt,	0 },
307 { ".INVISIBLE",	  Attribute,   	OP_INVISIBLE },
308 { ".JOIN",  	  Attribute,   	OP_JOIN },
309 { ".LIBS",  	  Libs,	    	0 },
310 { ".MADE",	  Attribute,	OP_MADE },
311 { ".MAIN",	  Main,		0 },
312 { ".MAKE",  	  Attribute,   	OP_MAKE },
313 { ".MAKEFLAGS",	  MFlags,   	0 },
314 { ".META",	  Meta,		OP_META },
315 { ".MFLAGS",	  MFlags,   	0 },
316 { ".NOMETA",	  NoMeta,	OP_NOMETA },
317 { ".NOMETA_CMP",  NoMetaCmp,	OP_NOMETA_CMP },
318 { ".NOPATH",	  NoPath,	OP_NOPATH },
319 { ".NOTMAIN",	  Attribute,   	OP_NOTMAIN },
320 { ".NOTPARALLEL", NotParallel,	0 },
321 { ".NO_PARALLEL", NotParallel,	0 },
322 { ".NULL",  	  Null,	    	0 },
323 { ".OBJDIR",	  ExObjdir,	0 },
324 { ".OPTIONAL",	  Attribute,   	OP_OPTIONAL },
325 { ".ORDER", 	  Order,    	0 },
326 { ".PARALLEL",	  Parallel,	0 },
327 { ".PATH",	  ExPath,	0 },
328 { ".PHONY",	  Phony,	OP_PHONY },
329 #ifdef POSIX
330 { ".POSIX",	  Posix,	0 },
331 #endif
332 { ".PRECIOUS",	  Precious, 	OP_PRECIOUS },
333 { ".RECURSIVE",	  Attribute,	OP_MAKE },
334 { ".SHELL", 	  ExShell,    	0 },
335 { ".SILENT",	  Silent,   	OP_SILENT },
336 { ".SINGLESHELL", SingleShell,	0 },
337 { ".STALE",	  Stale,	0 },
338 { ".SUFFIXES",	  Suffixes, 	0 },
339 { ".USE",   	  Attribute,   	OP_USE },
340 { ".USEBEFORE",   Attribute,   	OP_USEBEFORE },
341 { ".WAIT",	  Wait, 	0 },
342 };
343 
344 ////////////////////////////////////////////////////////////
345 // local functions
346 
347 static int ParseIsEscaped(const char *, const char *);
348 static void ParseErrorInternal(const char *, size_t, int, const char *, ...)
349     MAKE_ATTR_PRINTFLIKE(4,5);
350 static void ParseVErrorInternal(FILE *, const char *, size_t, int, const char *, va_list)
351     MAKE_ATTR_PRINTFLIKE(5, 0);
352 static int ParseFindKeyword(const char *);
353 static int ParseLinkSrc(void *, void *);
354 static int ParseDoOp(void *, void *);
355 static void ParseDoSrc(int, const char *);
356 static int ParseFindMain(void *, void *);
357 static int ParseAddDir(void *, void *);
358 static int ParseClearPath(void *, void *);
359 static void ParseDoDependency(char *);
360 static int ParseAddCmd(void *, void *);
361 static void ParseHasCommands(void *);
362 static void ParseDoInclude(char *);
363 static void ParseSetParseFile(const char *);
364 static void ParseSetIncludedFile(void);
365 #ifdef SYSVINCLUDE
366 static void ParseTraditionalInclude(char *);
367 #endif
368 #ifdef GMAKEEXPORT
369 static void ParseGmakeExport(char *);
370 #endif
371 static int ParseEOF(void);
372 static char *ParseReadLine(void);
373 static void ParseFinishLine(void);
374 static void ParseMark(GNode *);
375 
376 ////////////////////////////////////////////////////////////
377 // file loader
378 
379 struct loadedfile {
380 	const char *path;		/* name, for error reports */
381 	char *buf;			/* contents buffer */
382 	size_t len;			/* length of contents */
383 	size_t maplen;			/* length of mmap area, or 0 */
384 	Boolean used;			/* XXX: have we used the data yet */
385 };
386 
387 /*
388  * Constructor/destructor for loadedfile
389  */
390 static struct loadedfile *
391 loadedfile_create(const char *path)
392 {
393 	struct loadedfile *lf;
394 
395 	lf = bmake_malloc(sizeof(*lf));
396 	lf->path = (path == NULL ? "(stdin)" : path);
397 	lf->buf = NULL;
398 	lf->len = 0;
399 	lf->maplen = 0;
400 	lf->used = FALSE;
401 	return lf;
402 }
403 
404 static void
405 loadedfile_destroy(struct loadedfile *lf)
406 {
407 	if (lf->buf != NULL) {
408 		if (lf->maplen > 0) {
409 			munmap(lf->buf, lf->maplen);
410 		} else {
411 			free(lf->buf);
412 		}
413 	}
414 	free(lf);
415 }
416 
417 /*
418  * nextbuf() operation for loadedfile, as needed by the weird and twisted
419  * logic below. Once that's cleaned up, we can get rid of lf->used...
420  */
421 static char *
422 loadedfile_nextbuf(void *x, size_t *len)
423 {
424 	struct loadedfile *lf = x;
425 
426 	if (lf->used) {
427 		return NULL;
428 	}
429 	lf->used = TRUE;
430 	*len = lf->len;
431 	return lf->buf;
432 }
433 
434 /*
435  * Try to get the size of a file.
436  */
437 static ReturnStatus
438 load_getsize(int fd, size_t *ret)
439 {
440 	struct stat st;
441 
442 	if (fstat(fd, &st) < 0) {
443 		return FAILURE;
444 	}
445 
446 	if (!S_ISREG(st.st_mode)) {
447 		return FAILURE;
448 	}
449 
450 	/*
451 	 * st_size is an off_t, which is 64 bits signed; *ret is
452 	 * size_t, which might be 32 bits unsigned or 64 bits
453 	 * unsigned. Rather than being elaborate, just punt on
454 	 * files that are more than 2^31 bytes. We should never
455 	 * see a makefile that size in practice...
456 	 *
457 	 * While we're at it reject negative sizes too, just in case.
458 	 */
459 	if (st.st_size < 0 || st.st_size > 0x7fffffff) {
460 		return FAILURE;
461 	}
462 
463 	*ret = (size_t) st.st_size;
464 	return SUCCESS;
465 }
466 
467 /*
468  * Read in a file.
469  *
470  * Until the path search logic can be moved under here instead of
471  * being in the caller in another source file, we need to have the fd
472  * passed in already open. Bleh.
473  *
474  * If the path is NULL use stdin and (to insure against fd leaks)
475  * assert that the caller passed in -1.
476  */
477 static struct loadedfile *
478 loadfile(const char *path, int fd)
479 {
480 	struct loadedfile *lf;
481 	long pagesize;
482 	ssize_t result;
483 	size_t bufpos;
484 
485 	lf = loadedfile_create(path);
486 
487 	if (path == NULL) {
488 		assert(fd == -1);
489 		fd = STDIN_FILENO;
490 	} else {
491 #if 0 /* notyet */
492 		fd = open(path, O_RDONLY);
493 		if (fd < 0) {
494 			...
495 			Error("%s: %s", path, strerror(errno));
496 			exit(1);
497 		}
498 #endif
499 	}
500 
501 	if (load_getsize(fd, &lf->len) == SUCCESS) {
502 		/* found a size, try mmap */
503 		pagesize = sysconf(_SC_PAGESIZE);
504 		if (pagesize <= 0) {
505 			pagesize = 0x1000;
506 		}
507 		/* round size up to a page */
508 		lf->maplen = pagesize * ((lf->len + pagesize - 1)/pagesize);
509 
510 		/*
511 		 * XXX hack for dealing with empty files; remove when
512 		 * we're no longer limited by interfacing to the old
513 		 * logic elsewhere in this file.
514 		 */
515 		if (lf->maplen == 0) {
516 			lf->maplen = pagesize;
517 		}
518 
519 		/*
520 		 * FUTURE: remove PROT_WRITE when the parser no longer
521 		 * needs to scribble on the input.
522 		 */
523 		lf->buf = mmap(NULL, lf->maplen, PROT_READ|PROT_WRITE,
524 			       MAP_FILE|MAP_COPY, fd, 0);
525 		if (lf->buf != MAP_FAILED) {
526 			/* succeeded */
527 			if (lf->len == lf->maplen && lf->buf[lf->len - 1] != '\n') {
528 				char *b = malloc(lf->len + 1);
529 				b[lf->len] = '\n';
530 				memcpy(b, lf->buf, lf->len++);
531 				munmap(lf->buf, lf->maplen);
532 				lf->maplen = 0;
533 				lf->buf = b;
534 			}
535 			goto done;
536 		}
537 	}
538 
539 	/* cannot mmap; load the traditional way */
540 
541 	lf->maplen = 0;
542 	lf->len = 1024;
543 	lf->buf = bmake_malloc(lf->len);
544 
545 	bufpos = 0;
546 	while (1) {
547 		assert(bufpos <= lf->len);
548 		if (bufpos == lf->len) {
549 			lf->len *= 2;
550 			lf->buf = bmake_realloc(lf->buf, lf->len);
551 		}
552 		result = read(fd, lf->buf + bufpos, lf->len - bufpos);
553 		if (result < 0) {
554 			Error("%s: read error: %s", path, strerror(errno));
555 			exit(1);
556 		}
557 		if (result == 0) {
558 			break;
559 		}
560 		bufpos += result;
561 	}
562 	assert(bufpos <= lf->len);
563 	lf->len = bufpos;
564 
565 	/* truncate malloc region to actual length (maybe not useful) */
566 	if (lf->len > 0) {
567 		lf->buf = bmake_realloc(lf->buf, lf->len);
568 	}
569 
570 done:
571 	if (path != NULL) {
572 		close(fd);
573 	}
574 	return lf;
575 }
576 
577 ////////////////////////////////////////////////////////////
578 // old code
579 
580 /*-
581  *----------------------------------------------------------------------
582  * ParseIsEscaped --
583  *	Check if the current character is escaped on the current line
584  *
585  * Results:
586  *	0 if the character is not backslash escaped, 1 otherwise
587  *
588  * Side Effects:
589  *	None
590  *----------------------------------------------------------------------
591  */
592 static int
593 ParseIsEscaped(const char *line, const char *c)
594 {
595     int active = 0;
596     for (;;) {
597 	if (line == c)
598 	    return active;
599 	if (*--c != '\\')
600 	    return active;
601 	active = !active;
602     }
603 }
604 
605 /*-
606  *----------------------------------------------------------------------
607  * ParseFindKeyword --
608  *	Look in the table of keywords for one matching the given string.
609  *
610  * Input:
611  *	str		String to find
612  *
613  * Results:
614  *	The index of the keyword, or -1 if it isn't there.
615  *
616  * Side Effects:
617  *	None
618  *----------------------------------------------------------------------
619  */
620 static int
621 ParseFindKeyword(const char *str)
622 {
623     int    start, end, cur;
624     int    diff;
625 
626     start = 0;
627     end = (sizeof(parseKeywords)/sizeof(parseKeywords[0])) - 1;
628 
629     do {
630 	cur = start + ((end - start) / 2);
631 	diff = strcmp(str, parseKeywords[cur].name);
632 
633 	if (diff == 0) {
634 	    return (cur);
635 	} else if (diff < 0) {
636 	    end = cur - 1;
637 	} else {
638 	    start = cur + 1;
639 	}
640     } while (start <= end);
641     return (-1);
642 }
643 
644 /*-
645  * ParseVErrorInternal  --
646  *	Error message abort function for parsing. Prints out the context
647  *	of the error (line number and file) as well as the message with
648  *	two optional arguments.
649  *
650  * Results:
651  *	None
652  *
653  * Side Effects:
654  *	"fatals" is incremented if the level is PARSE_FATAL.
655  */
656 /* VARARGS */
657 static void
658 ParseVErrorInternal(FILE *f, const char *cfname, size_t clineno, int type,
659     const char *fmt, va_list ap)
660 {
661 	static Boolean fatal_warning_error_printed = FALSE;
662 
663 	(void)fprintf(f, "%s: ", progname);
664 
665 	if (cfname != NULL) {
666 		(void)fprintf(f, "\"");
667 		if (*cfname != '/' && strcmp(cfname, "(stdin)") != 0) {
668 			char *cp;
669 			const char *dir;
670 
671 			/*
672 			 * Nothing is more annoying than not knowing
673 			 * which Makefile is the culprit.
674 			 */
675 			dir = Var_Value(".PARSEDIR", VAR_GLOBAL, &cp);
676 			if (dir == NULL || *dir == '\0' ||
677 			    (*dir == '.' && dir[1] == '\0'))
678 				dir = Var_Value(".CURDIR", VAR_GLOBAL, &cp);
679 			if (dir == NULL)
680 				dir = ".";
681 
682 			(void)fprintf(f, "%s/%s", dir, cfname);
683 		} else
684 			(void)fprintf(f, "%s", cfname);
685 
686 		(void)fprintf(f, "\" line %d: ", (int)clineno);
687 	}
688 	if (type == PARSE_WARNING)
689 		(void)fprintf(f, "warning: ");
690 	(void)vfprintf(f, fmt, ap);
691 	(void)fprintf(f, "\n");
692 	(void)fflush(f);
693 	if (type == PARSE_FATAL || parseWarnFatal)
694 		fatals += 1;
695 	if (parseWarnFatal && !fatal_warning_error_printed) {
696 		Error("parsing warnings being treated as errors");
697 		fatal_warning_error_printed = TRUE;
698 	}
699 }
700 
701 /*-
702  * ParseErrorInternal  --
703  *	Error function
704  *
705  * Results:
706  *	None
707  *
708  * Side Effects:
709  *	None
710  */
711 /* VARARGS */
712 static void
713 ParseErrorInternal(const char *cfname, size_t clineno, int type,
714     const char *fmt, ...)
715 {
716 	va_list ap;
717 
718 	va_start(ap, fmt);
719 	(void)fflush(stdout);
720 	ParseVErrorInternal(stderr, cfname, clineno, type, fmt, ap);
721 	va_end(ap);
722 
723 	if (debug_file != stderr && debug_file != stdout) {
724 		va_start(ap, fmt);
725 		ParseVErrorInternal(debug_file, cfname, clineno, type, fmt, ap);
726 		va_end(ap);
727 	}
728 }
729 
730 /*-
731  * Parse_Error  --
732  *	External interface to ParseErrorInternal; uses the default filename
733  *	Line number.
734  *
735  * Results:
736  *	None
737  *
738  * Side Effects:
739  *	None
740  */
741 /* VARARGS */
742 void
743 Parse_Error(int type, const char *fmt, ...)
744 {
745 	va_list ap;
746 	const char *fname;
747 	size_t lineno;
748 
749 	if (curFile == NULL) {
750 		fname = NULL;
751 		lineno = 0;
752 	} else {
753 		fname = curFile->fname;
754 		lineno = curFile->lineno;
755 	}
756 
757 	va_start(ap, fmt);
758 	(void)fflush(stdout);
759 	ParseVErrorInternal(stderr, fname, lineno, type, fmt, ap);
760 	va_end(ap);
761 
762 	if (debug_file != stderr && debug_file != stdout) {
763 		va_start(ap, fmt);
764 		ParseVErrorInternal(debug_file, fname, lineno, type, fmt, ap);
765 		va_end(ap);
766 	}
767 }
768 
769 
770 /*
771  * ParseMessage
772  *	Parse a .info .warning or .error directive
773  *
774  *	The input is the line minus the ".".  We substitute
775  *	variables, print the message and exit(1) (for .error) or just print
776  *	a warning if the directive is malformed.
777  */
778 static Boolean
779 ParseMessage(char *line)
780 {
781     int mtype;
782 
783     switch(*line) {
784     case 'i':
785 	mtype = 0;
786 	break;
787     case 'w':
788 	mtype = PARSE_WARNING;
789 	break;
790     case 'e':
791 	mtype = PARSE_FATAL;
792 	break;
793     default:
794 	Parse_Error(PARSE_WARNING, "invalid syntax: \".%s\"", line);
795 	return FALSE;
796     }
797 
798     while (isalpha((u_char)*line))
799 	line++;
800     if (!isspace((u_char)*line))
801 	return FALSE;			/* not for us */
802     while (isspace((u_char)*line))
803 	line++;
804 
805     line = Var_Subst(NULL, line, VAR_CMD, FALSE, TRUE, FALSE);
806     Parse_Error(mtype, "%s", line);
807     free(line);
808 
809     if (mtype == PARSE_FATAL) {
810 	/* Terminate immediately. */
811 	exit(1);
812     }
813     return TRUE;
814 }
815 
816 /*-
817  *---------------------------------------------------------------------
818  * ParseLinkSrc  --
819  *	Link the parent node to its new child. Used in a Lst_ForEach by
820  *	ParseDoDependency. If the specType isn't 'Not', the parent
821  *	isn't linked as a parent of the child.
822  *
823  * Input:
824  *	pgnp		The parent node
825  *	cgpn		The child node
826  *
827  * Results:
828  *	Always = 0
829  *
830  * Side Effects:
831  *	New elements are added to the parents list of cgn and the
832  *	children list of cgn. the unmade field of pgn is updated
833  *	to reflect the additional child.
834  *---------------------------------------------------------------------
835  */
836 static int
837 ParseLinkSrc(void *pgnp, void *cgnp)
838 {
839     GNode          *pgn = (GNode *)pgnp;
840     GNode          *cgn = (GNode *)cgnp;
841 
842     if ((pgn->type & OP_DOUBLEDEP) && !Lst_IsEmpty (pgn->cohorts))
843 	pgn = (GNode *)Lst_Datum(Lst_Last(pgn->cohorts));
844     (void)Lst_AtEnd(pgn->children, cgn);
845     if (specType == Not)
846 	    (void)Lst_AtEnd(cgn->parents, pgn);
847     pgn->unmade += 1;
848     if (DEBUG(PARSE)) {
849 	fprintf(debug_file, "# %s: added child %s - %s\n", __func__,
850 	    pgn->name, cgn->name);
851 	Targ_PrintNode(pgn, 0);
852 	Targ_PrintNode(cgn, 0);
853     }
854     return (0);
855 }
856 
857 /*-
858  *---------------------------------------------------------------------
859  * ParseDoOp  --
860  *	Apply the parsed operator to the given target node. Used in a
861  *	Lst_ForEach call by ParseDoDependency once all targets have
862  *	been found and their operator parsed. If the previous and new
863  *	operators are incompatible, a major error is taken.
864  *
865  * Input:
866  *	gnp		The node to which the operator is to be applied
867  *	opp		The operator to apply
868  *
869  * Results:
870  *	Always 0
871  *
872  * Side Effects:
873  *	The type field of the node is altered to reflect any new bits in
874  *	the op.
875  *---------------------------------------------------------------------
876  */
877 static int
878 ParseDoOp(void *gnp, void *opp)
879 {
880     GNode          *gn = (GNode *)gnp;
881     int             op = *(int *)opp;
882     /*
883      * If the dependency mask of the operator and the node don't match and
884      * the node has actually had an operator applied to it before, and
885      * the operator actually has some dependency information in it, complain.
886      */
887     if (((op & OP_OPMASK) != (gn->type & OP_OPMASK)) &&
888 	!OP_NOP(gn->type) && !OP_NOP(op))
889     {
890 	Parse_Error(PARSE_FATAL, "Inconsistent operator for %s", gn->name);
891 	return (1);
892     }
893 
894     if ((op == OP_DOUBLEDEP) && ((gn->type & OP_OPMASK) == OP_DOUBLEDEP)) {
895 	/*
896 	 * If the node was the object of a :: operator, we need to create a
897 	 * new instance of it for the children and commands on this dependency
898 	 * line. The new instance is placed on the 'cohorts' list of the
899 	 * initial one (note the initial one is not on its own cohorts list)
900 	 * and the new instance is linked to all parents of the initial
901 	 * instance.
902 	 */
903 	GNode	*cohort;
904 
905 	/*
906 	 * Propagate copied bits to the initial node.  They'll be propagated
907 	 * back to the rest of the cohorts later.
908 	 */
909 	gn->type |= op & ~OP_OPMASK;
910 
911 	cohort = Targ_FindNode(gn->name, TARG_NOHASH);
912 	if (doing_depend)
913 	    ParseMark(cohort);
914 	/*
915 	 * Make the cohort invisible as well to avoid duplicating it into
916 	 * other variables. True, parents of this target won't tend to do
917 	 * anything with their local variables, but better safe than
918 	 * sorry. (I think this is pointless now, since the relevant list
919 	 * traversals will no longer see this node anyway. -mycroft)
920 	 */
921 	cohort->type = op | OP_INVISIBLE;
922 	(void)Lst_AtEnd(gn->cohorts, cohort);
923 	cohort->centurion = gn;
924 	gn->unmade_cohorts += 1;
925 	snprintf(cohort->cohort_num, sizeof cohort->cohort_num, "#%d",
926 		gn->unmade_cohorts);
927     } else {
928 	/*
929 	 * We don't want to nuke any previous flags (whatever they were) so we
930 	 * just OR the new operator into the old
931 	 */
932 	gn->type |= op;
933     }
934 
935     return (0);
936 }
937 
938 /*-
939  *---------------------------------------------------------------------
940  * ParseDoSrc  --
941  *	Given the name of a source, figure out if it is an attribute
942  *	and apply it to the targets if it is. Else decide if there is
943  *	some attribute which should be applied *to* the source because
944  *	of some special target and apply it if so. Otherwise, make the
945  *	source be a child of the targets in the list 'targets'
946  *
947  * Input:
948  *	tOp		operator (if any) from special targets
949  *	src		name of the source to handle
950  *
951  * Results:
952  *	None
953  *
954  * Side Effects:
955  *	Operator bits may be added to the list of targets or to the source.
956  *	The targets may have a new source added to their lists of children.
957  *---------------------------------------------------------------------
958  */
959 static void
960 ParseDoSrc(int tOp, const char *src)
961 {
962     GNode	*gn = NULL;
963     static int wait_number = 0;
964     char wait_src[16];
965 
966     if (*src == '.' && isupper ((unsigned char)src[1])) {
967 	int keywd = ParseFindKeyword(src);
968 	if (keywd != -1) {
969 	    int op = parseKeywords[keywd].op;
970 	    if (op != 0) {
971 		Lst_ForEach(targets, ParseDoOp, &op);
972 		return;
973 	    }
974 	    if (parseKeywords[keywd].spec == Wait) {
975 		/*
976 		 * We add a .WAIT node in the dependency list.
977 		 * After any dynamic dependencies (and filename globbing)
978 		 * have happened, it is given a dependency on the each
979 		 * previous child back to and previous .WAIT node.
980 		 * The next child won't be scheduled until the .WAIT node
981 		 * is built.
982 		 * We give each .WAIT node a unique name (mainly for diag).
983 		 */
984 		snprintf(wait_src, sizeof wait_src, ".WAIT_%u", ++wait_number);
985 		gn = Targ_FindNode(wait_src, TARG_NOHASH);
986 		if (doing_depend)
987 		    ParseMark(gn);
988 		gn->type = OP_WAIT | OP_PHONY | OP_DEPENDS | OP_NOTMAIN;
989 		Lst_ForEach(targets, ParseLinkSrc, gn);
990 		return;
991 	    }
992 	}
993     }
994 
995     switch (specType) {
996     case Main:
997 	/*
998 	 * If we have noted the existence of a .MAIN, it means we need
999 	 * to add the sources of said target to the list of things
1000 	 * to create. The string 'src' is likely to be free, so we
1001 	 * must make a new copy of it. Note that this will only be
1002 	 * invoked if the user didn't specify a target on the command
1003 	 * line. This is to allow #ifmake's to succeed, or something...
1004 	 */
1005 	(void)Lst_AtEnd(create, bmake_strdup(src));
1006 	/*
1007 	 * Add the name to the .TARGETS variable as well, so the user can
1008 	 * employ that, if desired.
1009 	 */
1010 	Var_Append(".TARGETS", src, VAR_GLOBAL);
1011 	return;
1012 
1013     case Order:
1014 	/*
1015 	 * Create proper predecessor/successor links between the previous
1016 	 * source and the current one.
1017 	 */
1018 	gn = Targ_FindNode(src, TARG_CREATE);
1019 	if (doing_depend)
1020 	    ParseMark(gn);
1021 	if (predecessor != NULL) {
1022 	    (void)Lst_AtEnd(predecessor->order_succ, gn);
1023 	    (void)Lst_AtEnd(gn->order_pred, predecessor);
1024 	    if (DEBUG(PARSE)) {
1025 		fprintf(debug_file, "# %s: added Order dependency %s - %s\n",
1026 		    __func__, predecessor->name, gn->name);
1027 		Targ_PrintNode(predecessor, 0);
1028 		Targ_PrintNode(gn, 0);
1029 	    }
1030 	}
1031 	/*
1032 	 * The current source now becomes the predecessor for the next one.
1033 	 */
1034 	predecessor = gn;
1035 	break;
1036 
1037     default:
1038 	/*
1039 	 * If the source is not an attribute, we need to find/create
1040 	 * a node for it. After that we can apply any operator to it
1041 	 * from a special target or link it to its parents, as
1042 	 * appropriate.
1043 	 *
1044 	 * In the case of a source that was the object of a :: operator,
1045 	 * the attribute is applied to all of its instances (as kept in
1046 	 * the 'cohorts' list of the node) or all the cohorts are linked
1047 	 * to all the targets.
1048 	 */
1049 
1050 	/* Find/create the 'src' node and attach to all targets */
1051 	gn = Targ_FindNode(src, TARG_CREATE);
1052 	if (doing_depend)
1053 	    ParseMark(gn);
1054 	if (tOp) {
1055 	    gn->type |= tOp;
1056 	} else {
1057 	    Lst_ForEach(targets, ParseLinkSrc, gn);
1058 	}
1059 	break;
1060     }
1061 }
1062 
1063 /*-
1064  *-----------------------------------------------------------------------
1065  * ParseFindMain --
1066  *	Find a real target in the list and set it to be the main one.
1067  *	Called by ParseDoDependency when a main target hasn't been found
1068  *	yet.
1069  *
1070  * Input:
1071  *	gnp		Node to examine
1072  *
1073  * Results:
1074  *	0 if main not found yet, 1 if it is.
1075  *
1076  * Side Effects:
1077  *	mainNode is changed and Targ_SetMain is called.
1078  *
1079  *-----------------------------------------------------------------------
1080  */
1081 static int
1082 ParseFindMain(void *gnp, void *dummy)
1083 {
1084     GNode   	  *gn = (GNode *)gnp;
1085     if ((gn->type & OP_NOTARGET) == 0) {
1086 	mainNode = gn;
1087 	Targ_SetMain(gn);
1088 	return (dummy ? 1 : 1);
1089     } else {
1090 	return (dummy ? 0 : 0);
1091     }
1092 }
1093 
1094 /*-
1095  *-----------------------------------------------------------------------
1096  * ParseAddDir --
1097  *	Front-end for Dir_AddDir to make sure Lst_ForEach keeps going
1098  *
1099  * Results:
1100  *	=== 0
1101  *
1102  * Side Effects:
1103  *	See Dir_AddDir.
1104  *
1105  *-----------------------------------------------------------------------
1106  */
1107 static int
1108 ParseAddDir(void *path, void *name)
1109 {
1110     (void)Dir_AddDir((Lst) path, (char *)name);
1111     return(0);
1112 }
1113 
1114 /*-
1115  *-----------------------------------------------------------------------
1116  * ParseClearPath --
1117  *	Front-end for Dir_ClearPath to make sure Lst_ForEach keeps going
1118  *
1119  * Results:
1120  *	=== 0
1121  *
1122  * Side Effects:
1123  *	See Dir_ClearPath
1124  *
1125  *-----------------------------------------------------------------------
1126  */
1127 static int
1128 ParseClearPath(void *path, void *dummy)
1129 {
1130     Dir_ClearPath((Lst) path);
1131     return(dummy ? 0 : 0);
1132 }
1133 
1134 /*-
1135  *---------------------------------------------------------------------
1136  * ParseDoDependency  --
1137  *	Parse the dependency line in line.
1138  *
1139  * Input:
1140  *	line		the line to parse
1141  *
1142  * Results:
1143  *	None
1144  *
1145  * Side Effects:
1146  *	The nodes of the sources are linked as children to the nodes of the
1147  *	targets. Some nodes may be created.
1148  *
1149  *	We parse a dependency line by first extracting words from the line and
1150  * finding nodes in the list of all targets with that name. This is done
1151  * until a character is encountered which is an operator character. Currently
1152  * these are only ! and :. At this point the operator is parsed and the
1153  * pointer into the line advanced until the first source is encountered.
1154  * 	The parsed operator is applied to each node in the 'targets' list,
1155  * which is where the nodes found for the targets are kept, by means of
1156  * the ParseDoOp function.
1157  *	The sources are read in much the same way as the targets were except
1158  * that now they are expanded using the wildcarding scheme of the C-Shell
1159  * and all instances of the resulting words in the list of all targets
1160  * are found. Each of the resulting nodes is then linked to each of the
1161  * targets as one of its children.
1162  *	Certain targets are handled specially. These are the ones detailed
1163  * by the specType variable.
1164  *	The storing of transformation rules is also taken care of here.
1165  * A target is recognized as a transformation rule by calling
1166  * Suff_IsTransform. If it is a transformation rule, its node is gotten
1167  * from the suffix module via Suff_AddTransform rather than the standard
1168  * Targ_FindNode in the target module.
1169  *---------------------------------------------------------------------
1170  */
1171 static void
1172 ParseDoDependency(char *line)
1173 {
1174     char  	   *cp;		/* our current position */
1175     GNode 	   *gn = NULL;	/* a general purpose temporary node */
1176     int             op;		/* the operator on the line */
1177     char            savec;	/* a place to save a character */
1178     Lst    	    paths;   	/* List of search paths to alter when parsing
1179 				 * a list of .PATH targets */
1180     int	    	    tOp;    	/* operator from special target */
1181     Lst	    	    sources;	/* list of archive source names after
1182 				 * expansion */
1183     Lst 	    curTargs;	/* list of target names to be found and added
1184 				 * to the targets list */
1185     char	   *lstart = line;
1186 
1187     if (DEBUG(PARSE))
1188 	fprintf(debug_file, "ParseDoDependency(%s)\n", line);
1189     tOp = 0;
1190 
1191     specType = Not;
1192     paths = NULL;
1193 
1194     curTargs = Lst_Init(FALSE);
1195 
1196     /*
1197      * First, grind through the targets.
1198      */
1199 
1200     do {
1201 	/*
1202 	 * Here LINE points to the beginning of the next word, and
1203 	 * LSTART points to the actual beginning of the line.
1204 	 */
1205 
1206 	/* Find the end of the next word. */
1207 	for (cp = line; *cp && (ParseIsEscaped(lstart, cp) ||
1208 		     !(isspace((unsigned char)*cp) ||
1209 			 *cp == '!' || *cp == ':' || *cp == LPAREN));
1210 		 cp++) {
1211 	    if (*cp == '$') {
1212 		/*
1213 		 * Must be a dynamic source (would have been expanded
1214 		 * otherwise), so call the Var module to parse the puppy
1215 		 * so we can safely advance beyond it...There should be
1216 		 * no errors in this, as they would have been discovered
1217 		 * in the initial Var_Subst and we wouldn't be here.
1218 		 */
1219 		int 	length;
1220 		void    *freeIt;
1221 
1222 		(void)Var_Parse(cp, VAR_CMD, TRUE, TRUE, FALSE, &length, &freeIt);
1223 		if (freeIt)
1224 		    free(freeIt);
1225 		cp += length-1;
1226 	    }
1227 	}
1228 
1229 	/*
1230 	 * If the word is followed by a left parenthesis, it's the
1231 	 * name of an object file inside an archive (ar file).
1232 	 */
1233 	if (!ParseIsEscaped(lstart, cp) && *cp == LPAREN) {
1234 	    /*
1235 	     * Archives must be handled specially to make sure the OP_ARCHV
1236 	     * flag is set in their 'type' field, for one thing, and because
1237 	     * things like "archive(file1.o file2.o file3.o)" are permissible.
1238 	     * Arch_ParseArchive will set 'line' to be the first non-blank
1239 	     * after the archive-spec. It creates/finds nodes for the members
1240 	     * and places them on the given list, returning SUCCESS if all
1241 	     * went well and FAILURE if there was an error in the
1242 	     * specification. On error, line should remain untouched.
1243 	     */
1244 	    if (Arch_ParseArchive(&line, targets, VAR_CMD) != SUCCESS) {
1245 		Parse_Error(PARSE_FATAL,
1246 			     "Error in archive specification: \"%s\"", line);
1247 		goto out;
1248 	    } else {
1249 		/* Done with this word; on to the next. */
1250 		continue;
1251 	    }
1252 	}
1253 
1254 	if (!*cp) {
1255 	    /*
1256 	     * We got to the end of the line while we were still
1257 	     * looking at targets.
1258 	     *
1259 	     * Ending a dependency line without an operator is a Bozo
1260 	     * no-no.  As a heuristic, this is also often triggered by
1261 	     * undetected conflicts from cvs/rcs merges.
1262 	     */
1263 	    if ((strncmp(line, "<<<<<<", 6) == 0) ||
1264 		(strncmp(line, "======", 6) == 0) ||
1265 		(strncmp(line, ">>>>>>", 6) == 0))
1266 		Parse_Error(PARSE_FATAL,
1267 		    "Makefile appears to contain unresolved cvs/rcs/??? merge conflicts");
1268 	    else
1269 		Parse_Error(PARSE_FATAL, lstart[0] == '.' ? "Unknown directive"
1270 				     : "Need an operator");
1271 	    goto out;
1272 	}
1273 
1274 	/* Insert a null terminator. */
1275 	savec = *cp;
1276 	*cp = '\0';
1277 
1278 	/*
1279 	 * Got the word. See if it's a special target and if so set
1280 	 * specType to match it.
1281 	 */
1282 	if (*line == '.' && isupper ((unsigned char)line[1])) {
1283 	    /*
1284 	     * See if the target is a special target that must have it
1285 	     * or its sources handled specially.
1286 	     */
1287 	    int keywd = ParseFindKeyword(line);
1288 	    if (keywd != -1) {
1289 		if (specType == ExPath && parseKeywords[keywd].spec != ExPath) {
1290 		    Parse_Error(PARSE_FATAL, "Mismatched special targets");
1291 		    goto out;
1292 		}
1293 
1294 		specType = parseKeywords[keywd].spec;
1295 		tOp = parseKeywords[keywd].op;
1296 
1297 		/*
1298 		 * Certain special targets have special semantics:
1299 		 *	.PATH		Have to set the dirSearchPath
1300 		 *			variable too
1301 		 *	.MAIN		Its sources are only used if
1302 		 *			nothing has been specified to
1303 		 *			create.
1304 		 *	.DEFAULT    	Need to create a node to hang
1305 		 *			commands on, but we don't want
1306 		 *			it in the graph, nor do we want
1307 		 *			it to be the Main Target, so we
1308 		 *			create it, set OP_NOTMAIN and
1309 		 *			add it to the list, setting
1310 		 *			DEFAULT to the new node for
1311 		 *			later use. We claim the node is
1312 		 *	    	    	A transformation rule to make
1313 		 *	    	    	life easier later, when we'll
1314 		 *	    	    	use Make_HandleUse to actually
1315 		 *	    	    	apply the .DEFAULT commands.
1316 		 *	.PHONY		The list of targets
1317 		 *	.NOPATH		Don't search for file in the path
1318 		 *	.STALE
1319 		 *	.BEGIN
1320 		 *	.END
1321 		 *	.ERROR
1322 		 *	.INTERRUPT  	Are not to be considered the
1323 		 *			main target.
1324 		 *  	.NOTPARALLEL	Make only one target at a time.
1325 		 *  	.SINGLESHELL	Create a shell for each command.
1326 		 *  	.ORDER	    	Must set initial predecessor to NULL
1327 		 */
1328 		switch (specType) {
1329 		case ExPath:
1330 		    if (paths == NULL) {
1331 			paths = Lst_Init(FALSE);
1332 		    }
1333 		    (void)Lst_AtEnd(paths, dirSearchPath);
1334 		    break;
1335 		case Main:
1336 		    if (!Lst_IsEmpty(create)) {
1337 			specType = Not;
1338 		    }
1339 		    break;
1340 		case Begin:
1341 		case End:
1342 		case Stale:
1343 		case dotError:
1344 		case Interrupt:
1345 		    gn = Targ_FindNode(line, TARG_CREATE);
1346 		    if (doing_depend)
1347 			ParseMark(gn);
1348 		    gn->type |= OP_NOTMAIN|OP_SPECIAL;
1349 		    (void)Lst_AtEnd(targets, gn);
1350 		    break;
1351 		case Default:
1352 		    gn = Targ_NewGN(".DEFAULT");
1353 		    gn->type |= (OP_NOTMAIN|OP_TRANSFORM);
1354 		    (void)Lst_AtEnd(targets, gn);
1355 		    DEFAULT = gn;
1356 		    break;
1357 		case NotParallel:
1358 		    maxJobs = 1;
1359 		    break;
1360 		case SingleShell:
1361 		    compatMake = TRUE;
1362 		    break;
1363 		case Order:
1364 		    predecessor = NULL;
1365 		    break;
1366 		default:
1367 		    break;
1368 		}
1369 	    } else if (strncmp(line, ".PATH", 5) == 0) {
1370 		/*
1371 		 * .PATH<suffix> has to be handled specially.
1372 		 * Call on the suffix module to give us a path to
1373 		 * modify.
1374 		 */
1375 		Lst 	path;
1376 
1377 		specType = ExPath;
1378 		path = Suff_GetPath(&line[5]);
1379 		if (path == NULL) {
1380 		    Parse_Error(PARSE_FATAL,
1381 				 "Suffix '%s' not defined (yet)",
1382 				 &line[5]);
1383 		    goto out;
1384 		} else {
1385 		    if (paths == NULL) {
1386 			paths = Lst_Init(FALSE);
1387 		    }
1388 		    (void)Lst_AtEnd(paths, path);
1389 		}
1390 	    }
1391 	}
1392 
1393 	/*
1394 	 * Have word in line. Get or create its node and stick it at
1395 	 * the end of the targets list
1396 	 */
1397 	if ((specType == Not) && (*line != '\0')) {
1398 	    if (Dir_HasWildcards(line)) {
1399 		/*
1400 		 * Targets are to be sought only in the current directory,
1401 		 * so create an empty path for the thing. Note we need to
1402 		 * use Dir_Destroy in the destruction of the path as the
1403 		 * Dir module could have added a directory to the path...
1404 		 */
1405 		Lst	    emptyPath = Lst_Init(FALSE);
1406 
1407 		Dir_Expand(line, emptyPath, curTargs);
1408 
1409 		Lst_Destroy(emptyPath, Dir_Destroy);
1410 	    } else {
1411 		/*
1412 		 * No wildcards, but we want to avoid code duplication,
1413 		 * so create a list with the word on it.
1414 		 */
1415 		(void)Lst_AtEnd(curTargs, line);
1416 	    }
1417 
1418 	    /* Apply the targets. */
1419 
1420 	    while(!Lst_IsEmpty(curTargs)) {
1421 		char	*targName = (char *)Lst_DeQueue(curTargs);
1422 
1423 		if (!Suff_IsTransform (targName)) {
1424 		    gn = Targ_FindNode(targName, TARG_CREATE);
1425 		} else {
1426 		    gn = Suff_AddTransform(targName);
1427 		}
1428 		if (doing_depend)
1429 		    ParseMark(gn);
1430 
1431 		(void)Lst_AtEnd(targets, gn);
1432 	    }
1433 	} else if (specType == ExPath && *line != '.' && *line != '\0') {
1434 	    Parse_Error(PARSE_WARNING, "Extra target (%s) ignored", line);
1435 	}
1436 
1437 	/* Don't need the inserted null terminator any more. */
1438 	*cp = savec;
1439 
1440 	/*
1441 	 * If it is a special type and not .PATH, it's the only target we
1442 	 * allow on this line...
1443 	 */
1444 	if (specType != Not && specType != ExPath) {
1445 	    Boolean warning = FALSE;
1446 
1447 	    while (*cp && (ParseIsEscaped(lstart, cp) ||
1448 		((*cp != '!') && (*cp != ':')))) {
1449 		if (ParseIsEscaped(lstart, cp) ||
1450 		    (*cp != ' ' && *cp != '\t')) {
1451 		    warning = TRUE;
1452 		}
1453 		cp++;
1454 	    }
1455 	    if (warning) {
1456 		Parse_Error(PARSE_WARNING, "Extra target ignored");
1457 	    }
1458 	} else {
1459 	    while (*cp && isspace ((unsigned char)*cp)) {
1460 		cp++;
1461 	    }
1462 	}
1463 	line = cp;
1464     } while (*line && (ParseIsEscaped(lstart, line) ||
1465 	((*line != '!') && (*line != ':'))));
1466 
1467     /*
1468      * Don't need the list of target names anymore...
1469      */
1470     Lst_Destroy(curTargs, NULL);
1471     curTargs = NULL;
1472 
1473     if (!Lst_IsEmpty(targets)) {
1474 	switch(specType) {
1475 	    default:
1476 		Parse_Error(PARSE_WARNING, "Special and mundane targets don't mix. Mundane ones ignored");
1477 		break;
1478 	    case Default:
1479 	    case Stale:
1480 	    case Begin:
1481 	    case End:
1482 	    case dotError:
1483 	    case Interrupt:
1484 		/*
1485 		 * These four create nodes on which to hang commands, so
1486 		 * targets shouldn't be empty...
1487 		 */
1488 	    case Not:
1489 		/*
1490 		 * Nothing special here -- targets can be empty if it wants.
1491 		 */
1492 		break;
1493 	}
1494     }
1495 
1496     /*
1497      * Have now parsed all the target names. Must parse the operator next. The
1498      * result is left in  op .
1499      */
1500     if (*cp == '!') {
1501 	op = OP_FORCE;
1502     } else if (*cp == ':') {
1503 	if (cp[1] == ':') {
1504 	    op = OP_DOUBLEDEP;
1505 	    cp++;
1506 	} else {
1507 	    op = OP_DEPENDS;
1508 	}
1509     } else {
1510 	Parse_Error(PARSE_FATAL, lstart[0] == '.' ? "Unknown directive"
1511 		    : "Missing dependency operator");
1512 	goto out;
1513     }
1514 
1515     /* Advance beyond the operator */
1516     cp++;
1517 
1518     /*
1519      * Apply the operator to the target. This is how we remember which
1520      * operator a target was defined with. It fails if the operator
1521      * used isn't consistent across all references.
1522      */
1523     Lst_ForEach(targets, ParseDoOp, &op);
1524 
1525     /*
1526      * Onward to the sources.
1527      *
1528      * LINE will now point to the first source word, if any, or the
1529      * end of the string if not.
1530      */
1531     while (*cp && isspace ((unsigned char)*cp)) {
1532 	cp++;
1533     }
1534     line = cp;
1535 
1536     /*
1537      * Several special targets take different actions if present with no
1538      * sources:
1539      *	a .SUFFIXES line with no sources clears out all old suffixes
1540      *	a .PRECIOUS line makes all targets precious
1541      *	a .IGNORE line ignores errors for all targets
1542      *	a .SILENT line creates silence when making all targets
1543      *	a .PATH removes all directories from the search path(s).
1544      */
1545     if (!*line) {
1546 	switch (specType) {
1547 	    case Suffixes:
1548 		Suff_ClearSuffixes();
1549 		break;
1550 	    case Precious:
1551 		allPrecious = TRUE;
1552 		break;
1553 	    case Ignore:
1554 		ignoreErrors = TRUE;
1555 		break;
1556 	    case Silent:
1557 		beSilent = TRUE;
1558 		break;
1559 	    case ExPath:
1560 		Lst_ForEach(paths, ParseClearPath, NULL);
1561 		Dir_SetPATH();
1562 		break;
1563 #ifdef POSIX
1564             case Posix:
1565                 Var_Set("%POSIX", "1003.2", VAR_GLOBAL, 0);
1566                 break;
1567 #endif
1568 	    default:
1569 		break;
1570 	}
1571     } else if (specType == MFlags) {
1572 	/*
1573 	 * Call on functions in main.c to deal with these arguments and
1574 	 * set the initial character to a null-character so the loop to
1575 	 * get sources won't get anything
1576 	 */
1577 	Main_ParseArgLine(line);
1578 	*line = '\0';
1579     } else if (specType == ExShell) {
1580 	if (Job_ParseShell(line) != SUCCESS) {
1581 	    Parse_Error(PARSE_FATAL, "improper shell specification");
1582 	    goto out;
1583 	}
1584 	*line = '\0';
1585     } else if ((specType == NotParallel) || (specType == SingleShell)) {
1586 	*line = '\0';
1587     }
1588 
1589     /*
1590      * NOW GO FOR THE SOURCES
1591      */
1592     if ((specType == Suffixes) || (specType == ExPath) ||
1593 	(specType == Includes) || (specType == Libs) ||
1594 	(specType == Null) || (specType == ExObjdir))
1595     {
1596 	while (*line) {
1597 	    /*
1598 	     * If the target was one that doesn't take files as its sources
1599 	     * but takes something like suffixes, we take each
1600 	     * space-separated word on the line as a something and deal
1601 	     * with it accordingly.
1602 	     *
1603 	     * If the target was .SUFFIXES, we take each source as a
1604 	     * suffix and add it to the list of suffixes maintained by the
1605 	     * Suff module.
1606 	     *
1607 	     * If the target was a .PATH, we add the source as a directory
1608 	     * to search on the search path.
1609 	     *
1610 	     * If it was .INCLUDES, the source is taken to be the suffix of
1611 	     * files which will be #included and whose search path should
1612 	     * be present in the .INCLUDES variable.
1613 	     *
1614 	     * If it was .LIBS, the source is taken to be the suffix of
1615 	     * files which are considered libraries and whose search path
1616 	     * should be present in the .LIBS variable.
1617 	     *
1618 	     * If it was .NULL, the source is the suffix to use when a file
1619 	     * has no valid suffix.
1620 	     *
1621 	     * If it was .OBJDIR, the source is a new definition for .OBJDIR,
1622 	     * and will cause make to do a new chdir to that path.
1623 	     */
1624 	    while (*cp && !isspace ((unsigned char)*cp)) {
1625 		cp++;
1626 	    }
1627 	    savec = *cp;
1628 	    *cp = '\0';
1629 	    switch (specType) {
1630 		case Suffixes:
1631 		    Suff_AddSuffix(line, &mainNode);
1632 		    break;
1633 		case ExPath:
1634 		    Lst_ForEach(paths, ParseAddDir, line);
1635 		    break;
1636 		case Includes:
1637 		    Suff_AddInclude(line);
1638 		    break;
1639 		case Libs:
1640 		    Suff_AddLib(line);
1641 		    break;
1642 		case Null:
1643 		    Suff_SetNull(line);
1644 		    break;
1645 		case ExObjdir:
1646 		    Main_SetObjdir(line);
1647 		    break;
1648 		default:
1649 		    break;
1650 	    }
1651 	    *cp = savec;
1652 	    if (savec != '\0') {
1653 		cp++;
1654 	    }
1655 	    while (*cp && isspace ((unsigned char)*cp)) {
1656 		cp++;
1657 	    }
1658 	    line = cp;
1659 	}
1660 	if (paths) {
1661 	    Lst_Destroy(paths, NULL);
1662 	}
1663 	if (specType == ExPath)
1664 	    Dir_SetPATH();
1665     } else {
1666 	while (*line) {
1667 	    /*
1668 	     * The targets take real sources, so we must beware of archive
1669 	     * specifications (i.e. things with left parentheses in them)
1670 	     * and handle them accordingly.
1671 	     */
1672 	    for (; *cp && !isspace ((unsigned char)*cp); cp++) {
1673 		if ((*cp == LPAREN) && (cp > line) && (cp[-1] != '$')) {
1674 		    /*
1675 		     * Only stop for a left parenthesis if it isn't at the
1676 		     * start of a word (that'll be for variable changes
1677 		     * later) and isn't preceded by a dollar sign (a dynamic
1678 		     * source).
1679 		     */
1680 		    break;
1681 		}
1682 	    }
1683 
1684 	    if (*cp == LPAREN) {
1685 		sources = Lst_Init(FALSE);
1686 		if (Arch_ParseArchive(&line, sources, VAR_CMD) != SUCCESS) {
1687 		    Parse_Error(PARSE_FATAL,
1688 				 "Error in source archive spec \"%s\"", line);
1689 		    goto out;
1690 		}
1691 
1692 		while (!Lst_IsEmpty (sources)) {
1693 		    gn = (GNode *)Lst_DeQueue(sources);
1694 		    ParseDoSrc(tOp, gn->name);
1695 		}
1696 		Lst_Destroy(sources, NULL);
1697 		cp = line;
1698 	    } else {
1699 		if (*cp) {
1700 		    *cp = '\0';
1701 		    cp += 1;
1702 		}
1703 
1704 		ParseDoSrc(tOp, line);
1705 	    }
1706 	    while (*cp && isspace ((unsigned char)*cp)) {
1707 		cp++;
1708 	    }
1709 	    line = cp;
1710 	}
1711     }
1712 
1713     if (mainNode == NULL) {
1714 	/*
1715 	 * If we have yet to decide on a main target to make, in the
1716 	 * absence of any user input, we want the first target on
1717 	 * the first dependency line that is actually a real target
1718 	 * (i.e. isn't a .USE or .EXEC rule) to be made.
1719 	 */
1720 	Lst_ForEach(targets, ParseFindMain, NULL);
1721     }
1722 
1723 out:
1724     if (curTargs)
1725 	    Lst_Destroy(curTargs, NULL);
1726 }
1727 
1728 /*-
1729  *---------------------------------------------------------------------
1730  * Parse_IsVar  --
1731  *	Return TRUE if the passed line is a variable assignment. A variable
1732  *	assignment consists of a single word followed by optional whitespace
1733  *	followed by either a += or an = operator.
1734  *	This function is used both by the Parse_File function and main when
1735  *	parsing the command-line arguments.
1736  *
1737  * Input:
1738  *	line		the line to check
1739  *
1740  * Results:
1741  *	TRUE if it is. FALSE if it ain't
1742  *
1743  * Side Effects:
1744  *	none
1745  *---------------------------------------------------------------------
1746  */
1747 Boolean
1748 Parse_IsVar(char *line)
1749 {
1750     Boolean wasSpace = FALSE;	/* set TRUE if found a space */
1751     char ch;
1752     int level = 0;
1753 #define ISEQOPERATOR(c) \
1754 	(((c) == '+') || ((c) == ':') || ((c) == '?') || ((c) == '!'))
1755 
1756     /*
1757      * Skip to variable name
1758      */
1759     for (;(*line == ' ') || (*line == '\t'); line++)
1760 	continue;
1761 
1762     /* Scan for one of the assignment operators outside a variable expansion */
1763     while ((ch = *line++) != 0) {
1764 	if (ch == '(' || ch == '{') {
1765 	    level++;
1766 	    continue;
1767 	}
1768 	if (ch == ')' || ch == '}') {
1769 	    level--;
1770 	    continue;
1771 	}
1772 	if (level != 0)
1773 	    continue;
1774 	while (ch == ' ' || ch == '\t') {
1775 	    ch = *line++;
1776 	    wasSpace = TRUE;
1777 	}
1778 #ifdef SUNSHCMD
1779 	if (ch == ':' && strncmp(line, "sh", 2) == 0) {
1780 	    line += 2;
1781 	    continue;
1782 	}
1783 #endif
1784 	if (ch == '=')
1785 	    return TRUE;
1786 	if (*line == '=' && ISEQOPERATOR(ch))
1787 	    return TRUE;
1788 	if (wasSpace)
1789 	    return FALSE;
1790     }
1791 
1792     return FALSE;
1793 }
1794 
1795 /*-
1796  *---------------------------------------------------------------------
1797  * Parse_DoVar  --
1798  *	Take the variable assignment in the passed line and do it in the
1799  *	global context.
1800  *
1801  *	Note: There is a lexical ambiguity with assignment modifier characters
1802  *	in variable names. This routine interprets the character before the =
1803  *	as a modifier. Therefore, an assignment like
1804  *	    C++=/usr/bin/CC
1805  *	is interpreted as "C+ +=" instead of "C++ =".
1806  *
1807  * Input:
1808  *	line		a line guaranteed to be a variable assignment.
1809  *			This reduces error checks
1810  *	ctxt		Context in which to do the assignment
1811  *
1812  * Results:
1813  *	none
1814  *
1815  * Side Effects:
1816  *	the variable structure of the given variable name is altered in the
1817  *	global context.
1818  *---------------------------------------------------------------------
1819  */
1820 void
1821 Parse_DoVar(char *line, GNode *ctxt)
1822 {
1823     char	   *cp;	/* pointer into line */
1824     enum {
1825 	VAR_SUBST, VAR_APPEND, VAR_SHELL, VAR_NORMAL
1826     }	    	    type;   	/* Type of assignment */
1827     char            *opc;	/* ptr to operator character to
1828 				 * null-terminate the variable name */
1829     Boolean	   freeCp = FALSE; /* TRUE if cp needs to be freed,
1830 				    * i.e. if any variable expansion was
1831 				    * performed */
1832     int depth;
1833 
1834     /*
1835      * Skip to variable name
1836      */
1837     while ((*line == ' ') || (*line == '\t')) {
1838 	line++;
1839     }
1840 
1841     /*
1842      * Skip to operator character, nulling out whitespace as we go
1843      * XXX Rather than counting () and {} we should look for $ and
1844      * then expand the variable.
1845      */
1846     for (depth = 0, cp = line + 1; depth != 0 || *cp != '='; cp++) {
1847 	if (*cp == '(' || *cp == '{') {
1848 	    depth++;
1849 	    continue;
1850 	}
1851 	if (*cp == ')' || *cp == '}') {
1852 	    depth--;
1853 	    continue;
1854 	}
1855 	if (depth == 0 && isspace ((unsigned char)*cp)) {
1856 	    *cp = '\0';
1857 	}
1858     }
1859     opc = cp-1;		/* operator is the previous character */
1860     *cp++ = '\0';	/* nuke the = */
1861 
1862     /*
1863      * Check operator type
1864      */
1865     switch (*opc) {
1866 	case '+':
1867 	    type = VAR_APPEND;
1868 	    *opc = '\0';
1869 	    break;
1870 
1871 	case '?':
1872 	    /*
1873 	     * If the variable already has a value, we don't do anything.
1874 	     */
1875 	    *opc = '\0';
1876 	    if (Var_Exists(line, ctxt)) {
1877 		return;
1878 	    } else {
1879 		type = VAR_NORMAL;
1880 	    }
1881 	    break;
1882 
1883 	case ':':
1884 	    type = VAR_SUBST;
1885 	    *opc = '\0';
1886 	    break;
1887 
1888 	case '!':
1889 	    type = VAR_SHELL;
1890 	    *opc = '\0';
1891 	    break;
1892 
1893 	default:
1894 #ifdef SUNSHCMD
1895 	    while (opc > line && *opc != ':')
1896 		opc--;
1897 
1898 	    if (strncmp(opc, ":sh", 3) == 0) {
1899 		type = VAR_SHELL;
1900 		*opc = '\0';
1901 		break;
1902 	    }
1903 #endif
1904 	    type = VAR_NORMAL;
1905 	    break;
1906     }
1907 
1908     while (isspace ((unsigned char)*cp)) {
1909 	cp++;
1910     }
1911 
1912     if (type == VAR_APPEND) {
1913 	Var_Append(line, cp, ctxt);
1914     } else if (type == VAR_SUBST) {
1915 	/*
1916 	 * Allow variables in the old value to be undefined, but leave their
1917 	 * invocation alone -- this is done by forcing oldVars to be false.
1918 	 * XXX: This can cause recursive variables, but that's not hard to do,
1919 	 * and this allows someone to do something like
1920 	 *
1921 	 *  CFLAGS = $(.INCLUDES)
1922 	 *  CFLAGS := -I.. $(CFLAGS)
1923 	 *
1924 	 * And not get an error.
1925 	 */
1926 	Boolean	  oldOldVars = oldVars;
1927 
1928 	oldVars = FALSE;
1929 
1930 	/*
1931 	 * make sure that we set the variable the first time to nothing
1932 	 * so that it gets substituted!
1933 	 */
1934 	if (!Var_Exists(line, ctxt))
1935 	    Var_Set(line, "", ctxt, 0);
1936 
1937 	cp = Var_Subst(NULL, cp, ctxt, FALSE, TRUE, TRUE);
1938 	oldVars = oldOldVars;
1939 	freeCp = TRUE;
1940 
1941 	Var_Set(line, cp, ctxt, 0);
1942     } else if (type == VAR_SHELL) {
1943 	char *res;
1944 	const char *error;
1945 
1946 	if (strchr(cp, '$') != NULL) {
1947 	    /*
1948 	     * There's a dollar sign in the command, so perform variable
1949 	     * expansion on the whole thing. The resulting string will need
1950 	     * freeing when we're done, so set freeCmd to TRUE.
1951 	     */
1952 	    cp = Var_Subst(NULL, cp, VAR_CMD, TRUE, TRUE, FALSE);
1953 	    freeCp = TRUE;
1954 	}
1955 
1956 	res = Cmd_Exec(cp, &error);
1957 	Var_Set(line, res, ctxt, 0);
1958 	free(res);
1959 
1960 	if (error)
1961 	    Parse_Error(PARSE_WARNING, error, cp);
1962     } else {
1963 	/*
1964 	 * Normal assignment -- just do it.
1965 	 */
1966 	Var_Set(line, cp, ctxt, 0);
1967     }
1968     if (strcmp(line, MAKEOVERRIDES) == 0)
1969 	Main_ExportMAKEFLAGS(FALSE);	/* re-export MAKEFLAGS */
1970     else if (strcmp(line, ".CURDIR") == 0) {
1971 	/*
1972 	 * Somone is being (too?) clever...
1973 	 * Let's pretend they know what they are doing and
1974 	 * re-initialize the 'cur' Path.
1975 	 */
1976 	Dir_InitCur(cp);
1977 	Dir_SetPATH();
1978     } else if (strcmp(line, MAKE_JOB_PREFIX) == 0) {
1979 	Job_SetPrefix();
1980     } else if (strcmp(line, MAKE_EXPORTED) == 0) {
1981 	Var_Export(cp, 0);
1982     }
1983     if (freeCp)
1984 	free(cp);
1985 }
1986 
1987 
1988 /*
1989  * ParseMaybeSubMake --
1990  * 	Scan the command string to see if it a possible submake node
1991  * Input:
1992  *	cmd		the command to scan
1993  * Results:
1994  *	TRUE if the command is possibly a submake, FALSE if not.
1995  */
1996 static Boolean
1997 ParseMaybeSubMake(const char *cmd)
1998 {
1999     size_t i;
2000     static struct {
2001 	const char *name;
2002 	size_t len;
2003     } vals[] = {
2004 #define MKV(A)	{	A, sizeof(A) - 1	}
2005 	MKV("${MAKE}"),
2006 	MKV("${.MAKE}"),
2007 	MKV("$(MAKE)"),
2008 	MKV("$(.MAKE)"),
2009 	MKV("make"),
2010     };
2011     for (i = 0; i < sizeof(vals)/sizeof(vals[0]); i++) {
2012 	char *ptr;
2013 	if ((ptr = strstr(cmd, vals[i].name)) == NULL)
2014 	    continue;
2015 	if ((ptr == cmd || !isalnum((unsigned char)ptr[-1]))
2016 	    && !isalnum((unsigned char)ptr[vals[i].len]))
2017 	    return TRUE;
2018     }
2019     return FALSE;
2020 }
2021 
2022 /*-
2023  * ParseAddCmd  --
2024  *	Lst_ForEach function to add a command line to all targets
2025  *
2026  * Input:
2027  *	gnp		the node to which the command is to be added
2028  *	cmd		the command to add
2029  *
2030  * Results:
2031  *	Always 0
2032  *
2033  * Side Effects:
2034  *	A new element is added to the commands list of the node,
2035  *	and the node can be marked as a submake node if the command is
2036  *	determined to be that.
2037  */
2038 static int
2039 ParseAddCmd(void *gnp, void *cmd)
2040 {
2041     GNode *gn = (GNode *)gnp;
2042 
2043     /* Add to last (ie current) cohort for :: targets */
2044     if ((gn->type & OP_DOUBLEDEP) && !Lst_IsEmpty (gn->cohorts))
2045 	gn = (GNode *)Lst_Datum(Lst_Last(gn->cohorts));
2046 
2047     /* if target already supplied, ignore commands */
2048     if (!(gn->type & OP_HAS_COMMANDS)) {
2049 	(void)Lst_AtEnd(gn->commands, cmd);
2050 	if (ParseMaybeSubMake(cmd))
2051 	    gn->type |= OP_SUBMAKE;
2052 	ParseMark(gn);
2053     } else {
2054 #ifdef notyet
2055 	/* XXX: We cannot do this until we fix the tree */
2056 	(void)Lst_AtEnd(gn->commands, cmd);
2057 	Parse_Error(PARSE_WARNING,
2058 		     "overriding commands for target \"%s\"; "
2059 		     "previous commands defined at %s: %d ignored",
2060 		     gn->name, gn->fname, gn->lineno);
2061 #else
2062 	Parse_Error(PARSE_WARNING,
2063 		     "duplicate script for target \"%s\" ignored",
2064 		     gn->name);
2065 	ParseErrorInternal(gn->fname, gn->lineno, PARSE_WARNING,
2066 			    "using previous script for \"%s\" defined here",
2067 			    gn->name);
2068 #endif
2069     }
2070     return(0);
2071 }
2072 
2073 /*-
2074  *-----------------------------------------------------------------------
2075  * ParseHasCommands --
2076  *	Callback procedure for Parse_File when destroying the list of
2077  *	targets on the last dependency line. Marks a target as already
2078  *	having commands if it does, to keep from having shell commands
2079  *	on multiple dependency lines.
2080  *
2081  * Input:
2082  *	gnp		Node to examine
2083  *
2084  * Results:
2085  *	None
2086  *
2087  * Side Effects:
2088  *	OP_HAS_COMMANDS may be set for the target.
2089  *
2090  *-----------------------------------------------------------------------
2091  */
2092 static void
2093 ParseHasCommands(void *gnp)
2094 {
2095     GNode *gn = (GNode *)gnp;
2096     if (!Lst_IsEmpty(gn->commands)) {
2097 	gn->type |= OP_HAS_COMMANDS;
2098     }
2099 }
2100 
2101 /*-
2102  *-----------------------------------------------------------------------
2103  * Parse_AddIncludeDir --
2104  *	Add a directory to the path searched for included makefiles
2105  *	bracketed by double-quotes. Used by functions in main.c
2106  *
2107  * Input:
2108  *	dir		The name of the directory to add
2109  *
2110  * Results:
2111  *	None.
2112  *
2113  * Side Effects:
2114  *	The directory is appended to the list.
2115  *
2116  *-----------------------------------------------------------------------
2117  */
2118 void
2119 Parse_AddIncludeDir(char *dir)
2120 {
2121     (void)Dir_AddDir(parseIncPath, dir);
2122 }
2123 
2124 /*-
2125  *---------------------------------------------------------------------
2126  * ParseDoInclude  --
2127  *	Push to another file.
2128  *
2129  *	The input is the line minus the `.'. A file spec is a string
2130  *	enclosed in <> or "". The former is looked for only in sysIncPath.
2131  *	The latter in . and the directories specified by -I command line
2132  *	options
2133  *
2134  * Results:
2135  *	None
2136  *
2137  * Side Effects:
2138  *	A structure is added to the includes Lst and readProc, lineno,
2139  *	fname and curFILE are altered for the new file
2140  *---------------------------------------------------------------------
2141  */
2142 
2143 static void
2144 Parse_include_file(char *file, Boolean isSystem, int silent)
2145 {
2146     struct loadedfile *lf;
2147     char          *fullname;	/* full pathname of file */
2148     char          *newName;
2149     char          *prefEnd, *incdir;
2150     int           fd;
2151     int           i;
2152 
2153     /*
2154      * Now we know the file's name and its search path, we attempt to
2155      * find the durn thing. A return of NULL indicates the file don't
2156      * exist.
2157      */
2158     fullname = file[0] == '/' ? bmake_strdup(file) : NULL;
2159 
2160     if (fullname == NULL && !isSystem) {
2161 	/*
2162 	 * Include files contained in double-quotes are first searched for
2163 	 * relative to the including file's location. We don't want to
2164 	 * cd there, of course, so we just tack on the old file's
2165 	 * leading path components and call Dir_FindFile to see if
2166 	 * we can locate the beast.
2167 	 */
2168 
2169 	incdir = bmake_strdup(curFile->fname);
2170 	prefEnd = strrchr(incdir, '/');
2171 	if (prefEnd != NULL) {
2172 	    *prefEnd = '\0';
2173 	    /* Now do lexical processing of leading "../" on the filename */
2174 	    for (i = 0; strncmp(file + i, "../", 3) == 0; i += 3) {
2175 		prefEnd = strrchr(incdir + 1, '/');
2176 		if (prefEnd == NULL || strcmp(prefEnd, "/..") == 0)
2177 		    break;
2178 		*prefEnd = '\0';
2179 	    }
2180 	    newName = str_concat(incdir, file + i, STR_ADDSLASH);
2181 	    fullname = Dir_FindFile(newName, parseIncPath);
2182 	    if (fullname == NULL)
2183 		fullname = Dir_FindFile(newName, dirSearchPath);
2184 	    free(newName);
2185 	}
2186 	free(incdir);
2187 
2188 	if (fullname == NULL) {
2189 	    /*
2190     	     * Makefile wasn't found in same directory as included makefile.
2191 	     * Search for it first on the -I search path,
2192 	     * then on the .PATH search path, if not found in a -I directory.
2193 	     * If we have a suffix specific path we should use that.
2194 	     */
2195 	    char *suff;
2196 	    Lst	suffPath = NULL;
2197 
2198 	    if ((suff = strrchr(file, '.'))) {
2199 		suffPath = Suff_GetPath(suff);
2200 		if (suffPath != NULL) {
2201 		    fullname = Dir_FindFile(file, suffPath);
2202 		}
2203 	    }
2204 	    if (fullname == NULL) {
2205 		fullname = Dir_FindFile(file, parseIncPath);
2206 		if (fullname == NULL) {
2207 		    fullname = Dir_FindFile(file, dirSearchPath);
2208 		}
2209 	    }
2210 	}
2211     }
2212 
2213     /* Looking for a system file or file still not found */
2214     if (fullname == NULL) {
2215 	/*
2216 	 * Look for it on the system path
2217 	 */
2218 	fullname = Dir_FindFile(file,
2219 		    Lst_IsEmpty(sysIncPath) ? defIncPath : sysIncPath);
2220     }
2221 
2222     if (fullname == NULL) {
2223 	if (!silent)
2224 	    Parse_Error(PARSE_FATAL, "Could not find %s", file);
2225 	return;
2226     }
2227 
2228     /* Actually open the file... */
2229     fd = open(fullname, O_RDONLY);
2230     if (fd == -1) {
2231 	if (!silent)
2232 	    Parse_Error(PARSE_FATAL, "Cannot open %s", fullname);
2233 	free(fullname);
2234 	return;
2235     }
2236 
2237     /* load it */
2238     lf = loadfile(fullname, fd);
2239 
2240     ParseSetIncludedFile();
2241     /* Start reading from this file next */
2242     Parse_SetInput(fullname, 0, -1, loadedfile_nextbuf, lf);
2243     curFile->lf = lf;
2244 }
2245 
2246 static void
2247 ParseDoInclude(char *line)
2248 {
2249     char          endc;	    	/* the character which ends the file spec */
2250     char          *cp;		/* current position in file spec */
2251     int		  silent = (*line != 'i') ? 1 : 0;
2252     char	  *file = &line[7 + silent];
2253 
2254     /* Skip to delimiter character so we know where to look */
2255     while (*file == ' ' || *file == '\t')
2256 	file++;
2257 
2258     if (*file != '"' && *file != '<') {
2259 	Parse_Error(PARSE_FATAL,
2260 	    ".include filename must be delimited by '\"' or '<'");
2261 	return;
2262     }
2263 
2264     /*
2265      * Set the search path on which to find the include file based on the
2266      * characters which bracket its name. Angle-brackets imply it's
2267      * a system Makefile while double-quotes imply it's a user makefile
2268      */
2269     if (*file == '<') {
2270 	endc = '>';
2271     } else {
2272 	endc = '"';
2273     }
2274 
2275     /* Skip to matching delimiter */
2276     for (cp = ++file; *cp && *cp != endc; cp++)
2277 	continue;
2278 
2279     if (*cp != endc) {
2280 	Parse_Error(PARSE_FATAL,
2281 		     "Unclosed %cinclude filename. '%c' expected",
2282 		     '.', endc);
2283 	return;
2284     }
2285     *cp = '\0';
2286 
2287     /*
2288      * Substitute for any variables in the file name before trying to
2289      * find the thing.
2290      */
2291     file = Var_Subst(NULL, file, VAR_CMD, FALSE, TRUE, FALSE);
2292 
2293     Parse_include_file(file, endc == '>', silent);
2294     free(file);
2295 }
2296 
2297 
2298 /*-
2299  *---------------------------------------------------------------------
2300  * ParseSetIncludedFile  --
2301  *	Set the .INCLUDEDFROMFILE variable to the contents of .PARSEFILE
2302  *	and the .INCLUDEDFROMDIR variable to the contents of .PARSEDIR
2303  *
2304  * Results:
2305  *	None
2306  *
2307  * Side Effects:
2308  *	The .INCLUDEDFROMFILE variable is overwritten by the contents
2309  *	of .PARSEFILE and the .INCLUDEDFROMDIR variable is overwriten
2310  *	by the contents of .PARSEDIR
2311  *---------------------------------------------------------------------
2312  */
2313 static void
2314 ParseSetIncludedFile(void)
2315 {
2316     char *pf, *fp = NULL;
2317     char *pd, *dp = NULL;
2318 
2319     pf = Var_Value(".PARSEFILE", VAR_GLOBAL, &fp);
2320     Var_Set(".INCLUDEDFROMFILE", pf, VAR_GLOBAL, 0);
2321     pd = Var_Value(".PARSEDIR", VAR_GLOBAL, &dp);
2322     Var_Set(".INCLUDEDFROMDIR", pd, VAR_GLOBAL, 0);
2323 
2324     if (DEBUG(PARSE))
2325 	fprintf(debug_file, "%s: ${.INCLUDEDFROMDIR} = `%s' "
2326 	    "${.INCLUDEDFROMFILE} = `%s'\n", __func__, pd, pf);
2327 
2328     if (fp)
2329 	free(fp);
2330     if (dp)
2331 	free(dp);
2332 }
2333 /*-
2334  *---------------------------------------------------------------------
2335  * ParseSetParseFile  --
2336  *	Set the .PARSEDIR and .PARSEFILE variables to the dirname and
2337  *	basename of the given filename
2338  *
2339  * Results:
2340  *	None
2341  *
2342  * Side Effects:
2343  *	The .PARSEDIR and .PARSEFILE variables are overwritten by the
2344  *	dirname and basename of the given filename.
2345  *---------------------------------------------------------------------
2346  */
2347 static void
2348 ParseSetParseFile(const char *filename)
2349 {
2350     char *slash, *dirname;
2351     const char *pd, *pf;
2352     int len;
2353 
2354     slash = strrchr(filename, '/');
2355     if (slash == NULL) {
2356 	Var_Set(".PARSEDIR", pd = curdir, VAR_GLOBAL, 0);
2357 	Var_Set(".PARSEFILE", pf = filename, VAR_GLOBAL, 0);
2358 	dirname= NULL;
2359     } else {
2360 	len = slash - filename;
2361 	dirname = bmake_malloc(len + 1);
2362 	memcpy(dirname, filename, len);
2363 	dirname[len] = '\0';
2364 	Var_Set(".PARSEDIR", pd = dirname, VAR_GLOBAL, 0);
2365 	Var_Set(".PARSEFILE", pf = slash + 1, VAR_GLOBAL, 0);
2366     }
2367     if (DEBUG(PARSE))
2368 	fprintf(debug_file, "%s: ${.PARSEDIR} = `%s' ${.PARSEFILE} = `%s'\n",
2369 	    __func__, pd, pf);
2370     free(dirname);
2371 }
2372 
2373 /*
2374  * Track the makefiles we read - so makefiles can
2375  * set dependencies on them.
2376  * Avoid adding anything more than once.
2377  */
2378 
2379 static void
2380 ParseTrackInput(const char *name)
2381 {
2382     char *old;
2383     char *ep;
2384     char *fp = NULL;
2385     size_t name_len = strlen(name);
2386 
2387     old = Var_Value(MAKE_MAKEFILES, VAR_GLOBAL, &fp);
2388     if (old) {
2389 	ep = old + strlen(old) - name_len;
2390 	/* does it contain name? */
2391 	for (; old != NULL; old = strchr(old, ' ')) {
2392 	    if (*old == ' ')
2393 		old++;
2394 	    if (old >= ep)
2395 		break;			/* cannot contain name */
2396 	    if (memcmp(old, name, name_len) == 0
2397 		    && (old[name_len] == 0 || old[name_len] == ' '))
2398 		goto cleanup;
2399 	}
2400     }
2401     Var_Append (MAKE_MAKEFILES, name, VAR_GLOBAL);
2402  cleanup:
2403     if (fp) {
2404 	free(fp);
2405     }
2406 }
2407 
2408 
2409 /*-
2410  *---------------------------------------------------------------------
2411  * Parse_setInput  --
2412  *	Start Parsing from the given source
2413  *
2414  * Results:
2415  *	None
2416  *
2417  * Side Effects:
2418  *	A structure is added to the includes Lst and readProc, lineno,
2419  *	fname and curFile are altered for the new file
2420  *---------------------------------------------------------------------
2421  */
2422 void
2423 Parse_SetInput(const char *name, int line, int fd,
2424 	char *(*nextbuf)(void *, size_t *), void *arg)
2425 {
2426     char *buf;
2427     size_t len;
2428 
2429     if (name == NULL)
2430 	name = curFile->fname;
2431     else
2432 	ParseTrackInput(name);
2433 
2434     if (DEBUG(PARSE))
2435 	fprintf(debug_file, "%s: file %s, line %d, fd %d, nextbuf %p, arg %p\n",
2436 	    __func__, name, line, fd, nextbuf, arg);
2437 
2438     if (fd == -1 && nextbuf == NULL)
2439 	/* sanity */
2440 	return;
2441 
2442     if (curFile != NULL)
2443 	/* Save exiting file info */
2444 	Lst_AtFront(includes, curFile);
2445 
2446     /* Allocate and fill in new structure */
2447     curFile = bmake_malloc(sizeof *curFile);
2448 
2449     /*
2450      * Once the previous state has been saved, we can get down to reading
2451      * the new file. We set up the name of the file to be the absolute
2452      * name of the include file so error messages refer to the right
2453      * place.
2454      */
2455     curFile->fname = bmake_strdup(name);
2456     curFile->lineno = line;
2457     curFile->first_lineno = line;
2458     curFile->nextbuf = nextbuf;
2459     curFile->nextbuf_arg = arg;
2460     curFile->lf = NULL;
2461 
2462     assert(nextbuf != NULL);
2463 
2464     /* Get first block of input data */
2465     buf = curFile->nextbuf(curFile->nextbuf_arg, &len);
2466     if (buf == NULL) {
2467         /* Was all a waste of time ... */
2468 	if (curFile->fname)
2469 	    free(curFile->fname);
2470 	free(curFile);
2471 	return;
2472     }
2473     curFile->P_str = buf;
2474     curFile->P_ptr = buf;
2475     curFile->P_end = buf+len;
2476 
2477     curFile->cond_depth = Cond_save_depth();
2478     ParseSetParseFile(name);
2479 }
2480 
2481 #ifdef SYSVINCLUDE
2482 /*-
2483  *---------------------------------------------------------------------
2484  * ParseTraditionalInclude  --
2485  *	Push to another file.
2486  *
2487  *	The input is the current line. The file name(s) are
2488  *	following the "include".
2489  *
2490  * Results:
2491  *	None
2492  *
2493  * Side Effects:
2494  *	A structure is added to the includes Lst and readProc, lineno,
2495  *	fname and curFILE are altered for the new file
2496  *---------------------------------------------------------------------
2497  */
2498 static void
2499 ParseTraditionalInclude(char *line)
2500 {
2501     char          *cp;		/* current position in file spec */
2502     int		   done = 0;
2503     int		   silent = (line[0] != 'i') ? 1 : 0;
2504     char	  *file = &line[silent + 7];
2505     char	  *all_files;
2506 
2507     if (DEBUG(PARSE)) {
2508 	    fprintf(debug_file, "%s: %s\n", __func__, file);
2509     }
2510 
2511     /*
2512      * Skip over whitespace
2513      */
2514     while (isspace((unsigned char)*file))
2515 	file++;
2516 
2517     /*
2518      * Substitute for any variables in the file name before trying to
2519      * find the thing.
2520      */
2521     all_files = Var_Subst(NULL, file, VAR_CMD, FALSE, TRUE, FALSE);
2522 
2523     if (*file == '\0') {
2524 	Parse_Error(PARSE_FATAL,
2525 		     "Filename missing from \"include\"");
2526 	return;
2527     }
2528 
2529     for (file = all_files; !done; file = cp + 1) {
2530 	/* Skip to end of line or next whitespace */
2531 	for (cp = file; *cp && !isspace((unsigned char) *cp); cp++)
2532 	    continue;
2533 
2534 	if (*cp)
2535 	    *cp = '\0';
2536 	else
2537 	    done = 1;
2538 
2539 	Parse_include_file(file, FALSE, silent);
2540     }
2541     free(all_files);
2542 }
2543 #endif
2544 
2545 #ifdef GMAKEEXPORT
2546 /*-
2547  *---------------------------------------------------------------------
2548  * ParseGmakeExport  --
2549  *	Parse export <variable>=<value>
2550  *
2551  *	And set the environment with it.
2552  *
2553  * Results:
2554  *	None
2555  *
2556  * Side Effects:
2557  *	None
2558  *---------------------------------------------------------------------
2559  */
2560 static void
2561 ParseGmakeExport(char *line)
2562 {
2563     char	  *variable = &line[6];
2564     char	  *value;
2565 
2566     if (DEBUG(PARSE)) {
2567 	    fprintf(debug_file, "%s: %s\n", __func__, variable);
2568     }
2569 
2570     /*
2571      * Skip over whitespace
2572      */
2573     while (isspace((unsigned char)*variable))
2574 	variable++;
2575 
2576     for (value = variable; *value && *value != '='; value++)
2577 	continue;
2578 
2579     if (*value != '=') {
2580 	Parse_Error(PARSE_FATAL,
2581 		     "Variable/Value missing from \"export\"");
2582 	return;
2583     }
2584     *value++ = '\0';			/* terminate variable */
2585 
2586     /*
2587      * Expand the value before putting it in the environment.
2588      */
2589     value = Var_Subst(NULL, value, VAR_CMD, FALSE, TRUE, FALSE);
2590     setenv(variable, value, 1);
2591 }
2592 #endif
2593 
2594 /*-
2595  *---------------------------------------------------------------------
2596  * ParseEOF  --
2597  *	Called when EOF is reached in the current file. If we were reading
2598  *	an include file, the includes stack is popped and things set up
2599  *	to go back to reading the previous file at the previous location.
2600  *
2601  * Results:
2602  *	CONTINUE if there's more to do. DONE if not.
2603  *
2604  * Side Effects:
2605  *	The old curFILE, is closed. The includes list is shortened.
2606  *	lineno, curFILE, and fname are changed if CONTINUE is returned.
2607  *---------------------------------------------------------------------
2608  */
2609 static int
2610 ParseEOF(void)
2611 {
2612     char *ptr;
2613     size_t len;
2614 
2615     assert(curFile->nextbuf != NULL);
2616 
2617     /* get next input buffer, if any */
2618     ptr = curFile->nextbuf(curFile->nextbuf_arg, &len);
2619     curFile->P_ptr = ptr;
2620     curFile->P_str = ptr;
2621     curFile->P_end = ptr + len;
2622     curFile->lineno = curFile->first_lineno;
2623     if (ptr != NULL) {
2624 	/* Iterate again */
2625 	return CONTINUE;
2626     }
2627 
2628     /* Ensure the makefile (or loop) didn't have mismatched conditionals */
2629     Cond_restore_depth(curFile->cond_depth);
2630 
2631     if (curFile->lf != NULL) {
2632 	    loadedfile_destroy(curFile->lf);
2633 	    curFile->lf = NULL;
2634     }
2635 
2636     /* Dispose of curFile info */
2637     /* Leak curFile->fname because all the gnodes have pointers to it */
2638     free(curFile->P_str);
2639     free(curFile);
2640 
2641     curFile = Lst_DeQueue(includes);
2642 
2643     if (curFile == NULL) {
2644 	/* We've run out of input */
2645 	Var_Delete(".PARSEDIR", VAR_GLOBAL);
2646 	Var_Delete(".PARSEFILE", VAR_GLOBAL);
2647 	Var_Delete(".INCLUDEDFROMDIR", VAR_GLOBAL);
2648 	Var_Delete(".INCLUDEDFROMFILE", VAR_GLOBAL);
2649 	return DONE;
2650     }
2651 
2652     if (DEBUG(PARSE))
2653 	fprintf(debug_file, "ParseEOF: returning to file %s, line %d\n",
2654 	    curFile->fname, curFile->lineno);
2655 
2656     /* Restore the PARSEDIR/PARSEFILE variables */
2657     ParseSetParseFile(curFile->fname);
2658     return (CONTINUE);
2659 }
2660 
2661 #define PARSE_RAW 1
2662 #define PARSE_SKIP 2
2663 
2664 static char *
2665 ParseGetLine(int flags, int *length)
2666 {
2667     IFile *cf = curFile;
2668     char *ptr;
2669     char ch;
2670     char *line;
2671     char *line_end;
2672     char *escaped;
2673     char *comment;
2674     char *tp;
2675 
2676     /* Loop through blank lines and comment lines */
2677     for (;;) {
2678 	cf->lineno++;
2679 	line = cf->P_ptr;
2680 	ptr = line;
2681 	line_end = line;
2682 	escaped = NULL;
2683 	comment = NULL;
2684 	for (;;) {
2685 	    if (cf->P_end != NULL && ptr == cf->P_end) {
2686 		/* end of buffer */
2687 		ch = 0;
2688 		break;
2689 	    }
2690 	    ch = *ptr;
2691 	    if (ch == 0 || (ch == '\\' && ptr[1] == 0)) {
2692 		if (cf->P_end == NULL)
2693 		    /* End of string (aka for loop) data */
2694 		    break;
2695 		/* see if there is more we can parse */
2696 		while (ptr++ < cf->P_end) {
2697 		    if ((ch = *ptr) == '\n') {
2698 			if (ptr > line && ptr[-1] == '\\')
2699 			    continue;
2700 			Parse_Error(PARSE_WARNING,
2701 			    "Zero byte read from file, skipping rest of line.");
2702 			break;
2703 		    }
2704 		}
2705 		if (cf->nextbuf != NULL) {
2706 		    /*
2707 		     * End of this buffer; return EOF and outer logic
2708 		     * will get the next one. (eww)
2709 		     */
2710 		    break;
2711 		}
2712 		Parse_Error(PARSE_FATAL, "Zero byte read from file");
2713 		return NULL;
2714 	    }
2715 
2716 	    if (ch == '\\') {
2717 		/* Don't treat next character as special, remember first one */
2718 		if (escaped == NULL)
2719 		    escaped = ptr;
2720 		if (ptr[1] == '\n')
2721 		    cf->lineno++;
2722 		ptr += 2;
2723 		line_end = ptr;
2724 		continue;
2725 	    }
2726 	    if (ch == '#' && comment == NULL) {
2727 		/* Remember first '#' for comment stripping */
2728 		/* Unless previous char was '[', as in modifier :[#] */
2729 		if (!(ptr > line && ptr[-1] == '['))
2730 		    comment = line_end;
2731 	    }
2732 	    ptr++;
2733 	    if (ch == '\n')
2734 		break;
2735 	    if (!isspace((unsigned char)ch))
2736 		/* We are not interested in trailing whitespace */
2737 		line_end = ptr;
2738 	}
2739 
2740 	/* Save next 'to be processed' location */
2741 	cf->P_ptr = ptr;
2742 
2743 	/* Check we have a non-comment, non-blank line */
2744 	if (line_end == line || comment == line) {
2745 	    if (ch == 0)
2746 		/* At end of file */
2747 		return NULL;
2748 	    /* Parse another line */
2749 	    continue;
2750 	}
2751 
2752 	/* We now have a line of data */
2753 	*line_end = 0;
2754 
2755 	if (flags & PARSE_RAW) {
2756 	    /* Leave '\' (etc) in line buffer (eg 'for' lines) */
2757 	    *length = line_end - line;
2758 	    return line;
2759 	}
2760 
2761 	if (flags & PARSE_SKIP) {
2762 	    /* Completely ignore non-directives */
2763 	    if (line[0] != '.')
2764 		continue;
2765 	    /* We could do more of the .else/.elif/.endif checks here */
2766 	}
2767 	break;
2768     }
2769 
2770     /* Brutally ignore anything after a non-escaped '#' in non-commands */
2771     if (comment != NULL && line[0] != '\t') {
2772 	line_end = comment;
2773 	*line_end = 0;
2774     }
2775 
2776     /* If we didn't see a '\\' then the in-situ data is fine */
2777     if (escaped == NULL) {
2778 	*length = line_end - line;
2779 	return line;
2780     }
2781 
2782     /* Remove escapes from '\n' and '#' */
2783     tp = ptr = escaped;
2784     escaped = line;
2785     for (; ; *tp++ = ch) {
2786 	ch = *ptr++;
2787 	if (ch != '\\') {
2788 	    if (ch == 0)
2789 		break;
2790 	    continue;
2791 	}
2792 
2793 	ch = *ptr++;
2794 	if (ch == 0) {
2795 	    /* Delete '\\' at end of buffer */
2796 	    tp--;
2797 	    break;
2798 	}
2799 
2800 	if (ch == '#' && line[0] != '\t')
2801 	    /* Delete '\\' from before '#' on non-command lines */
2802 	    continue;
2803 
2804 	if (ch != '\n') {
2805 	    /* Leave '\\' in buffer for later */
2806 	    *tp++ = '\\';
2807 	    /* Make sure we don't delete an escaped ' ' from the line end */
2808 	    escaped = tp + 1;
2809 	    continue;
2810 	}
2811 
2812 	/* Escaped '\n' replace following whitespace with a single ' ' */
2813 	while (ptr[0] == ' ' || ptr[0] == '\t')
2814 	    ptr++;
2815 	ch = ' ';
2816     }
2817 
2818     /* Delete any trailing spaces - eg from empty continuations */
2819     while (tp > escaped && isspace((unsigned char)tp[-1]))
2820 	tp--;
2821 
2822     *tp = 0;
2823     *length = tp - line;
2824     return line;
2825 }
2826 
2827 /*-
2828  *---------------------------------------------------------------------
2829  * ParseReadLine --
2830  *	Read an entire line from the input file. Called only by Parse_File.
2831  *
2832  * Results:
2833  *	A line w/o its newline
2834  *
2835  * Side Effects:
2836  *	Only those associated with reading a character
2837  *---------------------------------------------------------------------
2838  */
2839 static char *
2840 ParseReadLine(void)
2841 {
2842     char 	  *line;    	/* Result */
2843     int	    	  lineLength;	/* Length of result */
2844     int	    	  lineno;	/* Saved line # */
2845     int	    	  rval;
2846 
2847     for (;;) {
2848 	line = ParseGetLine(0, &lineLength);
2849 	if (line == NULL)
2850 	    return NULL;
2851 
2852 	if (line[0] != '.')
2853 	    return line;
2854 
2855 	/*
2856 	 * The line might be a conditional. Ask the conditional module
2857 	 * about it and act accordingly
2858 	 */
2859 	switch (Cond_Eval(line)) {
2860 	case COND_SKIP:
2861 	    /* Skip to next conditional that evaluates to COND_PARSE.  */
2862 	    do {
2863 		line = ParseGetLine(PARSE_SKIP, &lineLength);
2864 	    } while (line && Cond_Eval(line) != COND_PARSE);
2865 	    if (line == NULL)
2866 		break;
2867 	    continue;
2868 	case COND_PARSE:
2869 	    continue;
2870 	case COND_INVALID:    /* Not a conditional line */
2871 	    /* Check for .for loops */
2872 	    rval = For_Eval(line);
2873 	    if (rval == 0)
2874 		/* Not a .for line */
2875 		break;
2876 	    if (rval < 0)
2877 		/* Syntax error - error printed, ignore line */
2878 		continue;
2879 	    /* Start of a .for loop */
2880 	    lineno = curFile->lineno;
2881 	    /* Accumulate loop lines until matching .endfor */
2882 	    do {
2883 		line = ParseGetLine(PARSE_RAW, &lineLength);
2884 		if (line == NULL) {
2885 		    Parse_Error(PARSE_FATAL,
2886 			     "Unexpected end of file in for loop.");
2887 		    break;
2888 		}
2889 	    } while (For_Accum(line));
2890 	    /* Stash each iteration as a new 'input file' */
2891 	    For_Run(lineno);
2892 	    /* Read next line from for-loop buffer */
2893 	    continue;
2894 	}
2895 	return (line);
2896     }
2897 }
2898 
2899 /*-
2900  *-----------------------------------------------------------------------
2901  * ParseFinishLine --
2902  *	Handle the end of a dependency group.
2903  *
2904  * Results:
2905  *	Nothing.
2906  *
2907  * Side Effects:
2908  *	inLine set FALSE. 'targets' list destroyed.
2909  *
2910  *-----------------------------------------------------------------------
2911  */
2912 static void
2913 ParseFinishLine(void)
2914 {
2915     if (inLine) {
2916 	Lst_ForEach(targets, Suff_EndTransform, NULL);
2917 	Lst_Destroy(targets, ParseHasCommands);
2918 	targets = NULL;
2919 	inLine = FALSE;
2920     }
2921 }
2922 
2923 
2924 /*-
2925  *---------------------------------------------------------------------
2926  * Parse_File --
2927  *	Parse a file into its component parts, incorporating it into the
2928  *	current dependency graph. This is the main function and controls
2929  *	almost every other function in this module
2930  *
2931  * Input:
2932  *	name		the name of the file being read
2933  *	fd		Open file to makefile to parse
2934  *
2935  * Results:
2936  *	None
2937  *
2938  * Side Effects:
2939  *	closes fd.
2940  *	Loads. Nodes are added to the list of all targets, nodes and links
2941  *	are added to the dependency graph. etc. etc. etc.
2942  *---------------------------------------------------------------------
2943  */
2944 void
2945 Parse_File(const char *name, int fd)
2946 {
2947     char	  *cp;		/* pointer into the line */
2948     char          *line;	/* the line we're working on */
2949     struct loadedfile *lf;
2950 
2951     lf = loadfile(name, fd);
2952 
2953     inLine = FALSE;
2954     fatals = 0;
2955 
2956     if (name == NULL) {
2957 	    name = "(stdin)";
2958     }
2959 
2960     Parse_SetInput(name, 0, -1, loadedfile_nextbuf, lf);
2961     curFile->lf = lf;
2962 
2963     do {
2964 	for (; (line = ParseReadLine()) != NULL; ) {
2965 	    if (DEBUG(PARSE))
2966 		fprintf(debug_file, "ParseReadLine (%d): '%s'\n",
2967 			curFile->lineno, line);
2968 	    if (*line == '.') {
2969 		/*
2970 		 * Lines that begin with the special character may be
2971 		 * include or undef directives.
2972 		 * On the other hand they can be suffix rules (.c.o: ...)
2973 		 * or just dependencies for filenames that start '.'.
2974 		 */
2975 		for (cp = line + 1; isspace((unsigned char)*cp); cp++) {
2976 		    continue;
2977 		}
2978 		if (strncmp(cp, "include", 7) == 0 ||
2979 			((cp[0] == 's' || cp[0] == '-') &&
2980 			    strncmp(&cp[1], "include", 7) == 0)) {
2981 		    ParseDoInclude(cp);
2982 		    continue;
2983 		}
2984 		if (strncmp(cp, "undef", 5) == 0) {
2985 		    char *cp2;
2986 		    for (cp += 5; isspace((unsigned char) *cp); cp++)
2987 			continue;
2988 		    for (cp2 = cp; !isspace((unsigned char) *cp2) &&
2989 				   (*cp2 != '\0'); cp2++)
2990 			continue;
2991 		    *cp2 = '\0';
2992 		    Var_Delete(cp, VAR_GLOBAL);
2993 		    continue;
2994 		} else if (strncmp(cp, "export", 6) == 0) {
2995 		    for (cp += 6; isspace((unsigned char) *cp); cp++)
2996 			continue;
2997 		    Var_Export(cp, 1);
2998 		    continue;
2999 		} else if (strncmp(cp, "unexport", 8) == 0) {
3000 		    Var_UnExport(cp);
3001 		    continue;
3002 		} else if (strncmp(cp, "info", 4) == 0 ||
3003 			   strncmp(cp, "error", 5) == 0 ||
3004 			   strncmp(cp, "warning", 7) == 0) {
3005 		    if (ParseMessage(cp))
3006 			continue;
3007 		}
3008 	    }
3009 
3010 	    if (*line == '\t') {
3011 		/*
3012 		 * If a line starts with a tab, it can only hope to be
3013 		 * a creation command.
3014 		 */
3015 		cp = line + 1;
3016 	      shellCommand:
3017 		for (; isspace ((unsigned char)*cp); cp++) {
3018 		    continue;
3019 		}
3020 		if (*cp) {
3021 		    if (!inLine)
3022 			Parse_Error(PARSE_FATAL,
3023 				     "Unassociated shell command \"%s\"",
3024 				     cp);
3025 		    /*
3026 		     * So long as it's not a blank line and we're actually
3027 		     * in a dependency spec, add the command to the list of
3028 		     * commands of all targets in the dependency spec
3029 		     */
3030 		    if (targets) {
3031 			cp = bmake_strdup(cp);
3032 			Lst_ForEach(targets, ParseAddCmd, cp);
3033 #ifdef CLEANUP
3034 			Lst_AtEnd(targCmds, cp);
3035 #endif
3036 		    }
3037 		}
3038 		continue;
3039 	    }
3040 
3041 #ifdef SYSVINCLUDE
3042 	    if (((strncmp(line, "include", 7) == 0 &&
3043 		    isspace((unsigned char) line[7])) ||
3044 			((line[0] == 's' || line[0] == '-') &&
3045 			    strncmp(&line[1], "include", 7) == 0 &&
3046 			    isspace((unsigned char) line[8]))) &&
3047 		    strchr(line, ':') == NULL) {
3048 		/*
3049 		 * It's an S3/S5-style "include".
3050 		 */
3051 		ParseTraditionalInclude(line);
3052 		continue;
3053 	    }
3054 #endif
3055 #ifdef GMAKEEXPORT
3056 	    if (strncmp(line, "export", 6) == 0 &&
3057 		isspace((unsigned char) line[6]) &&
3058 		strchr(line, ':') == NULL) {
3059 		/*
3060 		 * It's a Gmake "export".
3061 		 */
3062 		ParseGmakeExport(line);
3063 		continue;
3064 	    }
3065 #endif
3066 	    if (Parse_IsVar(line)) {
3067 		ParseFinishLine();
3068 		Parse_DoVar(line, VAR_GLOBAL);
3069 		continue;
3070 	    }
3071 
3072 #ifndef POSIX
3073 	    /*
3074 	     * To make life easier on novices, if the line is indented we
3075 	     * first make sure the line has a dependency operator in it.
3076 	     * If it doesn't have an operator and we're in a dependency
3077 	     * line's script, we assume it's actually a shell command
3078 	     * and add it to the current list of targets.
3079 	     */
3080 	    cp = line;
3081 	    if (isspace((unsigned char) line[0])) {
3082 		while ((*cp != '\0') && isspace((unsigned char) *cp))
3083 		    cp++;
3084 		while (*cp && (ParseIsEscaped(line, cp) ||
3085 			(*cp != ':') && (*cp != '!'))) {
3086 		    cp++;
3087 		}
3088 		if (*cp == '\0') {
3089 		    if (inLine) {
3090 			Parse_Error(PARSE_WARNING,
3091 				     "Shell command needs a leading tab");
3092 			goto shellCommand;
3093 		    }
3094 		}
3095 	    }
3096 #endif
3097 	    ParseFinishLine();
3098 
3099 	    /*
3100 	     * For some reason - probably to make the parser impossible -
3101 	     * a ';' can be used to separate commands from dependencies.
3102 	     * Attempt to avoid ';' inside substitution patterns.
3103 	     */
3104 	    {
3105 		int level = 0;
3106 
3107 		for (cp = line; *cp != 0; cp++) {
3108 		    if (*cp == '\\' && cp[1] != 0) {
3109 			cp++;
3110 			continue;
3111 		    }
3112 		    if (*cp == '$' &&
3113 			(cp[1] == '(' || cp[1] == '{')) {
3114 			level++;
3115 			continue;
3116 		    }
3117 		    if (level > 0) {
3118 			if (*cp == ')' || *cp == '}') {
3119 			    level--;
3120 			    continue;
3121 			}
3122 		    } else if (*cp == ';') {
3123 			break;
3124 		    }
3125 		}
3126 	    }
3127 	    if (*cp != 0)
3128 		/* Terminate the dependency list at the ';' */
3129 		*cp++ = 0;
3130 	    else
3131 		cp = NULL;
3132 
3133 	    /*
3134 	     * We now know it's a dependency line so it needs to have all
3135 	     * variables expanded before being parsed. Tell the variable
3136 	     * module to complain if some variable is undefined...
3137 	     */
3138 	    line = Var_Subst(NULL, line, VAR_CMD, TRUE, TRUE, FALSE);
3139 
3140 	    /*
3141 	     * Need a non-circular list for the target nodes
3142 	     */
3143 	    if (targets)
3144 		Lst_Destroy(targets, NULL);
3145 
3146 	    targets = Lst_Init(FALSE);
3147 	    inLine = TRUE;
3148 
3149 	    ParseDoDependency(line);
3150 	    free(line);
3151 
3152 	    /* If there were commands after a ';', add them now */
3153 	    if (cp != NULL) {
3154 		goto shellCommand;
3155 	    }
3156 	}
3157 	/*
3158 	 * Reached EOF, but it may be just EOF of an include file...
3159 	 */
3160     } while (ParseEOF() == CONTINUE);
3161 
3162     if (fatals) {
3163 	(void)fflush(stdout);
3164 	(void)fprintf(stderr,
3165 	    "%s: Fatal errors encountered -- cannot continue",
3166 	    progname);
3167 	PrintOnError(NULL, NULL);
3168 	exit(1);
3169     }
3170 }
3171 
3172 /*-
3173  *---------------------------------------------------------------------
3174  * Parse_Init --
3175  *	initialize the parsing module
3176  *
3177  * Results:
3178  *	none
3179  *
3180  * Side Effects:
3181  *	the parseIncPath list is initialized...
3182  *---------------------------------------------------------------------
3183  */
3184 void
3185 Parse_Init(void)
3186 {
3187     mainNode = NULL;
3188     parseIncPath = Lst_Init(FALSE);
3189     sysIncPath = Lst_Init(FALSE);
3190     defIncPath = Lst_Init(FALSE);
3191     includes = Lst_Init(FALSE);
3192 #ifdef CLEANUP
3193     targCmds = Lst_Init(FALSE);
3194 #endif
3195 }
3196 
3197 void
3198 Parse_End(void)
3199 {
3200 #ifdef CLEANUP
3201     Lst_Destroy(targCmds, (FreeProc *)free);
3202     if (targets)
3203 	Lst_Destroy(targets, NULL);
3204     Lst_Destroy(defIncPath, Dir_Destroy);
3205     Lst_Destroy(sysIncPath, Dir_Destroy);
3206     Lst_Destroy(parseIncPath, Dir_Destroy);
3207     Lst_Destroy(includes, NULL);	/* Should be empty now */
3208 #endif
3209 }
3210 
3211 
3212 /*-
3213  *-----------------------------------------------------------------------
3214  * Parse_MainName --
3215  *	Return a Lst of the main target to create for main()'s sake. If
3216  *	no such target exists, we Punt with an obnoxious error message.
3217  *
3218  * Results:
3219  *	A Lst of the single node to create.
3220  *
3221  * Side Effects:
3222  *	None.
3223  *
3224  *-----------------------------------------------------------------------
3225  */
3226 Lst
3227 Parse_MainName(void)
3228 {
3229     Lst           mainList;	/* result list */
3230 
3231     mainList = Lst_Init(FALSE);
3232 
3233     if (mainNode == NULL) {
3234 	Punt("no target to make.");
3235     	/*NOTREACHED*/
3236     } else if (mainNode->type & OP_DOUBLEDEP) {
3237 	(void)Lst_AtEnd(mainList, mainNode);
3238 	Lst_Concat(mainList, mainNode->cohorts, LST_CONCNEW);
3239     }
3240     else
3241 	(void)Lst_AtEnd(mainList, mainNode);
3242     Var_Append(".TARGETS", mainNode->name, VAR_GLOBAL);
3243     return (mainList);
3244 }
3245 
3246 /*-
3247  *-----------------------------------------------------------------------
3248  * ParseMark --
3249  *	Add the filename and lineno to the GNode so that we remember
3250  *	where it was first defined.
3251  *
3252  * Side Effects:
3253  *	None.
3254  *
3255  *-----------------------------------------------------------------------
3256  */
3257 static void
3258 ParseMark(GNode *gn)
3259 {
3260     gn->fname = curFile->fname;
3261     gn->lineno = curFile->lineno;
3262 }
3263