 @@ -1,2088 +1,2087 @@
-/*	$NetBSD: parse.c,v 1.518 2020/12/27 11:47:04 rillig Exp $	*/
+/*	$NetBSD: parse.c,v 1.519 2020/12/27 18:22:28 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.518 2020/12/27 11:47:04 rillig Exp $");
+MAKE_RCSID("$NetBSD: parse.c,v 1.519 2020/12/27 18:22:28 rillig Exp $");
 /* types and constants */
 /*
  * Structure for a file being read ("included file")
  */
 typedef struct IFile {
 	char *fname;		/* name of file (relative? absolute?) */
 	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;
 	/* Function to read more data, with a single opaque argument. */
 	ReadMoreProc readMore;
 	void *readMoreArg;
 	struct loadedfile *lf;	/* loadedfile object, if any */
 } IFile;
 /*
  * Tokens for target attributes
  */
 typedef enum ParseSpecial {
 	SP_ATTRIBUTE,	/* Generic attribute */
 	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 */
 	/* .MAIN and we don't have anything user-specified to make */
 	SP_MAIN,
 	SP_META,	/* .META */
 	SP_MFLAGS,	/* .MFLAGS or .MAKEFLAGS */
 	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 */
 } 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 left-hand side of 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 = LST_INIT;
 #endif
 /*
  * Predecessor node for handling .ORDER. Initialized to NULL when .ORDER
  * seen, then set to each successive source on the line.
  */
 static GNode *order_pred;
 /* parser state */
 /* number of fatal errors */
 static int fatals = 0;
 /*
  * Variables for doing includes
  */
 /* The include chain of makefiles.  At the bottom is the top-level makefile
  * from the command line, and on top of that, there are the included files or
  * .for loops, up to and including the current file.
+ *
  * 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 of each chain of .for loop needs to be
  * printed twice, once with its first_lineno and once with its lineno.
+ *
  * As of 2020-10-28, using the above rules, the stack trace for the .info line
  * in include-subsub.mk would be:
+ *
  *	includes[5]:	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 */ includes;
 static IFile *
 GetInclude(size_t i)
+{
 	return Vector_Get(&includes, i);
+}
 /* The file that is currently being read. */
 static IFile *
 CurFile(void)
+{
 	return GetInclude(includes.len - 1);
+}
 /* include paths */
 SearchPath *parseIncPath;	/* dirs for "..." includes */
 SearchPath *sysIncPath;		/* dirs for <...> includes */
 SearchPath *defSysIncPath;	/* 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,	OP_NONE },
     { ".DEFAULT",	SP_DEFAULT,	OP_NONE },
     { ".DELETE_ON_ERROR", SP_DELETE_ON_ERROR, OP_NONE },
     { ".END",		SP_END,		OP_NONE },
     { ".ERROR",		SP_ERROR,	OP_NONE },
     { ".EXEC",		SP_ATTRIBUTE,	OP_EXEC },
     { ".IGNORE",	SP_IGNORE,	OP_IGNORE },
     { ".INCLUDES",	SP_INCLUDES,	OP_NONE },
     { ".INTERRUPT",	SP_INTERRUPT,	OP_NONE },
     { ".INVISIBLE",	SP_ATTRIBUTE,	OP_INVISIBLE },
     { ".JOIN",		SP_ATTRIBUTE,	OP_JOIN },
     { ".LIBS",		SP_LIBS,	OP_NONE },
     { ".MADE",		SP_ATTRIBUTE,	OP_MADE },
     { ".MAIN",		SP_MAIN,	OP_NONE },
     { ".MAKE",		SP_ATTRIBUTE,	OP_MAKE },
     { ".MAKEFLAGS",	SP_MFLAGS,	OP_NONE },
     { ".META",		SP_META,	OP_META },
     { ".MFLAGS",	SP_MFLAGS,	OP_NONE },
     { ".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,	OP_NONE },
     { ".NO_PARALLEL",	SP_NOTPARALLEL,	OP_NONE },
     { ".NULL",		SP_NULL,	OP_NONE },
     { ".OBJDIR",	SP_OBJDIR,	OP_NONE },
     { ".OPTIONAL",	SP_ATTRIBUTE,	OP_OPTIONAL },
     { ".ORDER",		SP_ORDER,	OP_NONE },
     { ".PARALLEL",	SP_PARALLEL,	OP_NONE },
     { ".PATH",		SP_PATH,	OP_NONE },
     { ".PHONY",		SP_PHONY,	OP_PHONY },
 #ifdef POSIX
     { ".POSIX",		SP_POSIX,	OP_NONE },
 #endif
     { ".PRECIOUS",	SP_PRECIOUS,	OP_PRECIOUS },
     { ".RECURSIVE",	SP_ATTRIBUTE,	OP_MAKE },
     { ".SHELL",		SP_SHELL,	OP_NONE },
     { ".SILENT",	SP_SILENT,	OP_SILENT },
     { ".SINGLESHELL",	SP_SINGLESHELL,	OP_NONE },
     { ".STALE",		SP_STALE,	OP_NONE },
     { ".SUFFIXES",	SP_SUFFIXES,	OP_NONE },
     { ".USE",		SP_ATTRIBUTE,	OP_USE },
     { ".USEBEFORE",	SP_ATTRIBUTE,	OP_USEBEFORE },
     { ".WAIT",		SP_WAIT,	OP_NONE },
 };
 /* file loader */
 struct loadedfile {
 	/* XXX: What is the lifetime of this path? Who manages the memory? */
 	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 */
 };
 /* XXX: What is the lifetime of the path? Who manages the memory? */
 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);
+}
 /*
  * readMore() 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_readMore(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;
+}
 static Boolean
 loadedfile_mmap(struct loadedfile *lf, int fd)
+{
 	static unsigned long pagesize = 0;
 	if (!load_getsize(fd, &lf->len))
 		return FALSE;
 	/* 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)
 		return FALSE;
 	if (lf->len > 0 && lf->buf[lf->len - 1] != '\n') {
 		if (lf->len == lf->maplen) {
 			char *b = bmake_malloc(lf->len + 1);
 			memcpy(b, lf->buf, lf->len);
 			munmap(lf->buf, lf->maplen);
 			lf->maplen = 0;
+		}
 		lf->buf[lf->len++] = '\n';
+	}
 	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.
  */
 static struct loadedfile *
 loadfile(const char *path, int fd)
+{
 	struct loadedfile *lf;
 	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 (loadedfile_mmap(lf, fd))
 		goto done;
 	/* cannot mmap; load the traditional way */
 	lf->maplen = 0;
 	lf->len = 1024;
 	lf->buf = bmake_malloc(lf->len);
 	bufpos = 0;
 	for (;;) {
 		assert(bufpos <= lf->len);
 		if (bufpos == lf->len) {
 			if (lf->len > SIZE_MAX / 2) {
 				errno = EFBIG;
 				Error("%s: file too large", path);
 				exit(2); /* Not 1 so -q can distinguish error */
+			}
 			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(2);	/* Not 1 so -q can distinguish error */
+		}
 		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)
+{
 	IFile *curFile = CurFile();
 	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 = 0;
 	int end = sizeof parseKeywords / sizeof parseKeywords[0] - 1;
 	do {
 		int curr = start + (end - start) / 2;
 		int diff = strcmp(str, parseKeywords[curr].name);
 		if (diff == 0)
 			return curr;
 		if (diff < 0)
 			end = curr - 1;
 		else
 			start = curr + 1;
 	} while (start <= end);
 	return -1;
+}
 static void
 PrintLocation(FILE *f, const char *fname, size_t lineno)
+{
 	char dirbuf[MAXPATHLEN + 1];
 	FStr dir, base;
 	if (*fname == '/' || strcmp(fname, "(stdin)") == 0) {
 		(void)fprintf(f, "\"%s\" line %u: ", fname, (unsigned)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);
 	if (dir.str == NULL)
 		dir.str = ".";
 	if (dir.str[0] != '/')
 		dir.str = realpath(dir.str, dirbuf);
 	base = Var_Value(".PARSEFILE", VAR_GLOBAL);
 	if (base.str == NULL)
 		base.str = str_basename(fname);
 	(void)fprintf(f, "\"%s/%s\" line %u: ",
 	    dir.str, base.str, (unsigned)lineno);
 	FStr_Done(&base);
 	FStr_Done(&dir);
+}
 static void
 ParseVErrorInternal(FILE *f, const char *fname, size_t lineno,
 		    ParseErrorLevel type, const char *fmt, va_list ap)
+{
 	static Boolean fatal_warning_error_printed = FALSE;
 	(void)fprintf(f, "%s: ", progname);
 	if (fname != NULL)
 		PrintLocation(f, fname, lineno);
 	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 *fname, size_t lineno,
 		   ParseErrorLevel type, const char *fmt, ...)
+{
 	va_list ap;
 	(void)fflush(stdout);
 	va_start(ap, fmt);
 	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);
+	}
+}
 /* Print a parse error message, including location information.
+ *
  * If the level is PARSE_FATAL, continue parsing until the end of the
  * current top-level makefile, then exit (see Parse_File).
+ *
  * 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 (includes.len == 0) {
 		fname = NULL;
 		lineno = 0;
 	} else {
 		IFile *curFile = CurFile();
 		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 and handle a .info, .warning or .error directive.
  * For an .error directive, immediately exit. */
 static void
 ParseMessage(ParseErrorLevel level, const char *levelName, const char *umsg)
+{
 	char *xmsg;
 	if (umsg[0] == '\0') {
 		Parse_Error(PARSE_FATAL, "Missing argument for \".%s\"",
 		    levelName);
 		return;
+	}
 	(void)Var_Subst(umsg, VAR_CMDLINE, VARE_WANTRES, &xmsg);
 	/* TODO: handle errors */
 	Parse_Error(level, "%s", xmsg);
 	free(xmsg);
 	if (level == PARSE_FATAL) {
 		PrintOnError(NULL, NULL);
 		exit(1);
+	}
+}
 /* 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 of the left-hand side of a '::' operator,
 		 * we need to create a new instance of it for the children
 		 * and commands on this dependency line since each of these
 		 * dependency groups has its own attributes and commands,
 		 * separate from the others.
+		 *
 		 * 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;
+}
 /*
  * We add a .WAIT node in the dependency list. After any dynamic dependencies
  * (and filename globbing) have happened, it is given a dependency on each
  * previous child, back until the 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 diagnostics).
  */
 static void
 ParseDependencySourceWait(Boolean isSpecial)
+{
 	static int wait_number = 0;
 	char wait_src[16];
 	GNode *gn;
 	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, isSpecial);
+}
 static Boolean
 ParseDependencySourceKeyword(const char *src, ParseSpecial specType)
+{
 	int keywd;
 	GNodeType op;
 	if (*src != '.' || !ch_isupper(src[1]))
 		return FALSE;
 	keywd = ParseFindKeyword(src);
 	if (keywd == -1)
 		return FALSE;
 	op = parseKeywords[keywd].op;
 	if (op != OP_NONE) {
 		ApplyDependencyOperator(op);
 		return TRUE;
+	}
 	if (parseKeywords[keywd].spec == SP_WAIT) {
 		ParseDependencySourceWait(specType != SP_NOT);
 		return TRUE;
+	}
 	return FALSE;
+}
 static void
 ParseDependencySourceMain(const char *src)
+{
 	/*
 	 * In a line like ".MAIN: source1 source2", it means we need to add
 	 * the sources of said target to the list of things to create.
+	 *
 	 * Note that this will only be invoked if the user didn't specify a
 	 * target on the command line and the .MAIN occurs for the first time.
+	 *
 	 * See ParseDoDependencyTargetSpecial, branch SP_MAIN.
 	 * See unit-tests/cond-func-make-main.mk.
 	 */
 	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
 ParseDependencySourceOrder(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 (order_pred != NULL) {
 		Lst_Append(&order_pred->order_succ, gn);
 		Lst_Append(&gn->order_pred, order_pred);
 		if (DEBUG(PARSE)) {
 			debug_printf("# %s: added Order dependency %s - %s\n",
 			    __func__, order_pred->name, gn->name);
 			Targ_PrintNode(order_pred, 0);
 			Targ_PrintNode(gn, 0);
+		}
+	}
 	/*
 	 * The current source now becomes the predecessor for the next one.
 	 */
 	order_pred = gn;
+}
 static void
 ParseDependencySourceOther(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 != OP_NONE)
 		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
 ParseDependencySource(GNodeType tOp, const char *src, ParseSpecial specType)
+{
 	if (ParseDependencySourceKeyword(src, specType))
 		return;
 	if (specType == SP_MAIN)
 		ParseDependencySourceMain(src);
 	else if (specType == SP_ORDER)
 		ParseDependencySourceOrder(src);
 	else
 		ParseDependencySourceOther(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)) {
 			DEBUG1(MAKE, "Setting main node to \"%s\"\n", gn->name);
 			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;
 			FStr nested_val;
-			/* XXX: Why VARE_WANTRES? */
+			(void)Var_Parse(&nested_p, VAR_CMDLINE, VARE_NONE,
-			(void)Var_Parse(&nested_p, VAR_CMDLINE,
+			    &nested_val);
 			    VARE_WANTRES | VARE_UNDEFERR, &nested_val);
 			/* TODO: handle errors */
 			FStr_Done(&nested_val);
 			cp += nested_p - cp;
 		} else
 			cp++;
+	}
 	*pp = cp;
+}
 /* Handle special targets like .PATH, .DEFAULT, .BEGIN, .ORDER. */
 static void
 ParseDoDependencyTargetSpecial(ParseSpecial *inout_specType,
 			       const char *line, /* XXX: bad name */
 			       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:
 		/*
 		 * Allow targets from the command line to override the
 		 * .MAIN node.
 		 */
 		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: {
 		/*
 		 * 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. 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.
 		 */
 		GNode *gn = GNode_New(".DEFAULT");
 		gn->type |= OP_NOTMAIN | OP_TRANSFORM;
 		Lst_Append(targets, gn);
 		defaultNode = 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:
 		order_pred = NULL;
 		break;
 	default:
 		break;
+	}
+}
 /*
  * .PATH<suffix> has to be handled specially.
  * Call on the suffix module to give us a path to modify.
  */
 static Boolean
 ParseDoDependencyTargetPath(const char *line, /* XXX: bad name */
 			    SearchPathList **inout_paths)
+{
 	SearchPath *path;
 	path = Suff_GetPath(&line[5]);
 	if (path == NULL) {
 		Parse_Error(PARSE_FATAL,
 		    "Suffix '%s' not defined (yet)", &line[5]);
 		return FALSE;
+	}
 	if (*inout_paths == NULL)
 		*inout_paths = Lst_New();
 	Lst_Append(*inout_paths, path);
 	return TRUE;
+}
 /*
  * See if it's a special target and if so set specType to match it.
  */
 static Boolean
 ParseDoDependencyTarget(const char *line, /* XXX: bad name */
 			ParseSpecial *inout_specType,
 			GNodeType *out_tOp, SearchPathList **inout_paths)
+{
 	int keywd;
 	if (!(line[0] == '.' && ch_isupper(line[1])))
 		return TRUE;
 	/*
 	 * See if the target is a special target that must have it
 	 * or its sources handled specially.
 	 */
 	keywd = ParseFindKeyword(line);
 	if (keywd != -1) {
 		if (*inout_specType == SP_PATH &&
 		    parseKeywords[keywd].spec != SP_PATH) {
 			Parse_Error(PARSE_FATAL, "Mismatched special targets");
 			return FALSE;
+		}
 		*inout_specType = parseKeywords[keywd].spec;
 		*out_tOp = parseKeywords[keywd].op;
 		ParseDoDependencyTargetSpecial(inout_specType, line,
 		    inout_paths);
 	} else if (strncmp(line, ".PATH", 5) == 0) {
 		*inout_specType = SP_PATH;
 		if (!ParseDoDependencyTargetPath(line, inout_paths))
 			return FALSE;
+	}
 	return TRUE;
+}
 static void
 ParseDoDependencyTargetMundane(char *line, /* XXX: bad name */
 			       StringList *curTargs)
+{
 	if (Dir_HasWildcards(line)) {
 		/*
 		 * Targets are to be sought only in the current directory,
 		 * so create an empty path for the thing. Note we need to
 		 * use Dir_Destroy in the destruction of the path as the
 		 * Dir module could have added a directory to the path...
 		 */
 		SearchPath *emptyPath = SearchPath_New();
 		Dir_Expand(line, emptyPath, curTargs);
 		SearchPath_Free(emptyPath);
 	} else {
 		/*
 		 * No wildcards, but we want to avoid code duplication,
 		 * so create a list with the word on it.
 		 */
 		Lst_Append(curTargs, line);
+	}
 	/* Apply the targets. */
 	while (!Lst_IsEmpty(curTargs)) {
 		char *targName = Lst_Dequeue(curTargs);
 		GNode *gn = Suff_IsTransform(targName)
 		    ? Suff_AddTransform(targName)
 		    : Targ_GetNode(targName);
 		if (doing_depend)
 			ParseMark(gn);
 		Lst_Append(targets, gn);
+	}
+}
 static void
 ParseDoDependencyTargetExtraWarn(char **pp, const char *lstart)
+{
 	Boolean warning = FALSE;
 	char *cp = *pp;
 	while (*cp != '\0') {
 		if (!ParseIsEscaped(lstart, cp) && (*cp == '!' || *cp == ':'))
 			break;
 		if (ParseIsEscaped(lstart, cp) || (*cp != ' ' && *cp != '\t'))
 			warning = TRUE;
 		cp++;
+	}
 	if (warning)
 		Parse_Error(PARSE_WARNING, "Extra target ignored");
 	*pp = cp;
+}
 static void
 ParseDoDependencyCheckSpec(ParseSpecial specType)
+{
 	switch (specType) {
 	default:
 		Parse_Error(PARSE_WARNING,
 		    "Special and mundane targets don't mix. "
 		    "Mundane ones ignored");
 		break;
 	case SP_DEFAULT:
 	case SP_STALE:
 	case SP_BEGIN:
 	case SP_END:
 	case SP_ERROR:
 	case SP_INTERRUPT:
 		/*
 		 * These create nodes on which to hang commands, so targets
 		 * shouldn't be empty.
 		 */
 	case SP_NOT:
 		/* Nothing special here -- targets can be empty if it wants. */
 		break;
+	}
+}
 static Boolean
 ParseDoDependencyParseOp(char **pp, const char *lstart, GNodeType *out_op)
+{
 	const char *cp = *pp;
 	if (*cp == '!') {
 		*out_op = OP_FORCE;
 		(*pp)++;
 		return TRUE;
+	}
 	if (*cp == ':') {
 		if (cp[1] == ':') {
 			*out_op = OP_DOUBLEDEP;
 			(*pp) += 2;
 		} else {
 			*out_op = OP_DEPENDS;
 			(*pp)++;
+		}
 		return TRUE;
+	}
+	{
 		const char *msg = lstart[0] == '.'
 		    ? "Unknown directive" : "Missing dependency operator";
 		Parse_Error(PARSE_FATAL, "%s", msg);
 		return FALSE;
+	}
+}
 static void
 ClearPaths(SearchPathList *paths)
+{
 	if (paths != NULL) {
 		SearchPathListNode *ln;
 		for (ln = paths->first; ln != NULL; ln = ln->next)
 			SearchPath_Clear(ln->datum);
+	}
 	Dir_SetPATH();
+}
 static void
 ParseDoDependencySourcesEmpty(ParseSpecial specType, SearchPathList *paths)
+{
 	switch (specType) {
 	case SP_SUFFIXES:
 		Suff_ClearSuffixes();
 		break;
 	case SP_PRECIOUS:
 		allPrecious = TRUE;
 		break;
 	case SP_IGNORE:
 		opts.ignoreErrors = TRUE;
 		break;
 	case SP_SILENT:
 		opts.beSilent = TRUE;
 		break;
 	case SP_PATH:
 		ClearPaths(paths);
 		break;
 #ifdef POSIX
 	case SP_POSIX:
 		Var_Set("%POSIX", "1003.2", VAR_GLOBAL);
 		break;
 #endif
 	default:
 		break;
+	}
+}
 static void
 AddToPaths(const char *dir, SearchPathList *paths)
+{
 	if (paths != NULL) {
 		SearchPathListNode *ln;
 		for (ln = paths->first; ln != NULL; ln = ln->next)
 			(void)Dir_AddDir(ln->datum, dir);
+	}
+}
 /*
  * If the target was one that doesn't take files as its sources
  * but takes something like suffixes, we take each
  * space-separated word on the line as a something and deal
  * with it accordingly.
+ *
  * If the target was .SUFFIXES, we take each source as a
  * suffix and add it to the list of suffixes maintained by the
  * Suff module.
+ *
  * If the target was a .PATH, we add the source as a directory
  * to search on the search path.
+ *
  * If it was .INCLUDES, the source is taken to be the suffix of
  * files which will be #included and whose search path should
  * be present in the .INCLUDES variable.
+ *
  * If it was .LIBS, the source is taken to be the suffix of
  * files which are considered libraries and whose search path
  * should be present in the .LIBS variable.
+ *
  * If it was .NULL, the source is the suffix to use when a file
  * has no valid suffix.
+ *
  * If it was .OBJDIR, the source is a new definition for .OBJDIR,
  * and will cause make to do a new chdir to that path.
  */
 static void
 ParseDoDependencySourceSpecial(ParseSpecial specType, char *word,
 			       SearchPathList *paths)
+{
 	switch (specType) {
 	case SP_SUFFIXES:
 		Suff_AddSuffix(word, &mainNode);
 		break;
 	case SP_PATH:
 		AddToPaths(word, paths);
 		break;
 	case SP_INCLUDES:
 		Suff_AddInclude(word);
 		break;
 	case SP_LIBS:
 		Suff_AddLib(word);
 		break;
 	case SP_NULL:
 		Suff_SetNull(word);
 		break;
 	case SP_OBJDIR:
 		Main_SetObjdir(FALSE, "%s", word);
 		break;
 	default:
 		break;
+	}
+}
 static Boolean
 ParseDoDependencyTargets(char **inout_cp,
 			 char **inout_line,
 			 const char *lstart,
 			 ParseSpecial *inout_specType,
 			 GNodeType *inout_tOp,
 			 SearchPathList **inout_paths,
 			 StringList *curTargs)
+{
 	char *cp;
 	char *tgt = *inout_line;
 	char savec;
 	const char *p;
 	for (;;) {
 		/*
 		 * Here LINE points to the beginning of the next word, and
 		 * LSTART points to the actual beginning of the line.
 		 */
 		/* Find the end of the next word. */
 		cp = tgt;
 		p = cp;
 		ParseDependencyTargetWord(&p, lstart);
 		cp += p - cp;
 		/*
 		 * If the word is followed by a left parenthesis, it's the
 		 * name of an object file inside an archive (ar file).
 		 */
 		if (!ParseIsEscaped(lstart, cp) && *cp == '(') {
 			/*
 			 * Archives must be handled specially to make sure the
 			 * OP_ARCHV flag is set in their 'type' field, for one
 			 * thing, and because things like "archive(file1.o
 			 * file2.o file3.o)" are permissible.
+			 *
 			 * Arch_ParseArchive will set 'line' to be the first
 			 * non-blank after the archive-spec. It creates/finds
 			 * nodes for the members and places them on the given
 			 * list, returning TRUE if all went well and FALSE if
 			 * there was an error in the specification. On error,
 			 * line should remain untouched.
 			 */
 			if (!Arch_ParseArchive(&tgt, targets, VAR_CMDLINE)) {
 				Parse_Error(PARSE_FATAL,
 				    "Error in archive specification: \"%s\"",
 				    tgt);
 				return FALSE;
+			}
 			cp = tgt;
 			continue;
+		}
 		if (*cp == '\0') {
 			ParseErrorNoDependency(lstart);
 			return FALSE;
+		}
 		/* Insert a null terminator. */
 		savec = *cp;
 		*cp = '\0';
 		if (!ParseDoDependencyTarget(tgt, inout_specType, inout_tOp,
 		    inout_paths))
 			return FALSE;
 		/*
 		 * Have word in line. Get or create its node and stick it at
 		 * the end of the targets list
 		 */
 		if (*inout_specType == SP_NOT && *tgt != '\0')
 			ParseDoDependencyTargetMundane(tgt, curTargs);
 		else if (*inout_specType == SP_PATH && *tgt != '.' &&
 			 *tgt != '\0')
 			Parse_Error(PARSE_WARNING, "Extra target (%s) ignored",
 			    tgt);
 		/* Don't need the inserted null terminator any more. */
 		*cp = savec;
 		/*
 		 * If it is a special type and not .PATH, it's the only target
 		 * we allow on this line.
 		 */
 		if (*inout_specType != SP_NOT && *inout_specType != SP_PATH)
 			ParseDoDependencyTargetExtraWarn(&cp, lstart);
 		else
 			pp_skip_whitespace(&cp);
 		tgt = cp;
 		if (*tgt == '\0')
 			break;
 		if ((*tgt == '!' || *tgt == ':') &&
 		    !ParseIsEscaped(lstart, tgt))
 			break;
+	}
 	*inout_cp = cp;
 	*inout_line = tgt;
 	return TRUE;
+}
 static void
 ParseDoDependencySourcesSpecial(char *start, char *end,
 				ParseSpecial specType, SearchPathList *paths)
+{
 	char savec;
 	while (*start != '\0') {
 		while (*end != '\0' && !ch_isspace(*end))
 			end++;
 		savec = *end;
 		*end = '\0';
 		ParseDoDependencySourceSpecial(specType, start, paths);
 		*end = savec;
 		if (savec != '\0')
 			end++;
 		pp_skip_whitespace(&end);
 		start = end;
+	}
+}
 static Boolean
 ParseDoDependencySourcesMundane(char *start, char *end,
 				ParseSpecial specType, GNodeType tOp)
+{
 	while (*start != '\0') {
 		/*
 		 * The targets take real sources, so we must beware of archive
 		 * specifications (i.e. things with left parentheses in them)
 		 * and handle them accordingly.
 		 */
 		for (; *end != '\0' && !ch_isspace(*end); end++) {
 			if (*end == '(' && end > start && end[-1] != '$') {
 				/*
 				 * Only stop for a left parenthesis if it
 				 * isn't at the start of a word (that'll be
 				 * for variable changes later) and isn't
 				 * preceded by a dollar sign (a dynamic
 				 * source).
 				 */
 				break;
+			}
+		}
 		if (*end == '(') {
 			GNodeList sources = LST_INIT;
 			if (!Arch_ParseArchive(&start, &sources, VAR_CMDLINE)) {
 				Parse_Error(PARSE_FATAL,
 				    "Error in source archive spec \"%s\"",
 				    start);
 				return FALSE;
+			}
 			while (!Lst_IsEmpty(&sources)) {
 				GNode *gn = Lst_Dequeue(&sources);
 				ParseDependencySource(tOp, gn->name, specType);
+			}
 			Lst_Done(&sources);
 			end = start;
 		} else {
 			if (*end != '\0') {
 				*end = '\0';
 				end++;
+			}
 			ParseDependencySource(tOp, start, specType);
+		}
 		pp_skip_whitespace(&end);
 		start = end;
+	}
 	return TRUE;
+}
 /* Parse a dependency line consisting of targets, followed by a dependency
  * operator, optionally followed by sources.
+ *
  * The nodes of the sources are linked as children to the nodes of the
  * targets. Nodes are created as necessary.
+ *
  * The operator is applied to each node in the global 'targets' list,
  * which is where the nodes found for the targets are kept, by means of
  * the ParseDoOp function.
+ *
  * The sources are parsed in much the same way as the targets, except
  * that they are expanded using the wildcarding scheme of the C-Shell,
  * and a target is created for each expanded word. Each of the resulting
  * nodes is then linked to each of the targets as one of its children.
+ *
  * Certain targets and sources such as .PHONY or .PRECIOUS are handled
  * specially. These are the ones detailed by the specType variable.
+ *
  * The storing of transformation rules such as '.c.o' is also taken care of
  * here. A target is recognized as a transformation rule by calling
  * Suff_IsTransform. If it is a transformation rule, its node is gotten
  * from the suffix module via Suff_AddTransform rather than the standard
  * Targ_FindNode in the target module.
+ *
  * Upon return, the value of the line is unspecified.
  */
 static void
 ParseDoDependency(char *line)
+{
 	char *cp;		/* our current position */
 	GNodeType op;		/* the operator on the line */
 	SearchPathList *paths;	/* search paths to alter when parsing
 				 * a list of .PATH targets */
 	GNodeType tOp;		/* operator from special target */
 	/* target names to be found and added to the targets list */
 	StringList curTargs = LST_INIT;
 	char *lstart = line;
 	/*
 	 * specType contains the SPECial TYPE of the current target. It is
 	 * SP_NOT if the target is unspecial. If it *is* special, however, the
 	 * children are linked as children of the parent but not vice versa.
 	 */
 	ParseSpecial specType = SP_NOT;
 	DEBUG1(PARSE, "ParseDoDependency(%s)\n", line);
 	tOp = OP_NONE;
 	paths = NULL;
 	/*
 	 * First, grind through the targets.
 	 */
 	/* XXX: don't use line as an iterator variable */
 	if (!ParseDoDependencyTargets(&cp, &line, lstart, &specType, &tOp,
 	    &paths, &curTargs))
 		goto out;
 	/*
 	 * Don't need the list of target names anymore.
 	 * The targets themselves are now in the global variable 'targets'.
 	 */
 	Lst_Done(&curTargs);
 	Lst_Init(&curTargs);
 	if (!Lst_IsEmpty(targets))
 		ParseDoDependencyCheckSpec(specType);
 	/*
 	 * Have now parsed all the target names. Must parse the operator next.
 	 */
 	if (!ParseDoDependencyParseOp(&cp, lstart, &op))
 		goto out;
 	/*
 	 * Apply the operator to the target. This is how we remember which
 	 * operator a target was defined with. It fails if the operator
 	 * used isn't consistent across all references.
 	 */
 	ApplyDependencyOperator(op);
 	/*
 	 * Onward to the sources.
+	 *
 	 * LINE will now point to the first source word, if any, or the
 	 * end of the string if not.
 	 */
 	pp_skip_whitespace(&cp);
 	line = cp;		/* XXX: 'line' is an inappropriate name */
 	/*
 	 * Several special targets take different actions if present with no
 	 * sources:
 	 *	a .SUFFIXES line with no sources clears out all old suffixes
 	 *	a .PRECIOUS line makes all targets precious
 	 *	a .IGNORE line ignores errors for all targets
 	 *	a .SILENT line creates silence when making all targets
 	 *	a .PATH removes all directories from the search path(s).
 	 */
 	if (line[0] == '\0') {
 		ParseDoDependencySourcesEmpty(specType, paths);
 	} else if (specType == SP_MFLAGS) {
 		/*
 		 * Call on functions in main.c to deal with these arguments and
 		 * set the initial character to a null-character so the loop to
 		 * get sources won't get anything
 		 */
 		Main_ParseArgLine(line);
 		*line = '\0';
 	} else if (specType == SP_SHELL) {
 		if (!Job_ParseShell(line)) {
 			Parse_Error(PARSE_FATAL,
 			    "improper shell specification");
 			goto out;
+		}
 		*line = '\0';
 	} else if (specType == SP_NOTPARALLEL || specType == SP_SINGLESHELL ||
 		   specType == SP_DELETE_ON_ERROR) {
 		*line = '\0';
+	}
 	/* Now go for the sources. */
 	if (specType == SP_SUFFIXES || specType == SP_PATH ||
 	    specType == SP_INCLUDES || specType == SP_LIBS ||
 	    specType == SP_NULL || specType == SP_OBJDIR) {
 		ParseDoDependencySourcesSpecial(line, cp, specType, paths);
 		if (paths != NULL) {
 			Lst_Free(paths);
 			paths = NULL;
+		}
 		if (specType == SP_PATH)
 			Dir_SetPATH();
 	} else {
 		assert(paths == NULL);
 		if (!ParseDoDependencySourcesMundane(line, cp, specType, tOp))
 			goto out;
+	}
 	FindMainTarget();
 out:
 	if (paths != NULL)
 		Lst_Free(paths);
 	Lst_Done(&curTargs);
+}
 typedef struct VarAssignParsed {
 	const char *nameStart;	/* unexpanded */
 	const char *nameEnd;	/* before operator adjustment */
 	const char *eq;		/* the '=' of the assignment operator */
 } VarAssignParsed;
 /*
  * Determine the assignment operator and adjust the end of the variable
  * name accordingly.
  */
 static void
 AdjustVarassignOp(const VarAssignParsed *pvar, const char *value,
 		  VarAssign *out_var)
+{
 	const char *op = pvar->eq;
 	const char *const name = pvar->nameStart;
 	VarAssignOp type;
 	if (op > name && op[-1] == '+') {
 		type = VAR_APPEND;
 		op--;
 	} else if (op > name && op[-1] == '?') {
 		op--;
 		type = VAR_DEFAULT;
 	} else if (op > name && op[-1] == ':') {
 		op--;
 		type = VAR_SUBST;
 	} else if (op > name && op[-1] == '!') {
 		op--;
 		type = VAR_SHELL;
 	} else {
 		type = VAR_NORMAL;
 #ifdef SUNSHCMD
 		while (op > name && ch_isspace(op[-1]))
 			op--;
 		if (op >= name + 3 && op[-3] == ':' && op[-2] == 's' &&
 		    op[-1] == 'h') {
 			type = VAR_SHELL;
 			op -= 3;
+		}
 #endif
+	}
+	{
 		const char *nameEnd = pvar->nameEnd < op ? pvar->nameEnd : op;
 		out_var->varname = bmake_strsedup(pvar->nameStart, nameEnd);
 		out_var->op = type;
 		out_var->value = value;
+	}
+}
 /*
  * Parse a variable assignment, consisting of a single-word variable name,
  * optional whitespace, an assignment operator, optional whitespace and the
  * variable value.
+ *
  * Note: There is a lexical ambiguity with assignment modifier characters
  * in variable names. This routine interprets the character before the =
  * as a modifier. Therefore, an assignment like
  *	C++=/usr/bin/CC
  * is interpreted as "C+ +=" instead of "C++ =".
+ *
  * Used for both lines in a file and command line arguments.
  */
 Boolean
 Parse_IsVar(const char *p, VarAssign *out_var)
+{
 	VarAssignParsed pvar;
 	const char *firstSpace = NULL;
 	int level = 0;
 	cpp_skip_hspace(&p);	/* Skip to variable name */
 	/*
 	 * During parsing, the '+' of the '+=' operator is initially parsed
 	 * as part of the variable name.  It is later corrected, as is the
 	 * ':sh' modifier. Of these two (nameEnd and op), the earlier one
 	 * determines the actual end of the variable name.
 	 */
 	pvar.nameStart = p;
 #ifdef CLEANUP
 	pvar.nameEnd = NULL;
 	pvar.eq = NULL;
 #endif
 	/*
 	 * Scan for one of the assignment operators outside a variable
 	 * expansion.
 	 */
 	while (*p != '\0') {
 		char ch = *p++;
 		if (ch == '(' || ch == '{') {
 			level++;
 			continue;
+		}
 		if (ch == ')' || ch == '}') {
 			level--;
 			continue;
+		}
 		if (level != 0)
 			continue;
 		if (ch == ' ' || ch == '\t')
 			if (firstSpace == NULL)
 				firstSpace = p - 1;
 		while (ch == ' ' || ch == '\t')
 			ch = *p++;
 #ifdef SUNSHCMD
 		if (ch == ':' && p[0] == 's' && p[1] == 'h') {
 			p += 2;
 			continue;
+		}
 #endif
 		if (ch == '=') {
 			pvar.eq = p - 1;
 			pvar.nameEnd = firstSpace != NULL ? firstSpace : p - 1;
 			cpp_skip_whitespace(&p);
 			AdjustVarassignOp(&pvar, p, out_var);
 			return TRUE;
+		}
 		if (*p == '=' &&
 		    (ch == '+' || ch == ':' || ch == '?' || ch == '!')) {
 			pvar.eq = p;
 			pvar.nameEnd = firstSpace != NULL ? firstSpace : p;
 			p++;
 			cpp_skip_whitespace(&p);
 			AdjustVarassignOp(&pvar, p, out_var);
 			return TRUE;
+		}
 		if (firstSpace != NULL)
 			return FALSE;
+	}
 	return FALSE;
+}
 /*
  * Check for syntax errors such as unclosed expressions or unknown modifiers.
  */
 static void
 VarCheckSyntax(VarAssignOp type, const char *uvalue, GNode *ctxt)
+{
 	if (opts.strict) {
 		if (type != VAR_SUBST && strchr(uvalue, '$') != NULL) {
 			char *expandedValue;
 			(void)Var_Subst(uvalue, ctxt, VARE_NONE,
 			    &expandedValue);
 			/* TODO: handle errors */
 			free(expandedValue);
+		}
+	}
+}
 static void
 VarAssign_EvalSubst(const char *name, const char *uvalue, GNode *ctxt,
 		    FStr *out_avalue)
+{
 	const char *avalue;
 	char *evalue;
 	Boolean savedPreserveUndefined = preserveUndefined;
 	/* TODO: Can this assignment to preserveUndefined be moved further down
 	 * to the actually interesting Var_Subst call, without affecting any
 	 * edge cases?
+	 *
 	 * It might affect the implicit expansion of the variable name in the
 	 * Var_Exists and Var_Set calls, even though it's unlikely that anyone
 	 * cared about this edge case when adding this code.  In addition,
 	 * variable assignments should not refer to any undefined variables in
 	 * the variable name. */
 	preserveUndefined = TRUE;
 	/*
 	 * make sure that we set the variable the first time to nothing
 	 * so that it gets substituted!
 	 */
 	if (!Var_Exists(name, ctxt))
 		Var_Set(name, "", ctxt);
 	(void)Var_Subst(uvalue, ctxt, VARE_WANTRES | VARE_KEEP_DOLLAR, &evalue);
 	/* TODO: handle errors */
 	preserveUndefined = savedPreserveUndefined;
 	avalue = evalue;
 	Var_Set(name, avalue, ctxt);
 	*out_avalue = (FStr){ avalue, evalue };
+}
 static void
 VarAssign_EvalShell(const char *name, const char *uvalue, GNode *ctxt,
 		    FStr *out_avalue)
+{
 	FStr cmd;
 	const char *errfmt;
 	char *cmdOut;
 	cmd = FStr_InitRefer(uvalue);
 	if (strchr(cmd.str, '$') != NULL) {
 		char *expanded;
 		(void)Var_Subst(cmd.str, VAR_CMDLINE,
 		    VARE_WANTRES | VARE_UNDEFERR, &expanded);
 		/* TODO: handle errors */
 		cmd = FStr_InitOwn(expanded);
+	}
 	cmdOut = Cmd_Exec(cmd.str, &errfmt);
 	Var_Set(name, cmdOut, ctxt);
 	*out_avalue = FStr_InitOwn(cmdOut);
 	if (errfmt != NULL)
 		Parse_Error(PARSE_WARNING, errfmt, cmd.str);
 	FStr_Done(&cmd);
+}
 /* Perform a variable assignment.
+ *
  * The actual value of the variable is returned in *out_avalue and
  * *out_avalue_freeIt.  Especially for VAR_SUBST and VAR_SHELL this can differ
  * from the literal value.
+ *
  * Return whether the assignment was actually done.  The assignment is only
  * skipped if the operator is '?=' and the variable already exists. */
 static Boolean
 VarAssign_Eval(const char *name, VarAssignOp op, const char *uvalue,
 	       GNode *ctxt, FStr *out_TRUE_avalue)
+{
 	FStr avalue = FStr_InitRefer(uvalue);
 	if (op == VAR_APPEND)
 		Var_Append(name, uvalue, ctxt);
 	else if (op == VAR_SUBST)
 		VarAssign_EvalSubst(name, uvalue, ctxt, &avalue);
 	else if (op == VAR_SHELL)
 		VarAssign_EvalShell(name, uvalue, ctxt, &avalue);
 	else {
 		if (op == VAR_DEFAULT && Var_Exists(name, ctxt))
 			return FALSE;
 		/* Normal assignment -- just do it. */
 		Var_Set(name, uvalue, ctxt);
+	}
 	*out_TRUE_avalue = avalue;
 	return TRUE;
+}
 static void
 VarAssignSpecial(const char *name, const char *avalue)
+{
 	if (strcmp(name, MAKEOVERRIDES) == 0)
 		Main_ExportMAKEFLAGS(FALSE); /* re-export MAKEFLAGS */
 	else if (strcmp(name, ".CURDIR") == 0) {
 		/*
 		 * Someone is being (too?) clever...
 		 * Let's pretend they know what they are doing and
 		 * re-initialize the 'cur' CachedDir.
 		 */
 		Dir_InitCur(avalue);
 		Dir_SetPATH();
 	} else if (strcmp(name, MAKE_JOB_PREFIX) == 0)
 		Job_SetPrefix();
 	else if (strcmp(name, MAKE_EXPORTED) == 0)
 		Var_ExportVars(avalue);
+}
 /* Perform the variable variable assignment in the given context. */
 void
 Parse_DoVar(VarAssign *var, GNode *ctxt)
+{
 	FStr avalue;	/* actual value (maybe expanded) */
 	VarCheckSyntax(var->op, var->value, ctxt);
 	if (VarAssign_Eval(var->varname, var->op, var->value, ctxt, &avalue)) {
 		VarAssignSpecial(var->varname, avalue.str);
 		FStr_Done(&avalue);
+	}
 	free(var->varname);
+}
 /* See if the command possibly calls a sub-make by using the variable
  * expressions ${.MAKE}, ${MAKE} or the plain word "make". */
 static Boolean
 MaybeSubMake(const char *cmd)
+{
 	const char *start;
 	for (start = cmd; *start != '\0'; start++) {
 		const char *p = start;
 		char endc;
 		/* XXX: What if progname != "make"? */
 		if (p[0] == 'm' && p[1] == 'a' && p[2] == 'k' && p[3] == 'e')
 			if (start == cmd || !ch_isalnum(p[-1]))
 				if (!ch_isalnum(p[4]))
 					return TRUE;
 		if (*p != '$')
 			continue;
 		p++;
 		if (*p == '{')
 			endc = '}';
 		else if (*p == '(')
 			endc = ')';
 		else
 			continue;
 		p++;
 		if (*p == '.')	/* Accept either ${.MAKE} or ${MAKE}. */
 			p++;
 		if (p[0] == 'M' && p[1] == 'A' && p[2] == 'K' && p[3] == 'E')