 @@ -1,14 +1,14 @@
-/*	$NetBSD: job.c,v 1.347 2020/12/08 19:58:20 rillig Exp $	*/
+/*	$NetBSD: job.c,v 1.348 2020/12/08 20:04:17 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.
 @@ -133,27 +133,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.347 2020/12/08 19:58:20 rillig Exp $");
+MAKE_RCSID("$NetBSD: job.c,v 1.348 2020/12/08 20:04:17 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,
 @@ -212,26 +212,28 @@ typedef struct Shell {
 	const char *newline;
 	char commentChar;	/* character used by shell for comment lines */
 	/*
 	 * command-line flags
 	 */
 	const char *echo;	/* echo commands */
 	const char *exit;	/* exit on error */
 } Shell;
 typedef struct RunFlags {
 	/* true if we put a no echo command into the command file */
 	Boolean silent;
 	Boolean always;
 } RunFlags;
 /*
  * error handling variables
  */
 static int job_errors = 0;	/* number of errors reported */
 typedef enum AbortReason {	/* why is the make aborting? */
 	ABORT_NONE,
 	ABORT_ERROR,		/* Because of an error */
 	ABORT_INTERRUPT,	/* Because it was interrupted */
 	ABORT_WAIT		/* Waiting for jobs to finish */
 } AbortReason;
 static AbortReason aborting = ABORT_NONE;
 @@ -665,42 +667,40 @@ JobFindPid(int pid, JobStatus status, Bo
 	Job *job;
 	for (job = job_table; job < job_table_end; job++) {
 		if (job->status == status && job->pid == pid)
 			return job;
+	}
 	if (DEBUG(JOB) && isJobs)
 		job_table_dump("no pid");
 	return NULL;
+}
 /* Parse leading '@', '-' and '+', which control the exact execution mode. */
 static void
-ParseRunOptions(char **pp,
+ParseRunOptions(char **pp, RunFlags *out_runFlags, Boolean *out_errOff)
 		RunFlags *out_runFlags, Boolean *out_errOff,
 		Boolean *out_runAlways)
+{
 	char *p = *pp;
 	out_runFlags->silent = FALSE;
 	*out_errOff = FALSE;
-	*out_runAlways = FALSE;
+	out_runFlags->always = FALSE;
 	for (;;) {
 		if (*p == '@')
 			out_runFlags->silent = !DEBUG(LOUD);
 		else if (*p == '-')
 			*out_errOff = TRUE;
 		else if (*p == '+')
-			*out_runAlways = TRUE;
+			out_runFlags->always = TRUE;
 		else
 			break;
 		p++;
+	}
 	pp_skip_whitespace(&p);
 	*pp = p;
+}
 /* Escape a string for a double-quoted string literal in sh, csh and ksh. */
 static char *
 EscapeShellDblQuot(const char *cmd)
 @@ -732,29 +732,29 @@ JobPrintf(Job *job, const char *fmt, con
 static void
 JobPrintln(Job *job, const char *line)
+{
 	JobPrintf(job, "%s\n", line);
+}
 /*
  * We don't want the error-control commands showing up either, so we turn
  * off echoing while executing them. We could put another field in the shell
  * structure to tell JobDoOutput to look for this string too, but why make
  * it any more complex than it already is?
  */
 static void
-JobPrintSpecialsErrCtl(Job *job, Boolean shutUp)
+JobPrintSpecialsErrCtl(Job *job, Boolean silent)
+{
-	if (!(job->flags & JOB_SILENT) && !shutUp && commandShell->hasEchoCtl) {
+	if (!(job->flags & JOB_SILENT) && !silent && commandShell->hasEchoCtl) {
 		JobPrintln(job, commandShell->echoOff);
 		JobPrintln(job, commandShell->errOffOrExecIgnore);
 		JobPrintln(job, commandShell->echoOn);
 	} else {
 		JobPrintln(job, commandShell->errOffOrExecIgnore);
+	}
+}
 /*
  * The shell has no error control, so we need to be weird to get it to
  * ignore any errors from the command. If echoing is turned on, we turn it
  * off and use the errOnOrEcho template to echo the command. Leave echoing
  * off so the user doesn't see the weirdness we go through to ignore errors.
 @@ -826,45 +826,44 @@ JobPrintCommand(Job *job, char *cmd)
 	const char *const cmdp = cmd;
 	/*
 	 * true if we shouldn't worry about inserting special commands into
 	 * the input stream.
 	 */
 	Boolean noSpecials;
 	RunFlags runFlags;
 	/*
 	 * true if we turned error checking off before printing the command
 	 * and need to turn it back on
 	 */
 	Boolean errOff;
 	Boolean runAlways;
 	/* Template to use when printing the command */
 	const char *cmdTemplate;
 	char *cmdStart;		/* Start of expanded command */
 	char *escCmd = NULL;	/* Command with quotes/backticks escaped */
 	noSpecials = !GNode_ShouldExecute(job->node);
 	numCommands++;
 	Var_Subst(cmd, job->node, VARE_WANTRES, &cmd);
 	/* TODO: handle errors */
 	cmdStart = cmd;
 	cmdTemplate = "%s\n";
-	ParseRunOptions(&cmd, &runFlags, &errOff, &runAlways);
+	ParseRunOptions(&cmd, &runFlags, &errOff);
-	if (runAlways && noSpecials) {
+	if (runFlags.always && noSpecials) {
 		/*
 		 * We're not actually executing anything...
 		 * but this one needs to be - use compat mode just for it.
 		 */
 		Compat_RunCommand(cmdp, job->node);
 		free(cmdStart);
 		return;
+	}
 	/*
 	 * If the shell doesn't have error control the alternate echo'ing will
 	 * be done (to avoid showing additional error checking code)
 	 * and this will need the characters '$ ` \ "' escaped