 @@ -1,14 +1,14 @@
-/*	$NetBSD: job.c,v 1.317 2020/11/14 12:38:06 rillig Exp $	*/
+/*	$NetBSD: job.c,v 1.318 2020/11/14 13:07:39 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.317 2020/11/14 12:38:06 rillig Exp $");
+MAKE_RCSID("$NetBSD: job.c,v 1.318 2020/11/14 13:07:39 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,
  * echoOn, noPrint and noPrintLen.  When echoOff is executed by the shell, it
 @@ -682,26 +682,42 @@ EscapeShellDblQuot(const char *cmd)
     /* Worst that could happen is every char needs escaping. */
     char *esc = bmake_malloc(strlen(cmd) * 2 + 1);
     for (i = 0, j = 0; cmd[i] != '\0'; i++, j++) {
 	if (cmd[i] == '$' || cmd[i] == '`' || cmd[i] == '\\' || cmd[i] == '"')
 	    esc[j++] = '\\';
 	esc[j] = cmd[i];
+    }
     esc[j] = '\0';
     return esc;
+}
 static void
 JobPrintf(Job *job, const char *fmt, const char *arg)
+{
     if (DEBUG(JOB))
 	debug_printf(fmt, arg);
     (void)fprintf(job->cmdFILE, fmt, arg);
     (void)fflush(job->cmdFILE);
+}
 static void
 JobPrintln(Job *job, const char *line)
+{
     JobPrintf(job, "%s\n", line);
+}
 /*-
  *-----------------------------------------------------------------------
  * JobPrintCommand  --
  *	Put out another command for the given job. If the command starts
  *	with an @ or a - we process it specially. In the former case,
  *	so long as the -s and -n flags weren't given to make, we stick
  *	a shell-specific echoOff command in the script. In the latter,
  *	we ignore errors for the entire job, unless the shell has error
  *	control.
  *	If the command is just "..." we take all future commands for this
  *	job to be commands to be executed once the entire graph has been
  *	made and return non-zero to signal that the end of the commands
  *	was reached. These commands are later attached to the postCommands
 @@ -723,32 +739,26 @@ JobPrintCommand(Job *job, char *cmd)
     Boolean shutUp;		/* true if we put a no echo command
 				 * into the command file */
     Boolean errOff;		/* true if we turned error checking
 				 * off before printing the command
 				 * and need to turn it back on */
     Boolean runAlways;
     const char *cmdTemplate;	/* Template to use when printing the
 				 * command */
     char *cmdStart;		/* Start of expanded command */
     char *escCmd = NULL;	/* Command with quotes/backticks escaped */
     noSpecials = !GNode_ShouldExecute(job->node);
 #define DBPRINTF(fmt, arg) if (DEBUG(JOB)) {	\
 	debug_printf(fmt, arg);			\
     }						\
     (void)fprintf(job->cmdFILE, fmt, arg);	\
     (void)fflush(job->cmdFILE);
     numCommands++;
     Var_Subst(cmd, job->node, VARE_WANTRES, &cmd);
     /* TODO: handle errors */
     cmdStart = cmd;
     cmdTemplate = "%s\n";
     ParseRunOptions(&cmd, &shutUp, &errOff, &runAlways);
     if (runAlways && noSpecials) {
 	/*
 	 * We're not actually executing anything...
 @@ -761,139 +771,136 @@ JobPrintCommand(Job *job, char *cmd)
     /*
      * 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
      */
     if (!commandShell->hasErrCtl)
 	escCmd = EscapeShellDblQuot(cmd);
     if (shutUp) {
 	if (!(job->flags & JOB_SILENT) && !noSpecials &&
 	    (commandShell->hasEchoCtl)) {
-	    DBPRINTF("%s\n", commandShell->echoOff);
+	    JobPrintln(job, commandShell->echoOff);
 	} else {
 	    if (commandShell->hasErrCtl)
 		shutUp = FALSE;
+	}
+    }
     if (errOff) {
 	if (!noSpecials) {
 	    if (commandShell->hasErrCtl) {
 		/*
 		 * 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?
 		 */
 		if (!(job->flags & JOB_SILENT) && !shutUp &&
 		    (commandShell->hasEchoCtl)) {
-		    DBPRINTF("%s\n", commandShell->echoOff);
+		    JobPrintln(job, commandShell->echoOff);
-		    DBPRINTF("%s\n", commandShell->errOffOrExecIgnore);
+		    JobPrintln(job, commandShell->errOffOrExecIgnore);
-		    DBPRINTF("%s\n", commandShell->echoOn);
+		    JobPrintln(job,  commandShell->echoOn);
 		} else {
-		    DBPRINTF("%s\n", commandShell->errOffOrExecIgnore);
+		    JobPrintln(job, commandShell->errOffOrExecIgnore);
+		}
 	    } else if (commandShell->errOffOrExecIgnore &&
 		       commandShell->errOffOrExecIgnore[0] != '\0') {
 		/*
 		 * 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. Set cmdTemplate to use the weirdness
 		 * instead of the simple "%s\n" template.
 		 */
 		job->flags |= JOB_IGNERR;
 		if (!(job->flags & JOB_SILENT) && !shutUp) {
 		    if (commandShell->hasEchoCtl) {
-			DBPRINTF("%s\n", commandShell->echoOff);
+			JobPrintln(job, commandShell->echoOff);
+		    }
-		    DBPRINTF(commandShell->errOnOrEcho, escCmd);
+		    JobPrintf(job, commandShell->errOnOrEcho, escCmd);
 		    shutUp = TRUE;
 		} else {
-		    if (!shutUp) {
+		    if (!shutUp)
-			DBPRINTF(commandShell->errOnOrEcho, escCmd);
+			JobPrintf(job, commandShell->errOnOrEcho, escCmd);
+		}
 		cmdTemplate = commandShell->errOffOrExecIgnore;
 		/*
 		 * The error ignoration (hee hee) is already taken care
 		 * of by the errOffOrExecIgnore template, so pretend error
 		 * checking is still on.
 		 */
 		errOff = FALSE;
 	    } else {
 		errOff = FALSE;
+	    }
 	} else {
 	    errOff = FALSE;
+	}
     } else {
 	/*
 	 * If errors are being checked and the shell doesn't have error control
 	 * but does supply an errExit template, then setup commands to run
 	 * through it.
 	 */
 	if (!commandShell->hasErrCtl && commandShell->errExit &&
 	    commandShell->errExit[0] != '\0') {
 	    if (!(job->flags & JOB_SILENT) && !shutUp) {
-		if (commandShell->hasEchoCtl) {
+		if (commandShell->hasEchoCtl)
-		    DBPRINTF("%s\n", commandShell->echoOff);
+		    JobPrintln(job, commandShell->echoOff);
 		JobPrintf(job, commandShell->errOnOrEcho, escCmd);
 		DBPRINTF(commandShell->errOnOrEcho, escCmd);
 		shutUp = TRUE;
+	    }
 	    /* If it's a comment line or blank, treat as an ignored error */
 	    if (escCmd[0] == commandShell->commentChar ||
 		(escCmd[0] == '\0'))
 		cmdTemplate = commandShell->errOffOrExecIgnore;
 	    else
 		cmdTemplate = commandShell->errExit;
 	    errOff = FALSE;
+	}
+    }
     if (DEBUG(SHELL) && strcmp(shellName, "sh") == 0 &&
 	!(job->flags & JOB_TRACED)) {
-	DBPRINTF("set -%s\n", "x");
+	JobPrintln(job, "set -x");
 	job->flags |= JOB_TRACED;
+    }
-    DBPRINTF(cmdTemplate, cmd);
+    JobPrintf(job, cmdTemplate, cmd);
     free(cmdStart);
     free(escCmd);
     if (errOff) {
 	/*
 	 * If echoing is already off, there's no point in issuing the
 	 * echoOff command. Otherwise we issue it and pretend it was on
 	 * for the whole command...
 	 */
 	if (!shutUp && !(job->flags & JOB_SILENT) && commandShell->hasEchoCtl) {
-	    DBPRINTF("%s\n", commandShell->echoOff);
+	    JobPrintln(job, commandShell->echoOff);
 	    shutUp = TRUE;
+	}
-	DBPRINTF("%s\n", commandShell->errOnOrEcho);
+	JobPrintln(job, commandShell->errOnOrEcho);
     if (shutUp && commandShell->hasEchoCtl) {
 	DBPRINTF("%s\n", commandShell->echoOn);
+    }
     if (shutUp && commandShell->hasEchoCtl)
 	JobPrintln(job, commandShell->echoOn);
+}
 /* Print all commands to the shell file that is later executed.
+ *
  * The special command "..." stops printing and saves the remaining commands
  * to be executed later. */
 static void
 JobPrintCommands(Job *job)
+{
     StringListNode *ln;
     for (ln = job->node->commands->first; ln != NULL; ln = ln->next) {
 	const char *cmd = ln->datum;