 @@ -1,14 +1,14 @@
-/*	$NetBSD: job.c,v 1.402 2021/01/29 23:45:35 rillig Exp $	*/
+/*	$NetBSD: job.c,v 1.403 2021/01/30 13:02:54 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.402 2021/01/29 23:45:35 rillig Exp $");
+MAKE_RCSID("$NetBSD: job.c,v 1.403 2021/01/30 13:02:54 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,
 @@ -1006,38 +1006,43 @@ JobPrintCommands(Job *job)
 		if (strcmp(cmd, "...") == 0) {
 			job->node->type |= OP_SAVE_CMDS;
 			job->tailCmds = ln->next;
 			break;
+		}
 		JobPrintCommand(job, &wr, ln, ln->datum);
 		seen = TRUE;
+	}
 	return seen;
+}
-/* Save the delayed commands, to be executed when everything else is done. */
+/*
  * Save the delayed commands (those after '...'), to be executed later in
  * the '.END' node, when everything else is done.
  */
 static void
 JobSaveCommands(Job *job)
+{
 	StringListNode *ln;
 	for (ln = job->tailCmds; ln != NULL; ln = ln->next) {
 		const char *cmd = ln->datum;
 		char *expanded_cmd;
-		/* XXX: This Var_Subst is only intended to expand the dynamic
+		/*
 		 * XXX: This Var_Subst is only intended to expand the dynamic
 		 * variables such as .TARGET, .IMPSRC.  It is not intended to
-		 * expand the other variables as well; see deptgt-end.mk. */
+		 * expand the other variables as well; see deptgt-end.mk.
 		 */
 		(void)Var_Subst(cmd, job->node, VARE_WANTRES, &expanded_cmd);
 		/* TODO: handle errors */
 		Lst_Append(&Targ_GetEndNode()->commands, expanded_cmd);
+	}
+}
 /* Called to close both input and output pipes when a job is finished. */
 static void
 JobClosePipes(Job *job)
+{
 	clearfd(job);
 	(void)close(job->outPipe);
 @@ -1650,59 +1655,48 @@ JobStart(GNode *gn, Boolean special)
 	job->status = JOB_ST_SET_UP;
 	job->special = special || gn->type & OP_SPECIAL;
 	job->ignerr = opts.ignoreErrors || gn->type & OP_IGNORE;
 	job->echo = !(opts.beSilent || gn->type & OP_SILENT);
 	/*
 	 * Check the commands now so any attributes from .DEFAULT have a
 	 * chance to migrate to the node.
 	 */
 	cmdsOK = Job_CheckCommands(gn, Error);
 	job->inPollfd = NULL;
 	/*
 	 * If the -n flag wasn't given, we open up OUR (not the child's)
 	 * temporary file to stuff commands in it. The thing is rd/wr so
 	 * we don't need to reopen it to feed it to the shell. If the -n
 	 * flag *was* given, we just set the file to be stdout. Cute, huh?
 	 */
 	if (Lst_IsEmpty(&gn->commands)) {
 		job->cmdFILE = stdout;
 		run = FALSE;
 	} else if (((gn->type & OP_MAKE) && !opts.noRecursiveExecute) ||
 	    (!opts.noExecute && !opts.touchFlag)) {
 		/*
-		 * The above conditions look very similar to
+		 * The above condition looks very similar to
-		 * GNode_ShouldExecute but are subtly different.
+		 * GNode_ShouldExecute but is subtly different.
-		 * They prevent that .MAKE targets are touched.
+		 * It prevents that .MAKE targets are touched.
 		 */
 		JobWriteShellCommands(job, gn, cmdsOK, &run);
 		(void)fflush(job->cmdFILE);
 	} else if (!GNode_ShouldExecute(gn)) {
 		/*
 		 * Not executing anything -- just print all the commands to
 		 * stdout in one fell swoop. This will still set up
 		 * job->tailCmds correctly.
 		 */
 		SwitchOutputTo(gn);
 		job->cmdFILE = stdout;
 		/*
 		 * Only print the commands if they're ok, but don't die if
 		 * they're not -- just let the user know they're bad and
 		 * keep going. It doesn't do any harm in this case and may
 		 * do some good.
 		 */
 		if (cmdsOK)
 			JobPrintCommands(job);
 		/* Don't execute the shell, thank you. */
 		run = FALSE;
 		(void)fflush(job->cmdFILE);
 	} else {
 		/*
 		 * Just touch the target and note that no shell should be
 		 * executed. Set cmdFILE to stdout to make life easier.
 		 */
 		job->cmdFILE = stdout;
 		Job_Touch(gn, job->echo);
 		run = FALSE;