 @@ -1,1619 +1,1616 @@
-/*	$NetBSD: parse.c,v 1.532 2021/01/26 23:44:56 rillig Exp $	*/
+/*	$NetBSD: parse.c,v 1.533 2021/01/27 00:02:38 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/stat.h>
 #include <errno.h>
 #include <stdarg.h>
 #include <stdint.h>
 #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.532 2021/01/26 23:44:56 rillig Exp $");
+MAKE_RCSID("$NetBSD: parse.c,v 1.533 2021/01/27 00:02:38 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 index 0 is the top-level makefile from
  * the command line, followed by the included files or .for loops, up to and
  * including the current file.
+ *
  * See PrintStackTrace for how to interpret the data.
  */
 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 */
 	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, char *buf, size_t buflen)
+{
 	struct loadedfile *lf;
 	lf = bmake_malloc(sizeof *lf);
 	lf->path = path == NULL ? "(stdin)" : path;
 	lf->buf = buf;
 	lf->len = buflen;
 	lf->used = FALSE;
 	return lf;
+}
 static void
 loadedfile_destroy(struct loadedfile *lf)
+{
 	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 1 GiB. 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 > 0x3fffffff)
 		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.
  */
 static struct loadedfile *
 loadfile(const char *path, int fd)
+{
 	ssize_t n;
 	Buffer buf;
 	size_t filesize;
 	if (path == NULL) {
 		assert(fd == -1);
 		fd = STDIN_FILENO;
+	}
 	if (load_getsize(fd, &filesize)) {
 		/*
 		 * Avoid resizing the buffer later for no reason.
+		 *
 		 * At the same time leave space for adding a final '\n',
 		 * just in case it is missing in the file.
 		 */
 		filesize++;
 	} else
 		filesize = 1024;
 	Buf_InitSize(&buf, filesize);
 	for (;;) {
 		assert(buf.len <= buf.cap);
 		if (buf.len == buf.cap) {
 			if (buf.cap > 0x1fffffff) {
 				errno = EFBIG;
 				Error("%s: file too large", path);
 				exit(2); /* Not 1 so -q can distinguish error */
+			}
 			Buf_Expand(&buf);
+		}
 		assert(buf.len < buf.cap);
 		n = read(fd, buf.data + buf.len, buf.cap - buf.len);
 		if (n < 0) {
 			Error("%s: read error: %s", path, strerror(errno));
 			exit(2);	/* Not 1 so -q can distinguish error */
+		}
 		if (n == 0)
 			break;
 		buf.len += (size_t)n;
+	}
 	assert(buf.len <= buf.cap);
 	if (!Buf_EndsWith(&buf, '\n'))
 		Buf_AddByte(&buf, '\n');
 	if (path != NULL)
 		close(fd);
+	{
 		struct loadedfile *lf = loadedfile_create(path,
 		    buf.data, buf.len);
 		Buf_Destroy(&buf, FALSE);
 		return lf;
+	}
+}
 static void
 PrintStackTrace(void)
+{
 	const IFile *entries;
 	size_t i, n;
 	if (!(DEBUG(PARSE)))
 		return;
 	entries = GetInclude(0);
 	n = includes.len;
 	if (n == 0)
 		return;
 	n--;			/* This entry is already in the diagnostic. */
 	/*
 	 * For the IFiles with fromForLoop, lineno seems to be sorted
 	 * backwards.  This is because lineno is the number of completely
 	 * parsed lines, which for a .for loop is right after the
 	 * corresponding .endfor.  The intuitive line number comes from
 	 * first_lineno instead, which points at the start of the .for loop.
+	 *
 	 * To make the stack trace intuitive, the entry below each chain of
 	 * .for loop entries must be ignored completely since neither its
 	 * lineno nor its first_lineno is useful.  Instead, the topmost of
 	 * each chain of .for loop entries needs to be printed twice, once
 	 * with its first_lineno and once with its lineno.
 	 */
 	for (i = n; i-- > 0;) {
 		const IFile *entry = entries + i;
 		const char *fname = entry->fname;
 		Boolean printLineno;
 		char dirbuf[MAXPATHLEN + 1];
 		if (fname[0] != '/' && strcmp(fname, "(stdin)") != 0)
 			fname = realpath(fname, dirbuf);
 		printLineno = !entry->fromForLoop;
 		if (i + 1 < n && entries[i + 1].fromForLoop == printLineno)
 			printLineno = entry->fromForLoop;
 		if (printLineno)
 			debug_printf("\tin .include from %s:%d\n",
 			    fname, entry->lineno);
 		if (entry->fromForLoop)
 			debug_printf("\tin .for loop from %s:%d\n",
 			    fname, entry->first_lineno);
+	}
+}
 /* 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)
 		goto print_stack_trace;
-	if (type == PARSE_FATAL || opts.parseWarnFatal)
+	if (type == PARSE_WARNING && !opts.parseWarnFatal)
-		fatals++;
+		goto print_stack_trace;
-	if (opts.parseWarnFatal && !fatal_warning_error_printed) {
+	fatals++;
-		/*
+	if (type == PARSE_WARNING && !fatal_warning_error_printed) {
 		 * FIXME: Also gets printed on .error, even though it
 		 *  doesn't apply to it.
 		 */
 		Error("parsing warnings being treated as errors");
 		fatal_warning_error_printed = TRUE;
+	}
 print_stack_trace:
 	PrintStackTrace();
+}
 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;
 			(void)Var_Parse(&nested_p, VAR_CMDLINE, VARE_NONE,
 			    &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 *targetName,
 			       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(targetName);
 		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 *suffixName,
 			    SearchPathList **inout_paths)
+{
 	SearchPath *path;
 	path = Suff_GetPath(suffixName);
 	if (path == NULL) {
 		Parse_Error(PARSE_FATAL,
 		    "Suffix '%s' not defined (yet)", suffixName);
 		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 *targetName,
 			ParseSpecial *inout_specType,
 			GNodeType *out_tOp, SearchPathList **inout_paths)
+{
 	int keywd;
 	if (!(targetName[0] == '.' && ch_isupper(targetName[1])))
 		return TRUE;
 	/*
 	 * See if the target is a special target that must have it
 	 * or its sources handled specially.
 	 */
 	keywd = ParseFindKeyword(targetName);
 	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, targetName,
 		    inout_paths);
 	} else if (strncmp(targetName, ".PATH", 5) == 0) {
 		*inout_specType = SP_PATH;
 		if (!ParseDoDependencyTargetPath(targetName + 5, inout_paths))
 			return FALSE;
+	}
 	return TRUE;
+}
 static void
 ParseDoDependencyTargetMundane(char *targetName, StringList *curTargs)
+{
 	if (Dir_HasWildcards(targetName)) {
 		/*
 		 * 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();
 		SearchPath_Expand(emptyPath, targetName, 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, targetName);
+	}
 	/* 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)SearchPath_Add(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;

 @@ -1,5 +1,4 @@
-make: "directive-error.mk" line 11: message
+make: "directive-error.mk" line 13: message
 make: parsing warnings being treated as errors
 make: stopped in unit-tests
 exit status 1

 @@ -1,11 +1,13 @@
-# $NetBSD: directive-error.mk,v 1.4 2021/01/26 23:51:20 rillig Exp $
+# $NetBSD: directive-error.mk,v 1.5 2021/01/27 00:02:38 rillig Exp $
+#
 # Tests for the .error directive, which prints an error message and exits
 # immediately, unlike other "fatal" parse errors, which continue to parse
 # until the end of the current top-level makefile.
+#
 # See also:
 #	opt-warnings-as-errors.mk
-# TODO: Implementation
+# Before parse.c 1.532 from 2021-01-27, the ".error" issued an irrelevant
 # message saying "parsing warnings being treated as errors".
 # FIXME: The "parsing warnings being treated as errors" is irrelevant.
 .MAKEFLAGS: -W
 .error message

 @@ -1,13 +1,18 @@
-# $NetBSD: opt-warnings-as-errors.mk,v 1.4 2020/11/09 20:50:56 rillig Exp $
+# $NetBSD: opt-warnings-as-errors.mk,v 1.5 2021/01/27 00:02:38 rillig Exp $
+#
 # Tests for the -W command line option, which turns warnings into errors.
+#
 # Even in -W mode, a .warning is not completely equivalent to an .error.
 # First, the word "warning" is still printed, and second, parsing continues
 # after a failed warning, whereas it would stop immediately at the first
 # .error.
 .MAKEFLAGS: -W
 .warning message 1
 .warning message 2
 _!=	echo 'parsing continues' 1>&2
 all:
 	@:;

 @@ -1,7 +1,7 @@
-make: "opt-warnings-as-errors.mk" line 7: warning: message 1
+make: "opt-warnings-as-errors.mk" line 12: warning: message 1
 make: parsing warnings being treated as errors
-make: "opt-warnings-as-errors.mk" line 8: warning: message 2
+make: "opt-warnings-as-errors.mk" line 13: warning: message 2
 parsing continues
 make: Fatal errors encountered -- cannot continue
 make: stopped in unit-tests
 exit status 1