 @@ -1,14 +1,14 @@
-/*	$NetBSD: job.c,v 1.422 2021/04/03 14:39:02 rillig Exp $	*/
+/*	$NetBSD: job.c,v 1.423 2021/04/04 09:58:51 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990 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.
 @@ -132,27 +132,27 @@
 #ifndef USE_SELECT
 #include <poll.h>
 #endif
 #include <signal.h>
 #include <utime.h>
 #include "make.h"
 #include "dir.h"
 #include "job.h"
 #include "pathnames.h"
 #include "trace.h"
 /*	"@(#)job.c	8.2 (Berkeley) 3/19/94"	*/
-MAKE_RCSID("$NetBSD: job.c,v 1.422 2021/04/03 14:39:02 rillig Exp $");
+MAKE_RCSID("$NetBSD: job.c,v 1.423 2021/04/04 09:58:51 rillig Exp $");
 /*
  * A shell defines how the commands are run.  All commands for a target are
  * written into a single file, which is then given to the shell to execute
  * the commands from it.  The commands are written to the file using a few
  * templates for echo control and error control.
+ *
  * The name of the shell is the basename for the predefined shells, such as
  * "sh", "csh", "bash".  For custom shells, it is the full pathname, and its
  * basename is used to select the type of shell; the longest match wins.
  * So /usr/pkg/bin/bash has type sh, /usr/local/bin/tcsh has type csh.
+ *
  * The echoing of command lines is controlled using hasEchoCtl, echoOff,
 @@ -1719,27 +1719,27 @@ JobStart(GNode *gn, bool special)
 	/* Create the pipe by which we'll get the shell's output. */
 	JobCreatePipe(job, 3);
 	JobExec(job, argv);
 	return JOB_RUNNING;
+}
 /*
  * Print the output of the shell command, skipping the noPrint text of the
  * shell, if any.  The default shell does not have noPrint though, which means
  * that in all practical cases, handling the output is left to the caller.
  */
 static char *
-JobOutput(char *cp, char *endp)	/* XXX: should all be const */
+PrintOutput(char *cp, char *endp)	/* XXX: should all be const */
+{
 	char *ecp;		/* XXX: should be const */
 	if (shell->noPrint == NULL || shell->noPrint[0] == '\0')
 		return cp;
 	/*
 	 * XXX: What happens if shell->noPrint occurs on the boundary of
 	 * the buffer?  To work correctly in all cases, this should rather
 	 * be a proper stream filter instead of doing string matching on
 	 * selected chunks of the output.
 	 */
 	while ((ecp = strstr(cp, shell->noPrint)) != NULL) {
 @@ -1856,27 +1856,27 @@ again:
 		 * Need to send the output to the screen. Null terminate it
 		 * first, overwriting the newline character if there was one.
 		 * So long as the line isn't one we should filter (according
 		 * to the shell description), we print the line, preceded
 		 * by a target banner if this target isn't the same as the
 		 * one for which we last printed something.
 		 * The rest of the data in the buffer are then shifted down
 		 * to the start of the buffer and curPos is set accordingly.
 		 */
 		job->outBuf[i] = '\0';
 		if (i >= job->curPos) {
 			char *cp;
-			cp = JobOutput(job->outBuf, &job->outBuf[i]);
+			cp = PrintOutput(job->outBuf, &job->outBuf[i]);
 			/*
 			 * There's still more in that thar buffer. This time,
 			 * though, we know there's no newline at the end, so
 			 * we add one of our own free will.
 			 */
 			if (*cp != '\0') {
 				if (!opts.beSilent)
 					SwitchOutputTo(job->node);
 #ifdef USE_META
 				if (useMeta) {
 					meta_job_output(job, cp,
 					    gotNL ? "\n" : "");

 @@ -1,14 +1,14 @@
-/*	$NetBSD: parse.c,v 1.554 2021/04/03 14:31:44 rillig Exp $	*/
+/*	$NetBSD: parse.c,v 1.555 2021/04/04 09:58:51 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.
 @@ -99,27 +99,27 @@
 #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.554 2021/04/03 14:31:44 rillig Exp $");
+MAKE_RCSID("$NetBSD: parse.c,v 1.555 2021/04/04 09:58:51 rillig Exp $");
 /* types and constants */
 /*
  * Structure for a file being read ("included file")
  */
 typedef struct IFile {
 	char *fname;		/* name of file (relative? absolute?) */
 	bool 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 */
 	bool depending;	/* state of doing_depend on EOF */
 @@ -2827,27 +2827,27 @@ ParseSkippedBranches(void)
+{
 	char *line;
 	while ((line = ParseGetLine(GLM_DOT)) != NULL) {
 		if (Cond_EvalLine(line) == COND_PARSE)
 			break;
 		/*
 		 * TODO: Check for typos in .elif directives
 		 * such as .elsif or .elseif.
+		 *
 		 * This check will probably duplicate some of
 		 * the code in ParseLine.  Most of the code
 		 * there cannot apply, only ParseVarassign and
-		 * ParseDependency can, and to prevent code
+		 * ParseDependencyLine can, and to prevent code
 		 * duplication, these would need to be called
 		 * with a flag called onlyCheckSyntax.
+		 *
 		 * See directive-elif.mk for details.
 		 */
+	}
 	return line != NULL;
+}
 static bool
 ParseForLoop(const char *line)
+{
 @@ -3069,27 +3069,27 @@ FindSemicolon(char *p)
 		else if (level > 0 && (*p == ')' || *p == '}'))
 			level--;
 		else if (level == 0 && *p == ';')
 			break;
+	}
 	return p;
+}
 /*
  * dependency	-> target... op [source...]
  * op		-> ':' | '::' | '!'
  */
 static void
-ParseDependency(char *line)
+ParseDependencyLine(char *line)
+{
 	VarEvalFlags eflags;
 	char *expanded_line;
 	const char *shellcmd = NULL;
 	/*
 	 * For some reason - probably to make the parser impossible -
 	 * a ';' can be used to separate commands from dependencies.
 	 * Attempt to avoid ';' inside substitution patterns.
 	 */
+	{
 		char *semicolon = FindSemicolon(line);
 		if (*semicolon != '\0') {
 @@ -3180,27 +3180,27 @@ ParseLine(char *line)
 		/*
 		 * It's a Gmake "export".
 		 */
 		ParseGmakeExport(line);
 		return;
+	}
 #endif
 	if (ParseVarassign(line))
 		return;
 	FinishDependencyGroup();
-	ParseDependency(line);
+	ParseDependencyLine(line);
+}
 /*
  * Parse a top-level makefile, incorporating its content into the global
  * dependency graph.
+ *
  * Input:
  *	name		The name of the file being read
  *	fd		The open file to parse; will be closed at the end
  */
 void
 Parse_File(const char *name, int fd)
+{

 @@ -1,29 +1,29 @@
-# $NetBSD: directive-for-errors.mk,v 1.1 2020/12/31 03:05:12 rillig Exp $
+# $NetBSD: directive-for-errors.mk,v 1.2 2021/04/04 09:58:51 rillig Exp $
+#
 # Tests for error handling in .for loops.
 # A .for directive must be followed by whitespace, everything else results
 # in a parse error.
 .fori in 1 2 3
 .  warning ${i}
 .endfor
 # A slash is not whitespace, therefore this is not parsed as a .for loop.
+#
 # XXX: The error message is misleading though.  As of 2020-12-31, it says
 # "Unknown directive "for"", but that directive is actually known.  This is
 # because ForEval does not detect the .for loop as such, so parsing
-# continues in ParseLine > ParseDependency > ParseDoDependency >
+# continues in ParseLine > ParseDependencyLine > ParseDoDependency >
 # ParseDoDependencyTargets > ParseErrorNoDependency, and there the directive
 # name is parsed a bit differently.
 .for/i in 1 2 3
 .  warning ${i}
 .endfor
 # As of 2020-12-31, the variable name can be an arbitrary word, it just needs
 # to be separated by whitespace.  Even '$' and '\' are valid variable names,
 # which is not useful in practice.
+#
 # The '$$' is not replaced with the values '1' or '3' from the .for loop,
 # instead it is kept as-is, and when the .info directive expands its argument,
 # each '$$' gets replaced with a single '$'.  The "long variable expression"

 @@ -1,39 +1,39 @@
-# $NetBSD: opt-jobs-no-action.mk,v 1.8 2020/12/10 23:54:41 rillig Exp $
+# $NetBSD: opt-jobs-no-action.mk,v 1.9 2021/04/04 09:58:51 rillig Exp $
+#
 # Tests for the combination of the options -j and -n, which prints the
 # commands instead of actually running them.
+#
 # The format of the output differs from the output of only the -n option,
 # without the -j.  This is because all this code is implemented twice, once
 # in compat.c and once in job.c.
+#
 # See also:
 #	opt-jobs.mk
 #		The corresponding tests without the -n option
 #	opt-no-action-combined.mk
 #		The corresponding tests without the -j option
 .MAKEFLAGS: -j1 -n
 # Change the templates for running the commands in jobs mode, to make it
 # easier to see what actually happens.
+#
 # The shell attributes are handled by Job_ParseShell.
 # The shell attributes 'quiet' and 'echo' don't need a trailing newline,
 # this is handled by the [0] != '\0' checks in Job_ParseShell.
 # The '\#' is handled by ParseGetLine.
 # The '\n' is handled by Str_Words in Job_ParseShell.
-# The '$$' is handled by Var_Subst in ParseDependency.
+# The '$$' is handled by Var_Subst in ParseDependencyLine.
 .SHELL: \
 	name=sh \
 	path=${.SHELL} \
 	quiet="\# .echoOff" \
 	echo="\# .echoOn" \
 	filter="\# .noPrint\n" \
 	check="\# .echoTmpl\n""echo \"%s\"\n" \
 	ignore="\# .runIgnTmpl\n""%s\n" \
 	errout="\# .runChkTmpl\n""{ %s \n} || exit $$?\n"
 all: explained combined
 .ORDER: explained combined

 @@ -1,28 +1,28 @@
-# $NetBSD: shell-csh.mk,v 1.7 2020/12/13 02:09:55 sjg Exp $
+# $NetBSD: shell-csh.mk,v 1.8 2021/04/04 09:58:51 rillig Exp $
+#
 # Tests for using a C shell for running the commands.
 CSH!=	which csh 2> /dev/null || true
 # The shell path must be an absolute path.
 # This is only obvious in parallel mode since in compat mode,
 # simple commands are executed via execve directly.
 .if ${CSH} != ""
 .SHELL: name="csh" path="${CSH}"
 .endif
 # In parallel mode, the shell->noPrint command is filtered from
-# the output, rather naively (in JobOutput).
+# the output, rather naively (in PrintOutput).
+#
 # Until 2020-10-03, the output in parallel mode was garbled because
 # the definition of the csh had been wrong since 1993 at least.
 .MAKEFLAGS: -j1
 all:
 .if ${CSH} != ""
 	# This command is both printed and executed.
 	echo normal
 	# This command is only executed.
 	@echo hidden