 @@ -1,1161 +1,1160 @@
-/*	$NetBSD: parse.c,v 1.404 2020/10/28 01:43:01 rillig Exp $	*/
+/*	$NetBSD: parse.c,v 1.405 2020/10/28 01:47:11 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 /*
  * Copyright (c) 1989 by Berkeley Softworks
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *	This product includes software developed by the University of
  *	California, Berkeley and its contributors.
  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 /*
  * Parsing of makefiles.
+ *
  * Parse_File is the main entry point and controls most of the other
  * functions in this module.
+ *
  * The directories for the .include "..." directive are kept in
  * 'parseIncPath', while those for .include <...> are kept in 'sysIncPath'.
  * The targets currently being defined are kept in 'targets'.
+ *
  * Interface:
  *	Parse_Init	Initialize the module
+ *
  *	Parse_End	Clean up the module
+ *
  *	Parse_File	Parse a top-level makefile.  Included files are
  *			handled by Parse_include_file though.
+ *
  *	Parse_IsVar	Return TRUE if the given line is a variable
  *			assignment. Used by MainParseArgs to determine if
  *			an argument is a target or a variable assignment.
  *			Used internally for pretty much the same thing.
+ *
  *	Parse_Error	Report a parse error, a warning or an informational
  *			message.
+ *
  *	Parse_MainName	Returns a list of the main target to create.
  */
 #include <sys/types.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <errno.h>
 #include <stdarg.h>
 #include <stdint.h>
 #ifndef MAP_FILE
 #define MAP_FILE 0
 #endif
 #ifndef MAP_COPY
 #define MAP_COPY MAP_PRIVATE
 #endif
 #include "make.h"
 #include "dir.h"
 #include "job.h"
 #include "pathnames.h"
 /*	"@(#)parse.c	8.3 (Berkeley) 3/19/94"	*/
-MAKE_RCSID("$NetBSD: parse.c,v 1.404 2020/10/28 01:43:01 rillig Exp $");
+MAKE_RCSID("$NetBSD: parse.c,v 1.405 2020/10/28 01:47:11 rillig Exp $");
 /* types and constants */
 /*
  * Structure for a file being read ("included file")
  */
 typedef struct IFile {
     char *fname;		/* name of file */
     Boolean fromForLoop;	/* simulated .include by the .for loop */
     int lineno;			/* current line number in file */
     int first_lineno;		/* line number of start of text */
     unsigned int cond_depth;	/* 'if' nesting when file opened */
     Boolean depending;		/* state of doing_depend on EOF */
     /* The buffer from which the file's content is read. */
     char *buf_freeIt;
     char *buf_ptr;		/* next char to be read */
     char *buf_end;
     char *(*nextbuf)(void *, size_t *); /* Function to get more data */
     void *nextbuf_arg;		/* Opaque arg for nextbuf() */
     struct loadedfile *lf;	/* loadedfile object, if any */
 } IFile;
 /*
  * Tokens for target attributes
  */
 typedef enum ParseSpecial {
     SP_BEGIN,		/* .BEGIN */
     SP_DEFAULT,		/* .DEFAULT */
     SP_DELETE_ON_ERROR,	/* .DELETE_ON_ERROR */
     SP_END,		/* .END */
     SP_ERROR,		/* .ERROR */
     SP_IGNORE,		/* .IGNORE */
     SP_INCLUDES,	/* .INCLUDES; not mentioned in the manual page */
     SP_INTERRUPT,	/* .INTERRUPT */
     SP_LIBS,		/* .LIBS; not mentioned in the manual page */
     SP_META,		/* .META */
     SP_MFLAGS,		/* .MFLAGS or .MAKEFLAGS */
     SP_MAIN,		/* .MAIN and we don't have anything user-specified to
 			 * make */
     SP_NOEXPORT,	/* .NOEXPORT; not mentioned in the manual page */
     SP_NOMETA,		/* .NOMETA */
     SP_NOMETA_CMP,	/* .NOMETA_CMP */
     SP_NOPATH,		/* .NOPATH */
     SP_NOT,		/* Not special */
     SP_NOTPARALLEL,	/* .NOTPARALLEL or .NO_PARALLEL */
     SP_NULL,		/* .NULL; not mentioned in the manual page */
     SP_OBJDIR,		/* .OBJDIR */
     SP_ORDER,		/* .ORDER */
     SP_PARALLEL,	/* .PARALLEL; not mentioned in the manual page */
     SP_PATH,		/* .PATH or .PATH.suffix */
     SP_PHONY,		/* .PHONY */
 #ifdef POSIX
     SP_POSIX,		/* .POSIX; not mentioned in the manual page */
 #endif
     SP_PRECIOUS,	/* .PRECIOUS */
     SP_SHELL,		/* .SHELL */
     SP_SILENT,		/* .SILENT */
     SP_SINGLESHELL,	/* .SINGLESHELL; not mentioned in the manual page */
     SP_STALE,		/* .STALE */
     SP_SUFFIXES,	/* .SUFFIXES */
     SP_WAIT,		/* .WAIT */
     SP_ATTRIBUTE	/* Generic attribute */
 } ParseSpecial;
 typedef List SearchPathList;
 typedef ListNode SearchPathListNode;
 /* result data */
 /*
  * The main target to create. This is the first target on the first
  * dependency line in the first makefile.
  */
 static GNode *mainNode;
 /* eval state */
 /* During parsing, the targets from the currently active dependency line,
  * or NULL if the current line does not belong to a dependency line, for
  * example because it is a variable assignment.
+ *
  * See unit-tests/deptgt.mk, keyword "parse.c:targets". */
 static GNodeList *targets;
 #ifdef CLEANUP
 /* All shell commands for all targets, in no particular order and possibly
  * with duplicates.  Kept in a separate list since the commands from .USE or
  * .USEBEFORE nodes are shared with other GNodes, thereby giving up the
  * easily understandable ownership over the allocated strings. */
 static StringList *targCmds;
 #endif
 /*
  * Predecessor node for handling .ORDER. Initialized to NULL when .ORDER
  * seen, then set to each successive source on the line.
  */
 static GNode *predecessor;
 /* parser state */
 /* number of fatal errors */
 static int fatals = 0;
 /*
  * Variables for doing includes
  */
 /* current file being read */
 static IFile *curFile;
 /* The include chain of makefiles that leads to curFile.  At the bottom of
  * the stack is the top-level makefile from the command line, and on top of
  * this file, there are the included files or .for loops, up to but excluding
  * curFile.
+ *
  * This data could be used to print stack traces on parse errors.  As of
  * 2020-09-14, this is not done though.  It seems quite simple to print the
  * tuples (fname:lineno:fromForLoop), from top to bottom.  This simple idea is
  * made complicated by the fact that the .for loops also use this stack for
  * storing information.
+ *
  * The lineno fields of the IFiles with fromForLoop == TRUE look confusing,
  * which is demonstrated by the test 'include-main.mk'.  They seem sorted
  * backwards since they tell the number of completely parsed lines, which for
  * a .for loop is right after the terminating .endfor.  To compensate for this
  * confusion, there is another field first_lineno pointing at the start of the
  * .for loop, 1-based for human consumption.
+ *
  * To make the stack trace intuitive, the entry below the first .for loop must
  * be ignored completely since neither its lineno nor its first_lineno is
  * useful.  Instead, the topmost .for loop needs to be printed twice, once
  * with its first_lineno and once with its lineno.
+ *
  * As of 2020-09-15, using the above rules, the stack trace for the .info line
  * in include-subsub.mk would be:
+ *
  *	curFile:	include-subsub.mk:4
  *			(lineno, from an .include)
  *	includes[4]:	include-sub.mk:32
  *			(lineno, from a .for loop below an .include)
  *	includes[4]:	include-sub.mk:31
  *			(first_lineno, from a .for loop, lineno == 32)
  *	includes[3]:	include-sub.mk:30
  *			(first_lineno, from a .for loop, lineno == 33)
  *	includes[2]:	include-sub.mk:29
  *			(first_lineno, from a .for loop, lineno == 34)
  *	includes[1]:	include-sub.mk:35
  *			(not printed since it is below a .for loop)
  *	includes[0]:	include-main.mk:27
  */
 static Vector /* of IFile pointer */ includes;
 static IFile *
 GetInclude(size_t i)
+{
     return *((IFile **)Vector_Get(&includes, i));
+}
 /* include paths (lists of directories) */
 SearchPath *parseIncPath;	/* dirs for "..." includes */
 SearchPath *sysIncPath;		/* dirs for <...> includes */
 SearchPath *defIncPath;		/* default for sysIncPath */
 /* parser tables */
 /*
  * The parseKeywords table is searched using binary search when deciding
  * if a target or source is special. The 'spec' field is the ParseSpecial
  * type of the keyword (SP_NOT if the keyword isn't special as a target) while
  * the 'op' field is the operator to apply to the list of targets if the
  * keyword is used as a source ("0" if the keyword isn't special as a source)
  */
 static const struct {
     const char   *name;		/* Name of keyword */
     ParseSpecial  spec;		/* Type when used as a target */
     GNodeType	  op;		/* Operator when used as a source */
 } parseKeywords[] = {
     { ".BEGIN",		SP_BEGIN,	0 },
     { ".DEFAULT",	SP_DEFAULT,	0 },
     { ".DELETE_ON_ERROR", SP_DELETE_ON_ERROR, 0 },
     { ".END",		SP_END,		0 },
     { ".ERROR",		SP_ERROR,	0 },
     { ".EXEC",		SP_ATTRIBUTE,	OP_EXEC },
     { ".IGNORE",	SP_IGNORE,	OP_IGNORE },
     { ".INCLUDES",	SP_INCLUDES,	0 },
     { ".INTERRUPT",	SP_INTERRUPT,	0 },
     { ".INVISIBLE",	SP_ATTRIBUTE,	OP_INVISIBLE },
     { ".JOIN",		SP_ATTRIBUTE,	OP_JOIN },
     { ".LIBS",		SP_LIBS,	0 },
     { ".MADE",		SP_ATTRIBUTE,	OP_MADE },
     { ".MAIN",		SP_MAIN,	0 },
     { ".MAKE",		SP_ATTRIBUTE,	OP_MAKE },
     { ".MAKEFLAGS",	SP_MFLAGS,	0 },
     { ".META",		SP_META,	OP_META },
     { ".MFLAGS",	SP_MFLAGS,	0 },
     { ".NOMETA",	SP_NOMETA,	OP_NOMETA },
     { ".NOMETA_CMP",	SP_NOMETA_CMP,	OP_NOMETA_CMP },
     { ".NOPATH",	SP_NOPATH,	OP_NOPATH },
     { ".NOTMAIN",	SP_ATTRIBUTE,	OP_NOTMAIN },
     { ".NOTPARALLEL",	SP_NOTPARALLEL,	0 },
     { ".NO_PARALLEL",	SP_NOTPARALLEL,	0 },
     { ".NULL",		SP_NULL,	0 },
     { ".OBJDIR",	SP_OBJDIR,	0 },
     { ".OPTIONAL",	SP_ATTRIBUTE,	OP_OPTIONAL },
     { ".ORDER",		SP_ORDER,	0 },
     { ".PARALLEL",	SP_PARALLEL,	0 },
     { ".PATH",		SP_PATH,	0 },
     { ".PHONY",		SP_PHONY,	OP_PHONY },
 #ifdef POSIX
     { ".POSIX",		SP_POSIX,	0 },
 #endif
     { ".PRECIOUS",	SP_PRECIOUS,	OP_PRECIOUS },
     { ".RECURSIVE",	SP_ATTRIBUTE,	OP_MAKE },
     { ".SHELL",		SP_SHELL,	0 },
     { ".SILENT",	SP_SILENT,	OP_SILENT },
     { ".SINGLESHELL",	SP_SINGLESHELL,	0 },
     { ".STALE",		SP_STALE,	0 },
     { ".SUFFIXES",	SP_SUFFIXES,	0 },
     { ".USE",		SP_ATTRIBUTE,	OP_USE },
     { ".USEBEFORE",	SP_ATTRIBUTE,	OP_USEBEFORE },
     { ".WAIT",		SP_WAIT,	0 },
 };
 /* file loader */
 struct loadedfile {
 	const char *path;		/* name, for error reports */
 	char *buf;			/* contents buffer */
 	size_t len;			/* length of contents */
 	size_t maplen;			/* length of mmap area, or 0 */
 	Boolean used;			/* XXX: have we used the data yet */
 };
 static struct loadedfile *
 loadedfile_create(const char *path)
+{
 	struct loadedfile *lf;
 	lf = bmake_malloc(sizeof(*lf));
 	lf->path = path == NULL ? "(stdin)" : path;
 	lf->buf = NULL;
 	lf->len = 0;
 	lf->maplen = 0;
 	lf->used = FALSE;
 	return lf;
+}
 static void
 loadedfile_destroy(struct loadedfile *lf)
+{
 	if (lf->buf != NULL) {
 		if (lf->maplen > 0) {
 			munmap(lf->buf, lf->maplen);
 		} else {
 			free(lf->buf);
+		}
+	}
 	free(lf);
+}
 /*
  * nextbuf() operation for loadedfile, as needed by the weird and twisted
  * logic below. Once that's cleaned up, we can get rid of lf->used...
  */
 static char *
 loadedfile_nextbuf(void *x, size_t *len)
+{
 	struct loadedfile *lf = x;
 	if (lf->used) {
 		return NULL;
+	}
 	lf->used = TRUE;
 	*len = lf->len;
 	return lf->buf;
+}
 /*
  * Try to get the size of a file.
  */
 static Boolean
 load_getsize(int fd, size_t *ret)
+{
 	struct stat st;
 	if (fstat(fd, &st) < 0) {
 		return FALSE;
+	}
 	if (!S_ISREG(st.st_mode)) {
 		return FALSE;
+	}
 	/*
 	 * st_size is an off_t, which is 64 bits signed; *ret is
 	 * size_t, which might be 32 bits unsigned or 64 bits
 	 * unsigned. Rather than being elaborate, just punt on
 	 * files that are more than 2^31 bytes. We should never
 	 * see a makefile that size in practice...
+	 *
 	 * While we're at it reject negative sizes too, just in case.
 	 */
 	if (st.st_size < 0 || st.st_size > 0x7fffffff) {
 		return FALSE;
+	}
 	*ret = (size_t)st.st_size;
 	return TRUE;
+}
 /*
  * Read in a file.
+ *
  * Until the path search logic can be moved under here instead of
  * being in the caller in another source file, we need to have the fd
  * passed in already open. Bleh.
+ *
  * If the path is NULL use stdin and (to insure against fd leaks)
  * assert that the caller passed in -1.
  */
 static struct loadedfile *
 loadfile(const char *path, int fd)
+{
 	struct loadedfile *lf;
 	static unsigned long pagesize = 0;
 	ssize_t result;
 	size_t bufpos;
 	lf = loadedfile_create(path);
 	if (path == NULL) {
 		assert(fd == -1);
 		fd = STDIN_FILENO;
 	} else {
 #if 0 /* notyet */
 		fd = open(path, O_RDONLY);
 		if (fd < 0) {
 			...
 			Error("%s: %s", path, strerror(errno));
 			exit(1);
+		}
 #endif
+	}
 	if (load_getsize(fd, &lf->len)) {
 		/* found a size, try mmap */
 		if (pagesize == 0)
 			pagesize = (unsigned long)sysconf(_SC_PAGESIZE);
 		if (pagesize == 0 || pagesize == (unsigned long)-1) {
 			pagesize = 0x1000;
+		}
 		/* round size up to a page */
 		lf->maplen = pagesize * ((lf->len + pagesize - 1)/pagesize);
 		/*
 		 * XXX hack for dealing with empty files; remove when
 		 * we're no longer limited by interfacing to the old
 		 * logic elsewhere in this file.
 		 */
 		if (lf->maplen == 0) {
 			lf->maplen = pagesize;
+		}
 		/*
 		 * FUTURE: remove PROT_WRITE when the parser no longer
 		 * needs to scribble on the input.
 		 */
 		lf->buf = mmap(NULL, lf->maplen, PROT_READ|PROT_WRITE,
 			       MAP_FILE|MAP_COPY, fd, 0);
 		if (lf->buf != MAP_FAILED) {
 			/* succeeded */
 			if (lf->len == lf->maplen && lf->buf[lf->len - 1] != '\n') {
 				char *b = bmake_malloc(lf->len + 1);
 				b[lf->len] = '\n';
 				memcpy(b, lf->buf, lf->len++);
 				munmap(lf->buf, lf->maplen);
 				lf->maplen = 0;
 				lf->buf = b;
+			}
 			goto done;
+		}
+	}
 	/* cannot mmap; load the traditional way */
 	lf->maplen = 0;
 	lf->len = 1024;
 	lf->buf = bmake_malloc(lf->len);
 	bufpos = 0;
 	while (1) {
 		assert(bufpos <= lf->len);
 		if (bufpos == lf->len) {
 			if (lf->len > SIZE_MAX/2) {
 				errno = EFBIG;
 				Error("%s: file too large", path);
 				exit(1);
+			}
 			lf->len *= 2;
 			lf->buf = bmake_realloc(lf->buf, lf->len);
+		}
 		assert(bufpos < lf->len);
 		result = read(fd, lf->buf + bufpos, lf->len - bufpos);
 		if (result < 0) {
 			Error("%s: read error: %s", path, strerror(errno));
 			exit(1);
+		}
 		if (result == 0) {
 			break;
+		}
 		bufpos += (size_t)result;
+	}
 	assert(bufpos <= lf->len);
 	lf->len = bufpos;
 	/* truncate malloc region to actual length (maybe not useful) */
 	if (lf->len > 0) {
 		/* as for mmap case, ensure trailing \n */
 		if (lf->buf[lf->len - 1] != '\n')
 			lf->len++;
 		lf->buf = bmake_realloc(lf->buf, lf->len);
 		lf->buf[lf->len - 1] = '\n';
+	}
 done:
 	if (path != NULL) {
 		close(fd);
+	}
 	return lf;
+}
 /* old code */
 /* Check if the current character is escaped on the current line. */
 static Boolean
 ParseIsEscaped(const char *line, const char *c)
+{
     Boolean active = FALSE;
     for (;;) {
 	if (line == c)
 	    return active;
 	if (*--c != '\\')
 	    return active;
 	active = !active;
+    }
+}
 /* Add the filename and lineno to the GNode so that we remember where it
  * was first defined. */
 static void
 ParseMark(GNode *gn)
+{
     gn->fname = curFile->fname;
     gn->lineno = curFile->lineno;
+}
 /* Look in the table of keywords for one matching the given string.
  * Return the index of the keyword, or -1 if it isn't there. */
 static int
 ParseFindKeyword(const char *str)
+{
     int start, end, cur;
     int diff;
     start = 0;
     end = sizeof parseKeywords / sizeof parseKeywords[0] - 1;
     do {
 	cur = start + (end - start) / 2;
 	diff = strcmp(str, parseKeywords[cur].name);
 	if (diff == 0) {
 	    return cur;
 	} else if (diff < 0) {
 	    end = cur - 1;
 	} else {
 	    start = cur + 1;
+	}
     } while (start <= end);
     return -1;
+}
 static void
 PrintLocation(FILE *f, const char *filename, size_t lineno)
+{
 	char dirbuf[MAXPATHLEN+1];
 	const char *dir, *base;
 	char *dir_freeIt, *base_freeIt;
 	if (*filename == '/' || strcmp(filename, "(stdin)") == 0) {
 		(void)fprintf(f, "\"%s\" line %zu: ", filename, lineno);
 		return;
+	}
 	/* Find out which makefile is the culprit.
 	 * We try ${.PARSEDIR} and apply realpath(3) if not absolute. */
 	dir = Var_Value(".PARSEDIR", VAR_GLOBAL, &dir_freeIt);
 	if (dir == NULL)
 		dir = ".";
 	if (*dir != '/')
 		dir = realpath(dir, dirbuf);
 	base = Var_Value(".PARSEFILE", VAR_GLOBAL, &base_freeIt);
 	if (base == NULL) {
 		const char *slash = strrchr(filename, '/');
 		base = slash != NULL ? slash + 1 : filename;
+	}
 	(void)fprintf(f, "\"%s/%s\" line %zu: ", dir, base, lineno);
 	bmake_free(base_freeIt);
 	bmake_free(dir_freeIt);
+}
 /* Print a parse error message, including location information.
+ *
  * Increment "fatals" if the level is PARSE_FATAL, and continue parsing
  * until the end of the current top-level makefile, then exit (see
  * Parse_File). */
 static void
 ParseVErrorInternal(FILE *f, const char *cfname, size_t clineno,
 		    ParseErrorLevel type, const char *fmt, va_list ap)
+{
 	static Boolean fatal_warning_error_printed = FALSE;
 	(void)fprintf(f, "%s: ", progname);
 	if (cfname != NULL)
 		PrintLocation(f, cfname, clineno);
 	if (type == PARSE_WARNING)
 		(void)fprintf(f, "warning: ");
 	(void)vfprintf(f, fmt, ap);
 	(void)fprintf(f, "\n");
 	(void)fflush(f);
 	if (type == PARSE_INFO)
 		return;
 	if (type == PARSE_FATAL || opts.parseWarnFatal)
 		fatals++;
 	if (opts.parseWarnFatal && !fatal_warning_error_printed) {
 		Error("parsing warnings being treated as errors");
 		fatal_warning_error_printed = TRUE;
+	}
+}
 static void
 ParseErrorInternal(const char *cfname, size_t clineno, ParseErrorLevel type,
 		   const char *fmt, ...)
+{
 	va_list ap;
 	va_start(ap, fmt);
 	(void)fflush(stdout);
 	ParseVErrorInternal(stderr, cfname, clineno, type, fmt, ap);
 	va_end(ap);
 	if (opts.debug_file != stderr && opts.debug_file != stdout) {
 		va_start(ap, fmt);
 		ParseVErrorInternal(opts.debug_file, cfname, clineno, type,
 				    fmt, ap);
 		va_end(ap);
+	}
+}
 /* External interface to ParseErrorInternal; uses the default filename and
  * line number.
+ *
  * Fmt is given without a trailing newline. */
 void
 Parse_Error(ParseErrorLevel type, const char *fmt, ...)
+{
 	va_list ap;
 	const char *fname;
 	size_t lineno;
 	if (curFile == NULL) {
 		fname = NULL;
 		lineno = 0;
 	} else {
 		fname = curFile->fname;
 		lineno = (size_t)curFile->lineno;
+	}
 	va_start(ap, fmt);
 	(void)fflush(stdout);
 	ParseVErrorInternal(stderr, fname, lineno, type, fmt, ap);
 	va_end(ap);
 	if (opts.debug_file != stderr && opts.debug_file != stdout) {
 		va_start(ap, fmt);
 		ParseVErrorInternal(opts.debug_file, fname, lineno, type,
 				    fmt, ap);
 		va_end(ap);
+	}
+}
 /* Parse a .info .warning or .error directive.
+ *
  * The input is the line minus the ".".  We substitute variables, print the
  * message and exit(1) (for .error) or just print a warning if the directive
  * is malformed.
  */
 static Boolean
 ParseMessage(const char *directive)
+{
     const char *p = directive;
     int mtype = *p == 'i' ? PARSE_INFO :
 		*p == 'w' ? PARSE_WARNING : PARSE_FATAL;
     char *arg;
     while (ch_isalpha(*p))
 	p++;
     if (!ch_isspace(*p))
 	return FALSE;		/* missing argument */
     cpp_skip_whitespace(&p);
     (void)Var_Subst(p, VAR_CMD, VARE_WANTRES, &arg);
     /* TODO: handle errors */
     Parse_Error(mtype, "%s", arg);
     free(arg);
     if (mtype == PARSE_FATAL) {
 	PrintOnError(NULL, NULL);
 	exit(1);
+    }
     return TRUE;
+}
 /* Add the child to the parent's children.
+ *
  * Additionally, add the parent to the child's parents, but only if the
  * target is not special.  An example for such a special target is .END,
  * which does not need to be informed once the child target has been made. */
 static void
 LinkSource(GNode *pgn, GNode *cgn, Boolean isSpecial)
+{
     if ((pgn->type & OP_DOUBLEDEP) && !Lst_IsEmpty(pgn->cohorts))
 	pgn = pgn->cohorts->last->datum;
     Lst_Append(pgn->children, cgn);
     pgn->unmade++;
     /* Special targets like .END don't need any children. */
     if (!isSpecial)
 	Lst_Append(cgn->parents, pgn);
     if (DEBUG(PARSE)) {
 	debug_printf("# %s: added child %s - %s\n",
 		     __func__, pgn->name, cgn->name);
 	Targ_PrintNode(pgn, 0);
 	Targ_PrintNode(cgn, 0);
+    }
+}
 /* Add the node to each target from the current dependency group. */
 static void
 LinkToTargets(GNode *gn, Boolean isSpecial)
+{
     GNodeListNode *ln;
     for (ln = targets->first; ln != NULL; ln = ln->next)
 	LinkSource(ln->datum, gn, isSpecial);
+}
 static Boolean
 TryApplyDependencyOperator(GNode *gn, GNodeType op)
+{
     /*
      * If the node occurred on the left-hand side of a dependency and the
      * operator also defines a dependency, they must match.
      */
     if ((op & OP_OPMASK) && (gn->type & OP_OPMASK) &&
 	((op & OP_OPMASK) != (gn->type & OP_OPMASK)))
+    {
 	Parse_Error(PARSE_FATAL, "Inconsistent operator for %s", gn->name);
 	return FALSE;
+    }
     if (op == OP_DOUBLEDEP && (gn->type & OP_OPMASK) == OP_DOUBLEDEP) {
 	/*
 	 * If the node was the object of a :: operator, we need to create a
 	 * new instance of it for the children and commands on this dependency
 	 * line. The new instance is placed on the 'cohorts' list of the
 	 * initial one (note the initial one is not on its own cohorts list)
 	 * and the new instance is linked to all parents of the initial
 	 * instance.
 	 */
 	GNode *cohort;
 	/*
 	 * Propagate copied bits to the initial node.  They'll be propagated
 	 * back to the rest of the cohorts later.
 	 */
 	gn->type |= op & ~OP_OPMASK;
 	cohort = Targ_NewInternalNode(gn->name);
 	if (doing_depend)
 	    ParseMark(cohort);
 	/*
 	 * Make the cohort invisible as well to avoid duplicating it into
 	 * other variables. True, parents of this target won't tend to do
 	 * anything with their local variables, but better safe than
 	 * sorry. (I think this is pointless now, since the relevant list
 	 * traversals will no longer see this node anyway. -mycroft)
 	 */
 	cohort->type = op | OP_INVISIBLE;
 	Lst_Append(gn->cohorts, cohort);
 	cohort->centurion = gn;
 	gn->unmade_cohorts++;
 	snprintf(cohort->cohort_num, sizeof cohort->cohort_num, "#%d",
 		 (unsigned int)gn->unmade_cohorts % 1000000);
     } else {
 	/*
 	 * We don't want to nuke any previous flags (whatever they were) so we
 	 * just OR the new operator into the old
 	 */
 	gn->type |= op;
+    }
     return TRUE;
+}
 static void
 ApplyDependencyOperator(GNodeType op)
+{
     GNodeListNode *ln;
     for (ln = targets->first; ln != NULL; ln = ln->next)
 	if (!TryApplyDependencyOperator(ln->datum, op))
 	    break;
+}
 static Boolean
 ParseDoSrcKeyword(const char *src, ParseSpecial specType)
+{
     static int wait_number = 0;
     char wait_src[16];
     GNode *gn;
     if (*src == '.' && ch_isupper(src[1])) {
 	int keywd = ParseFindKeyword(src);
 	if (keywd != -1) {
 	    int op = parseKeywords[keywd].op;
 	    if (op != 0) {
 		ApplyDependencyOperator(op);
 		return TRUE;
+	    }
 	    if (parseKeywords[keywd].spec == SP_WAIT) {
 		/*
 		 * We add a .WAIT node in the dependency list.
 		 * After any dynamic dependencies (and filename globbing)
 		 * have happened, it is given a dependency on the each
 		 * previous child back to and previous .WAIT node.
 		 * The next child won't be scheduled until the .WAIT node
 		 * is built.
 		 * We give each .WAIT node a unique name (mainly for diag).
 		 */
 		snprintf(wait_src, sizeof wait_src, ".WAIT_%u", ++wait_number);
 		gn = Targ_NewInternalNode(wait_src);
 		if (doing_depend)
 		    ParseMark(gn);
 		gn->type = OP_WAIT | OP_PHONY | OP_DEPENDS | OP_NOTMAIN;
 		LinkToTargets(gn, specType != SP_NOT);
 		return TRUE;
+	    }
+	}
+    }
     return FALSE;
+}
 static void
 ParseDoSrcMain(const char *src)
+{
     /*
      * If we have noted the existence of a .MAIN, it means we need
      * to add the sources of said target to the list of things
      * to create. The string 'src' is likely to be free, so we
      * must make a new copy of it. Note that this will only be
      * invoked if the user didn't specify a target on the command
      * line. This is to allow #ifmake's to succeed, or something...
      */
     Lst_Append(opts.create, bmake_strdup(src));
     /*
      * Add the name to the .TARGETS variable as well, so the user can
      * employ that, if desired.
      */
     Var_Append(".TARGETS", src, VAR_GLOBAL);
+}
 static void
 ParseDoSrcOrder(const char *src)
+{
     GNode *gn;
     /*
      * Create proper predecessor/successor links between the previous
      * source and the current one.
      */
     gn = Targ_GetNode(src);
     if (doing_depend)
 	ParseMark(gn);
     if (predecessor != NULL) {
 	Lst_Append(predecessor->order_succ, gn);
 	Lst_Append(gn->order_pred, predecessor);
 	if (DEBUG(PARSE)) {
 	    debug_printf("# %s: added Order dependency %s - %s\n",
 			 __func__, predecessor->name, gn->name);
 	    Targ_PrintNode(predecessor, 0);
 	    Targ_PrintNode(gn, 0);
+	}
+    }
     /*
      * The current source now becomes the predecessor for the next one.
      */
     predecessor = gn;
+}
 static void
 ParseDoSrcOther(const char *src, GNodeType tOp, ParseSpecial specType)
+{
     GNode *gn;
     /*
      * If the source is not an attribute, we need to find/create
      * a node for it. After that we can apply any operator to it
      * from a special target or link it to its parents, as
      * appropriate.
+     *
      * In the case of a source that was the object of a :: operator,
      * the attribute is applied to all of its instances (as kept in
      * the 'cohorts' list of the node) or all the cohorts are linked
      * to all the targets.
      */
     /* Find/create the 'src' node and attach to all targets */
     gn = Targ_GetNode(src);
     if (doing_depend)
 	ParseMark(gn);
     if (tOp) {
 	gn->type |= tOp;
     } else {
 	LinkToTargets(gn, specType != SP_NOT);
+    }
+}
 /* Given the name of a source in a dependency line, figure out if it is an
  * attribute (such as .SILENT) and apply it to the targets if it is. Else
  * decide if there is some attribute which should be applied *to* the source
  * because of some special target (such as .PHONY) and apply it if so.
  * Otherwise, make the source a child of the targets in the list 'targets'.
+ *
  * Input:
  *	tOp		operator (if any) from special targets
  *	src		name of the source to handle
  */
 static void
 ParseDoSrc(GNodeType tOp, const char *src, ParseSpecial specType)
+{
     if (ParseDoSrcKeyword(src, specType))
 	return;
     if (specType == SP_MAIN)
 	ParseDoSrcMain(src);
     else if (specType == SP_ORDER)
 	ParseDoSrcOrder(src);
     else
 	ParseDoSrcOther(src, tOp, specType);
+}
 /* If we have yet to decide on a main target to make, in the absence of any
  * user input, we want the first target on the first dependency line that is
  * actually a real target (i.e. isn't a .USE or .EXEC rule) to be made. */
 static void
 FindMainTarget(void)
+{
     GNodeListNode *ln;
     if (mainNode != NULL)
 	return;
     for (ln = targets->first; ln != NULL; ln = ln->next) {
 	GNode *gn = ln->datum;
 	if (!(gn->type & OP_NOTARGET)) {
 	    mainNode = gn;
 	    Targ_SetMain(gn);
 	    return;
+	}
+    }
+}
 /*
  * We got to the end of the line while we were still looking at targets.
+ *
  * Ending a dependency line without an operator is a Bozo no-no.  As a
  * heuristic, this is also often triggered by undetected conflicts from
  * cvs/rcs merges.
  */
 static void
 ParseErrorNoDependency(const char *lstart)
+{
     if ((strncmp(lstart, "<<<<<<", 6) == 0) ||
 	(strncmp(lstart, "======", 6) == 0) ||
 	(strncmp(lstart, ">>>>>>", 6) == 0))
 	Parse_Error(PARSE_FATAL,
 		    "Makefile appears to contain unresolved cvs/rcs/??? merge conflicts");
     else if (lstart[0] == '.') {
 	const char *dirstart = lstart + 1;
 	const char *dirend;
 	cpp_skip_whitespace(&dirstart);
 	dirend = dirstart;
 	while (ch_isalnum(*dirend) || *dirend == '-')
 	    dirend++;
 	Parse_Error(PARSE_FATAL, "Unknown directive \"%.*s\"",
 		    (int)(dirend - dirstart), dirstart);
     } else
 	Parse_Error(PARSE_FATAL, "Need an operator");
+}
 static void
 ParseDependencyTargetWord(/*const*/ char **pp, const char *lstart)
+{
     /*const*/ char *cp = *pp;
     while (*cp != '\0') {
 	if ((ch_isspace(*cp) || *cp == '!' || *cp == ':' || *cp == '(') &&
 	    !ParseIsEscaped(lstart, cp))
 	    break;
 	if (*cp == '$') {
 	    /*
 	     * Must be a dynamic source (would have been expanded
 	     * otherwise), so call the Var module to parse the puppy
 	     * so we can safely advance beyond it...There should be
 	     * no errors in this, as they would have been discovered
 	     * in the initial Var_Subst and we wouldn't be here.
 	     */
 	    const char *nested_p = cp;
 	    const char *nested_val;
 	    void *freeIt;
 	    (void)Var_Parse(&nested_p, VAR_CMD, VARE_UNDEFERR|VARE_WANTRES,
 			    &nested_val, &freeIt);
 	    /* TODO: handle errors */
 	    free(freeIt);
 	    cp += nested_p - cp;
 	} else
 	    cp++;
+    }
     *pp = cp;
+}
 /*
  * Certain special targets have special semantics:
  *	.PATH		Have to set the dirSearchPath
  *			variable too
  *	.MAIN		Its sources are only used if
  *			nothing has been specified to
  *			create.
  *	.DEFAULT	Need to create a node to hang
  *			commands on, but we don't want
  *			it in the graph, nor do we want
  *			it to be the Main Target, so we
  *			create it, set OP_NOTMAIN and
  *			add it to the list, setting
  *			DEFAULT to the new node for
  *			later use. We claim the node is
  *			A transformation rule to make
  *			life easier later, when we'll
  *			use Make_HandleUse to actually
  *			apply the .DEFAULT commands.
  *	.PHONY		The list of targets
  *	.NOPATH		Don't search for file in the path
  *	.STALE
  *	.BEGIN
  *	.END
  *	.ERROR
  *	.DELETE_ON_ERROR
  *	.INTERRUPT	Are not to be considered the
  *			main target.
  *	.NOTPARALLEL	Make only one target at a time.
  *	.SINGLESHELL	Create a shell for each command.
  *	.ORDER		Must set initial predecessor to NULL
  */
 static void
 ParseDoDependencyTargetSpecial(ParseSpecial *inout_specType,
 			       const char *line,
 			       SearchPathList **inout_paths)
+{
     switch (*inout_specType) {
     case SP_PATH:
 	if (*inout_paths == NULL) {
 	    *inout_paths = Lst_New();
+	}
 	Lst_Append(*inout_paths, dirSearchPath);
 	break;
     case SP_MAIN:
 	if (!Lst_IsEmpty(opts.create)) {
 	    *inout_specType = SP_NOT;
+	}
 	break;
     case SP_BEGIN:
     case SP_END:
     case SP_STALE:
     case SP_ERROR:
     case SP_INTERRUPT: {
 	GNode *gn = Targ_GetNode(line);
 	if (doing_depend)
 	    ParseMark(gn);
 	gn->type |= OP_NOTMAIN|OP_SPECIAL;
 	Lst_Append(targets, gn);
 	break;
+    }
     case SP_DEFAULT: {
 	GNode *gn = Targ_NewGN(".DEFAULT");
 	gn->type |= OP_NOTMAIN|OP_TRANSFORM;
 	Lst_Append(targets, gn);
 	DEFAULT = gn;
 	break;
+    }
     case SP_DELETE_ON_ERROR:
 	deleteOnError = TRUE;
 	break;
     case SP_NOTPARALLEL:
 	opts.maxJobs = 1;
 	break;
     case SP_SINGLESHELL:
 	opts.compatMake = TRUE;
 	break;
     case SP_ORDER:
 	predecessor = NULL;
 	break;
     default:
 	break;
+    }
+}
 /*
  * .PATH<suffix> has to be handled specially.
  * Call on the suffix module to give us a path to modify.