 @@ -1,14 +1,14 @@
-/*	$NetBSD: cond.c,v 1.169 2020/10/26 21:34:10 rillig Exp $	*/
+/*	$NetBSD: cond.c,v 1.170 2020/10/30 07:19:30 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.
 @@ -83,27 +83,27 @@
  *	Cond_restore_depth
  *			Save and restore the nesting of the conditions, at
  *			the start and end of including another makefile, to
  *			ensure that in each makefile the conditional
  *			directives are well-balanced.
  */
 #include <errno.h>
 #include "make.h"
 #include "dir.h"
 /*	"@(#)cond.c	8.2 (Berkeley) 1/2/94"	*/
-MAKE_RCSID("$NetBSD: cond.c,v 1.169 2020/10/26 21:34:10 rillig Exp $");
+MAKE_RCSID("$NetBSD: cond.c,v 1.170 2020/10/30 07:19:30 rillig Exp $");
 /*
  * The parsing of conditional expressions is based on this grammar:
  *	E -> F || E
  *	E -> F
  *	F -> T && F
  *	F -> T
  *	T -> defined(variable)
  *	T -> make(target)
  *	T -> exists(file)
  *	T -> empty(varspec)
  *	T -> target(name)
  *	T -> commands(name)
 @@ -236,27 +236,28 @@ ParseFuncArg(const char **pp, Boolean do
 	    break;
 	if ((ch == '&' || ch == '|') && paren_depth == 0)
 	    break;
 	if (*p == '$') {
 	    /*
 	     * Parse the variable spec and install it as part of the argument
 	     * if it's valid. We tell Var_Parse to complain on an undefined
 	     * variable, so we don't need to do it. Nor do we return an error,
 	     * though perhaps we should...
 	     */
 	    void *nestedVal_freeIt;
 	    VarEvalFlags eflags = VARE_UNDEFERR | (doEval ? VARE_WANTRES : 0);
 	    const char *nestedVal;
-	    (void)Var_Parse(&p, VAR_CMD, eflags, &nestedVal, &nestedVal_freeIt);
+	    (void)Var_Parse(&p, VAR_CMDLINE, eflags, &nestedVal,
 			    &nestedVal_freeIt);
 	    /* TODO: handle errors */
 	    Buf_AddStr(&argBuf, nestedVal);
 	    free(nestedVal_freeIt);
 	    continue;
+	}
 	if (ch == '(')
 	    paren_depth++;
 	else if (ch == ')' && --paren_depth < 0)
 	    break;
 	Buf_AddByte(&argBuf, *p);
 	p++;
+    }
 @@ -273,27 +274,27 @@ ParseFuncArg(const char **pp, Boolean do
 	/* The PARSE_FATAL is done as a follow-up by CondEvalExpression. */
 	return 0;
+    }
     *pp = p;
     return argLen;
+}
 /* Test whether the given variable is defined. */
 static Boolean
 FuncDefined(size_t argLen MAKE_ATTR_UNUSED, const char *arg)
+{
     char *freeIt;
-    Boolean result = Var_Value(arg, VAR_CMD, &freeIt) != NULL;
+    Boolean result = Var_Value(arg, VAR_CMDLINE, &freeIt) != NULL;
     bmake_free(freeIt);
     return result;
+}
 /* See if the given target is being made. */
 static Boolean
 FuncMake(size_t argLen MAKE_ATTR_UNUSED, const char *arg)
+{
     StringListNode *ln;
     for (ln = opts.create->first; ln != NULL; ln = ln->next)
 	if (Str_Match(ln->datum, arg))
 	    return TRUE;
 @@ -433,27 +434,28 @@ CondParser_String(CondParser *par, Boole
 	case ' ':
 	case '\t':
 	    if (!qt)
 		goto got_str;
 	    Buf_AddByte(&buf, par->p[0]);
 	    par->p++;
 	    continue;
 	case '$':
 	    /* if we are in quotes, an undefined variable is ok */
 	    eflags = ((!qt && doEval) ? VARE_UNDEFERR : 0) |
 		     (doEval ? VARE_WANTRES : 0);
 	    nested_p = par->p;
 	    atStart = nested_p == start;
-	    parseResult = Var_Parse(&nested_p, VAR_CMD, eflags, &str, freeIt);
+	    parseResult = Var_Parse(&nested_p, VAR_CMDLINE, eflags, &str,
 				    freeIt);
 	    /* TODO: handle errors */
 	    if (str == var_Error) {
 		if (parseResult & VPR_ANY_MSG)
 		    par->printedError = TRUE;
 		if (*freeIt) {
 		    free(*freeIt);
 		    *freeIt = NULL;
+		}
 		/*
 		 * Even if !doEval, we still report syntax errors, which
 		 * is what getting var_Error back with !doEval means.
 		 */
 		str = NULL;
 @@ -673,27 +675,27 @@ done:
 static size_t
 ParseEmptyArg(const char **linePtr, Boolean doEval,
 	      const char *func MAKE_ATTR_UNUSED, char **argPtr)
+{
     void *val_freeIt;
     const char *val;
     size_t magic_res;
     /* We do all the work here and return the result as the length */
     *argPtr = NULL;
     (*linePtr)--;		/* Make (*linePtr)[1] point to the '('. */
-    (void)Var_Parse(linePtr, VAR_CMD, doEval ? VARE_WANTRES : 0,
+    (void)Var_Parse(linePtr, VAR_CMDLINE, doEval ? VARE_WANTRES : 0,
 		    &val, &val_freeIt);
     /* TODO: handle errors */
     /* If successful, *linePtr points beyond the closing ')' now. */
     if (val == var_Error) {
 	free(val_freeIt);
 	return (size_t)-1;
+    }
     /* A variable is empty when it just contains spaces... 4/15/92, christos */
     cpp_skip_whitespace(&val);
     /*

 @@ -1,14 +1,14 @@
-/*	$NetBSD: main.c,v 1.409 2020/10/28 03:21:25 rillig Exp $	*/
+/*	$NetBSD: main.c,v 1.410 2020/10/30 07:19:30 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.
 @@ -108,27 +108,27 @@
 #include <errno.h>
 #include <signal.h>
 #include <stdarg.h>
 #include <time.h>
 #include "make.h"
 #include "dir.h"
 #include "job.h"
 #include "pathnames.h"
 #include "trace.h"
 /*	"@(#)main.c	8.3 (Berkeley) 3/19/94"	*/
-MAKE_RCSID("$NetBSD: main.c,v 1.409 2020/10/28 03:21:25 rillig Exp $");
+MAKE_RCSID("$NetBSD: main.c,v 1.410 2020/10/30 07:19:30 rillig Exp $");
 #if defined(MAKE_NATIVE) && !defined(lint)
 __COPYRIGHT("@(#) Copyright (c) 1988, 1989, 1990, 1993 "
 	    "The Regents of the University of California.  "
 	    "All rights reserved.");
 #endif
 #ifndef	DEFMAXLOCAL
 #define	DEFMAXLOCAL DEFMAXJOBS
 #endif
 CmdOpts opts;
 time_t			now;		/* Time at start of make */
 GNode			*DEFAULT;	/* .DEFAULT node */
 @@ -639,27 +639,27 @@ rearg:
 		argc -= arginc;
+	}
 	oldVars = TRUE;
 	/*
 	 * See if the rest of the arguments are variable assignments and
 	 * perform them if so. Else take them to be targets and stuff them
 	 * on the end of the "create" list.
 	 */
 	for (; argc > 1; ++argv, --argc) {
 		VarAssign var;
 		if (Parse_IsVar(argv[1], &var)) {
-			Parse_DoVar(&var, VAR_CMD);
+			Parse_DoVar(&var, VAR_CMDLINE);
 		} else {
 			if (!*argv[1])
 				Punt("illegal (null) argument.");
 			if (*argv[1] == '-' && !dashDash)
 				goto rearg;
 			Lst_Append(opts.create, bmake_strdup(argv[1]));
+		}
+	}
 	return;
 noarg:
 	(void)fprintf(stderr, "%s: option requires an argument -- %c\n",
 	    progname, c);
 @@ -733,27 +733,27 @@ Main_SetObjdir(const char *fmt, ...)
 			rc = TRUE;
 			if (opts.enterFlag && strcmp(objdir, curdir) != 0)
 				enterFlagObj = TRUE;
+		}
+	}
 	return rc;
+}
 static Boolean
 Main_SetVarObjdir(const char *var, const char *suffix)
+{
 	char *path_freeIt;
-	const char *path = Var_Value(var, VAR_CMD, &path_freeIt);
+	const char *path = Var_Value(var, VAR_CMDLINE, &path_freeIt);
 	const char *xpath;
 	char *xpath_freeIt;
 	if (path == NULL || path[0] == '\0') {
 		bmake_free(path_freeIt);
 		return FALSE;
+	}
 	/* expand variable substitutions */
 	xpath = path;
 	xpath_freeIt = NULL;
 	if (strchr(path, '$') != 0) {
 		(void)Var_Subst(path, VAR_GLOBAL, VARE_WANTRES, &xpath_freeIt);
 @@ -1026,32 +1026,32 @@ init_machine_arch(void)
  * MAKEOBJDIRPREFIX is set or MAKEOBJDIR contains a variable expression.
  */
 static void
 HandlePWD(const struct stat *curdir_st)
+{
 	char *pwd;
 	char *prefix_freeIt, *makeobjdir_freeIt;
 	const char *makeobjdir;
 	struct stat pwd_st;
 	if (ignorePWD || (pwd = getenv("PWD")) == NULL)
 		return;
-	if (Var_Value("MAKEOBJDIRPREFIX", VAR_CMD, &prefix_freeIt) != NULL) {
+	if (Var_Value("MAKEOBJDIRPREFIX", VAR_CMDLINE, &prefix_freeIt) != NULL) {
 		bmake_free(prefix_freeIt);
 		return;
+	}
-	makeobjdir = Var_Value("MAKEOBJDIR", VAR_CMD, &makeobjdir_freeIt);
+	makeobjdir = Var_Value("MAKEOBJDIR", VAR_CMDLINE, &makeobjdir_freeIt);
 	if (makeobjdir != NULL && strchr(makeobjdir, '$') != NULL)
 		goto ignore_pwd;
 	if (stat(pwd, &pwd_st) == 0 &&
 	    curdir_st->st_ino == pwd_st.st_ino &&
 	    curdir_st->st_dev == pwd_st.st_dev)
 		(void)strncpy(curdir, pwd, MAXPATHLEN);
 ignore_pwd:
 	bmake_free(makeobjdir_freeIt);
+}
 #endif
 @@ -1226,30 +1226,30 @@ InitMaxJobs(void)
 	free(value);
+}
 /*
  * For compatibility, look at the directories in the VPATH variable
  * and add them to the search path, if the variable is defined. The
  * variable's value is in the same format as the PATH environment
  * variable, i.e. <directory>:<directory>:<directory>...
  */
 static void
 InitVpath(void)
+{
 	char *vpath, savec, *path;
-	if (!Var_Exists("VPATH", VAR_CMD))
+	if (!Var_Exists("VPATH", VAR_CMDLINE))
 		return;
-	(void)Var_Subst("${VPATH}", VAR_CMD, VARE_WANTRES, &vpath);
+	(void)Var_Subst("${VPATH}", VAR_CMDLINE, VARE_WANTRES, &vpath);
 	/* TODO: handle errors */
 	path = vpath;
 	do {
 		char *cp;
 		/* skip to end of directory */
 		for (cp = path; *cp != ':' && *cp != '\0'; cp++)
 			continue;
 		/* Save terminator character so know when to stop */
 		savec = *cp;
 		*cp = '\0';
 		/* Add directory to search path */
 		(void)Dir_AddDir(dirSearchPath, path);
 		*cp = savec;
 @@ -1262,27 +1262,27 @@ static void
 ReadMakefiles(void)
+{
 	if (opts.makefiles->first != NULL) {
 		StringListNode *ln;
 		for (ln = opts.makefiles->first; ln != NULL; ln = ln->next) {
 			if (ReadMakefile(ln->datum) != 0)
 				Fatal("%s: cannot open %s.",
 				      progname, (char *)ln->datum);
+		}
 	} else {
 		char *p1;
 		(void)Var_Subst("${" MAKEFILE_PREFERENCE "}",
-				VAR_CMD, VARE_WANTRES, &p1);
+				VAR_CMDLINE, VARE_WANTRES, &p1);
 		/* TODO: handle errors */
 		(void)str2Lst_Append(opts.makefiles, p1, NULL);
 		(void)Lst_ForEachUntil(opts.makefiles,
 				       ReadMakefileSucceeded, NULL);
 		free(p1);
+	}
+}
 static void
 CleanUp(void)
+{
 #ifdef CLEANUP
 	Lst_Destroy(opts.variables, free);
 @@ -1416,27 +1416,27 @@ main(int argc, char **argv)
 	/*
 	 * Initialize various variables.
 	 *	MAKE also gets this name, for compatibility
 	 *	.MAKEFLAGS gets set to the empty string just in case.
 	 *	MFLAGS also gets initialized empty, for compatibility.
 	 */
 	Parse_Init();
 	InitVarMake(argv[0]);
 	Var_Set(MAKEFLAGS, "", VAR_GLOBAL);
 	Var_Set(MAKEOVERRIDES, "", VAR_GLOBAL);
 	Var_Set("MFLAGS", "", VAR_GLOBAL);
 	Var_Set(".ALLTARGETS", "", VAR_GLOBAL);
 	/* some makefiles need to know this */
-	Var_Set(MAKE_LEVEL ".ENV", MAKE_LEVEL_ENV, VAR_CMD);
+	Var_Set(MAKE_LEVEL ".ENV", MAKE_LEVEL_ENV, VAR_CMDLINE);
 	/*
 	 * Set some other useful macros
 	 */
+	{
 	    char tmp[64], *ep;
 	    makelevel = ((ep = getenv(MAKE_LEVEL_ENV)) && *ep) ? atoi(ep) : 0;
 	    if (makelevel < 0)
 		makelevel = 0;
 	    snprintf(tmp, sizeof(tmp), "%d", makelevel);
 	    Var_Set(MAKE_LEVEL, tmp, VAR_GLOBAL);
 	    snprintf(tmp, sizeof(tmp), "%u", myPid);
 @@ -1520,27 +1520,27 @@ main(int argc, char **argv)
 	/*
 	 * Read in the built-in rules first, followed by the specified
 	 * makefiles, or the default makefile and Makefile, in that order,
 	 * if no makefiles were given on the command line.
 	 */
 	if (!opts.noBuiltins)
 		ReadBuiltinRules();
 	ReadMakefiles();
 	/* In particular suppress .depend for '-r -V .OBJDIR -f /dev/null' */
 	if (!opts.noBuiltins || !opts.printVars) {
 	    /* ignore /dev/null and anything starting with "no" */
 	    (void)Var_Subst("${.MAKE.DEPENDFILE:N/dev/null:Nno*:T}",
-		VAR_CMD, VARE_WANTRES, &makeDependfile);
+			    VAR_CMDLINE, VARE_WANTRES, &makeDependfile);
 	    if (makeDependfile[0] != '\0') {
 		/* TODO: handle errors */
 		doing_depend = TRUE;
 		(void)ReadMakefile(makeDependfile);
 		doing_depend = FALSE;
+	    }
+	}
 	if (enterFlagObj)
 		printf("%s: Entering directory `%s'\n", progname, objdir);
 	MakeMode(NULL);
 @@ -2117,27 +2117,27 @@ PrintOnError(GNode *gn, const char *s)
 void
 Main_ExportMAKEFLAGS(Boolean first)
+{
     static Boolean once = TRUE;
     const char *expr;
     char *s;
     if (once != first)
 	return;
     once = FALSE;
     expr = "${.MAKEFLAGS} ${.MAKEOVERRIDES:O:u:@v@$v=${$v:Q}@}";
-    (void)Var_Subst(expr, VAR_CMD, VARE_WANTRES, &s);
+    (void)Var_Subst(expr, VAR_CMDLINE, VARE_WANTRES, &s);
     /* TODO: handle errors */
     if (s[0] != '\0') {
 #ifdef POSIX
 	setenv("MAKEFLAGS", s, 1);
 #else
 	setenv("MAKE", s, 1);
 #endif
+    }
+}
 char *
 getTmpdir(void)
+{

 @@ -1,14 +1,14 @@
-/*	$NetBSD: make.h,v 1.175 2020/10/28 03:21:25 rillig Exp $	*/
+/*	$NetBSD: make.h,v 1.176 2020/10/30 07:19:30 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.
 @@ -352,27 +352,27 @@ typedef struct GNode {
     char cohort_num[8];
     /* The number of unmade instances on the cohorts list */
     int unmade_cohorts;
     /* Pointer to the first instance of a '::' node; only set when on a
      * cohorts list */
     struct GNode *centurion;
     /* Last time (sequence number) we tried to make this node */
     unsigned int checked_seqno;
     /* The "local" variables that are specific to this target and this target
      * only, such as $@, $<, $?.
+     *
-     * Also used for the global variable scopes VAR_GLOBAL, VAR_CMD,
+     * Also used for the global variable scopes VAR_GLOBAL, VAR_CMDLINE,
      * VAR_INTERNAL, which contain variables with arbitrary names. */
     HashTable context;
     /* The commands to be given to a shell to create this target. */
     StringList *commands;
     /* Suffix for the node (determined by Suff_FindDeps and opaque to everyone
      * but the Suff module) */
     struct Suff *suffix;
     /* filename where the GNode got defined */
     const char *fname;
     /* line number where the GNode got defined */
 @@ -425,27 +425,27 @@ extern SearchPath *dirSearchPath;
 				 * looking for targets */
 extern Boolean  allPrecious;	/* True if every target is precious */
 extern Boolean  deleteOnError;	/* True if failed targets should be deleted */
 extern Boolean	doing_depend;	/* TRUE if processing .depend */
 extern GNode    *DEFAULT;	/* .DEFAULT rule */
 extern GNode	*VAR_INTERNAL;	/* Variables defined internally by make
 				 * which should not override those set by
 				 * makefiles.
 				 */
 extern GNode    *VAR_GLOBAL;	/* Variables defined in a global context, e.g
 				 * in the Makefile itself */
-extern GNode    *VAR_CMD;	/* Variables defined on the command line */
+extern GNode    *VAR_CMDLINE;	/* Variables defined on the command line */
 extern char	var_Error[];	/* Value returned by Var_Parse when an error
 				 * is encountered. It actually points to
 				 * an empty string, so naive callers needn't
 				 * worry about it. */
 extern time_t	now;		/* The time at the start of this whole
 				 * process */
 extern Boolean	oldVars;	/* Do old-style variable substitution */
 extern SearchPath *sysIncPath;	/* The system include path. */
 extern SearchPath *defSysIncPath; /* The default system include path. */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: parse.c,v 1.410 2020/10/29 20:37:47 rillig Exp $	*/
+/*	$NetBSD: parse.c,v 1.411 2020/10/30 07:19:30 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.
 @@ -107,27 +107,27 @@
 #ifndef MAP_FILE
 #define MAP_FILE 0
 #endif
 #ifndef MAP_COPY
 #define MAP_COPY MAP_PRIVATE
 #endif
 #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.410 2020/10/29 20:37:47 rillig Exp $");
+MAKE_RCSID("$NetBSD: parse.c,v 1.411 2020/10/30 07:19:30 rillig Exp $");
 /* types and constants */
 /*
  * Structure for a file being read ("included file")
  */
 typedef struct IFile {
     char *fname;		/* name of file */
     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 */
 @@ -731,27 +731,27 @@ static Boolean
 ParseMessage(const char *directive)
+{
     const char *p = directive;
     int mtype = *p == 'i' ? PARSE_INFO :
 		*p == 'w' ? PARSE_WARNING : PARSE_FATAL;
     char *arg;
     while (ch_isalpha(*p))
 	p++;
     if (!ch_isspace(*p))
 	return FALSE;		/* missing argument */
     cpp_skip_whitespace(&p);
-    (void)Var_Subst(p, VAR_CMD, VARE_WANTRES, &arg);
+    (void)Var_Subst(p, VAR_CMDLINE, VARE_WANTRES, &arg);
     /* TODO: handle errors */
     Parse_Error(mtype, "%s", arg);
     free(arg);
     if (mtype == PARSE_FATAL) {
 	PrintOnError(NULL, NULL);
 	exit(1);
+    }
     return TRUE;
+}
 /* Add the child to the parent's children.
 @@ -1053,27 +1053,27 @@ ParseDependencyTargetWord(/*const*/ char
 	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;
 	    const char *nested_val;
 	    void *freeIt;
-	    (void)Var_Parse(&nested_p, VAR_CMD, VARE_UNDEFERR|VARE_WANTRES,
+	    (void)Var_Parse(&nested_p, VAR_CMDLINE, VARE_UNDEFERR|VARE_WANTRES,
 			    &nested_val, &freeIt);
 	    /* TODO: handle errors */
 	    free(freeIt);
 	    cp += nested_p - cp;
 	} else
 	    cp++;
+    }
     *pp = cp;
+}
 /*
  * Certain special targets have special semantics:
 @@ -1467,27 +1467,27 @@ ParseDoDependencyTargets(char **inout_cp
 	 * 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(&line, targets, VAR_CMD)) {
+	    if (!Arch_ParseArchive(&line, targets, VAR_CMDLINE)) {
 		Parse_Error(PARSE_FATAL,
 			    "Error in archive specification: \"%s\"", line);
 		return FALSE;
 	    } else {
 		/* Done with this word; on to the next. */
 		cp = line;
 		continue;
+	    }
+	}
 	if (!*cp) {
 	    ParseErrorNoDependency(lstart);
 	    return FALSE;
 @@ -1569,27 +1569,27 @@ ParseDoDependencySourcesMundane(char *st
 	    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_New();
-	    if (!Arch_ParseArchive(&start, sources, VAR_CMD)) {
+	    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);
 		ParseDoSrc(tOp, gn->name, specType);
+	    }
 	    Lst_Free(sources);
 	    end = start;
 	} else {
 	    if (*end) {
 @@ -1942,27 +1942,27 @@ VarAssign_EvalSubst(const char *name, co
+}
 static void
 VarAssign_EvalShell(const char *name, const char *uvalue, GNode *ctxt,
 		    const char **out_avalue, void **out_avalue_freeIt)
+{
     const char *cmd, *errfmt;
     char *cmdOut;
     void *cmd_freeIt = NULL;
     cmd = uvalue;
     if (strchr(cmd, '$') != NULL) {
 	char *ecmd;
-	(void)Var_Subst(cmd, VAR_CMD, VARE_UNDEFERR|VARE_WANTRES, &ecmd);
+	(void)Var_Subst(cmd, VAR_CMDLINE, VARE_UNDEFERR | VARE_WANTRES, &ecmd);
 	/* TODO: handle errors */
 	cmd = cmd_freeIt = ecmd;
+    }
     cmdOut = Cmd_Exec(cmd, &errfmt);
     Var_Set(name, cmdOut, ctxt);
     *out_avalue = *out_avalue_freeIt = cmdOut;
     if (errfmt)
 	Parse_Error(PARSE_WARNING, errfmt, cmd);
     free(cmd_freeIt);
+}
 @@ -2264,27 +2264,27 @@ ParseDoInclude(char *line)
     if (*cp != endc) {
 	Parse_Error(PARSE_FATAL,
 		    "Unclosed %cinclude filename. '%c' expected",
 		    '.', endc);
 	return;
+    }
     *cp = '\0';
     /*
      * Substitute for any variables in the file name before trying to
      * find the thing.
      */
-    (void)Var_Subst(file, VAR_CMD, VARE_WANTRES, &file);
+    (void)Var_Subst(file, VAR_CMDLINE, VARE_WANTRES, &file);
     /* TODO: handle errors */
     Parse_include_file(file, endc == '>', *line == 'd', silent);
     free(file);
+}
 /* Split filename into dirname + basename, then assign these to the
  * given variables. */
 static void
 SetFilenameVars(const char *filename, const char *dirvar, const char *filevar)
+{
     const char *slash, *dirname, *basename;
     void *freeIt;
 @@ -2479,27 +2479,27 @@ ParseTraditionalInclude(char *line)
     int done = 0;
     int silent = line[0] != 'i';
     char *file = line + (silent ? 8 : 7);
     char *all_files;
     DEBUG2(PARSE, "%s: %s\n", __func__, file);
     pp_skip_whitespace(&file);
     /*
      * Substitute for any variables in the file name before trying to
      * find the thing.
      */
-    (void)Var_Subst(file, VAR_CMD, VARE_WANTRES, &all_files);
+    (void)Var_Subst(file, VAR_CMDLINE, VARE_WANTRES, &all_files);
     /* TODO: handle errors */
     if (*file == '\0') {
 	Parse_Error(PARSE_FATAL, "Filename missing from \"include\"");
 	goto out;
+    }
     for (file = all_files; !done; file = cp + 1) {
 	/* Skip to end of line or next whitespace */
 	for (cp = file; *cp && !ch_isspace(*cp); cp++)
 	    continue;
 	if (*cp)
 @@ -2529,27 +2529,27 @@ ParseGmakeExport(char *line)
     for (value = variable; *value && *value != '='; value++)
 	continue;
     if (*value != '=') {
 	Parse_Error(PARSE_FATAL,
 		    "Variable/Value missing from \"export\"");
 	return;
+    }
     *value++ = '\0';		/* terminate variable */
     /*
      * Expand the value before putting it in the environment.
      */
-    (void)Var_Subst(value, VAR_CMD, VARE_WANTRES, &value);
+    (void)Var_Subst(value, VAR_CMDLINE, VARE_WANTRES, &value);
     /* TODO: handle errors */
     setenv(variable, value, 1);
     free(value);
+}
 #endif
 /* Called when EOF is reached in the current file. If we were reading an
  * include file, the includes stack is popped and things set up to go back
  * to reading the previous file at the previous location.
+ *
  * Results:
  *	TRUE to continue parsing, i.e. it had only reached the end of an
 @@ -3019,27 +3019,27 @@ ParseDependency(char *line)
+     *
      * Ideally, only the right-hand side would allow undefined
      * variables since it is common to have no dependencies.
      * Having undefined variables on the left-hand side is more
      * unusual though.  Since both sides are expanded in a single
      * pass, there is not much choice what to do here.
+     *
      * In normal mode, it does not matter whether undefined
      * variables are allowed or not since as of 2020-09-14,
      * Var_Parse does not print any parse errors in such a case.
      * It simply returns the special empty string var_Error,
      * which cannot be detected in the result of Var_Subst. */
     eflags = DEBUG(LINT) ? VARE_WANTRES : VARE_UNDEFERR | VARE_WANTRES;
-    (void)Var_Subst(line, VAR_CMD, eflags, &expanded_line);
+    (void)Var_Subst(line, VAR_CMDLINE, eflags, &expanded_line);
     /* TODO: handle errors */
     /* Need a fresh list for the target nodes */
     if (targets != NULL)
 	Lst_Free(targets);
     targets = Lst_New();
     ParseDoDependency(expanded_line);
     free(expanded_line);
     if (shellcmd != NULL)
 	ParseLine_ShellCommand(shellcmd);
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: var.c,v 1.593 2020/10/30 06:59:12 rillig Exp $	*/
+/*	$NetBSD: var.c,v 1.594 2020/10/30 07:19:30 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.
 @@ -119,27 +119,27 @@
 #include    <sys/types.h>
 #include    <regex.h>
 #endif
 #include    <inttypes.h>
 #include    <limits.h>
 #include    <time.h>
 #include    "make.h"
 #include    "dir.h"
 #include    "job.h"
 #include    "metachar.h"
 /*	"@(#)var.c	8.3 (Berkeley) 3/19/94" */
-MAKE_RCSID("$NetBSD: var.c,v 1.593 2020/10/30 06:59:12 rillig Exp $");
+MAKE_RCSID("$NetBSD: var.c,v 1.594 2020/10/30 07:19:30 rillig Exp $");
 #define VAR_DEBUG1(fmt, arg1) DEBUG1(VAR, fmt, arg1)
 #define VAR_DEBUG2(fmt, arg1, arg2) DEBUG2(VAR, fmt, arg1, arg2)
 #define VAR_DEBUG3(fmt, arg1, arg2, arg3) DEBUG3(VAR, fmt, arg1, arg2, arg3)
 #define VAR_DEBUG4(fmt, arg1, arg2, arg3, arg4) DEBUG4(VAR, fmt, arg1, arg2, arg3, arg4)
 ENUM_FLAGS_RTTI_3(VarEvalFlags,
 		  VARE_UNDEFERR, VARE_WANTRES, VARE_ASSIGN);
 /*
  * This lets us tell if we have replaced the original environ
  * (which we cannot free).
  */
 @@ -165,44 +165,44 @@ static char emptyString[] = "";
  * Traditionally this make consumed $$ during := like any other expansion.
  * Other make's do not, and this make follows straight since 2016-01-09.
+ *
  * This knob allows controlling the behavior.
  * FALSE to consume $$ during := assignment.
  * TRUE to preserve $$ during := assignment.
  */
 #define MAKE_SAVE_DOLLARS ".MAKE.SAVE_DOLLARS"
 static Boolean save_dollars = TRUE;
 /*
  * Internally, variables are contained in four different contexts.
  *	1) the environment. They cannot be changed. If an environment
- *	    variable is appended to, the result is placed in the global
+ *	   variable is appended to, the result is placed in the global
- *	    context.
+ *	   context.
- *	2) the global context. Variables set in the Makefile are located in
+ *	2) the global context. Variables set in the makefiles are located
- *	    the global context.
+ *	   here.
  *	3) the command-line context. All variables set on the command line
- *	   are placed in this context. They are UNALTERABLE once placed here.
+ *	   are placed in this context.
  *	4) the local context. Each target has associated with it a context
  *	   list. On this list are located the structures describing such
  *	   local variables as $(@) and $(*)
  * The four contexts are searched in the reverse order from which they are
  * listed (but see opts.checkEnvFirst).
  */
 GNode          *VAR_INTERNAL;	/* variables from make itself */
 GNode          *VAR_GLOBAL;	/* variables from the makefile */
-GNode          *VAR_CMD;	/* variables defined on the command-line */
+GNode          *VAR_CMDLINE;	/* variables defined on the command-line */
 typedef enum VarFindFlags {
-    FIND_CMD		= 0x01,	/* look in VAR_CMD when searching */
+    FIND_CMD		= 0x01,	/* look in VAR_CMDLINE when searching */
     FIND_GLOBAL		= 0x02,	/* look in VAR_GLOBAL as well */
     FIND_ENV		= 0x04	/* look in the environment also */
 } VarFindFlags;
 typedef enum VarFlags {
     /* The variable's value is currently being used by Var_Parse or Var_Subst.
      * This marker is used to avoid endless recursion. */
     VAR_IN_USE = 0x01,
     /* The variable comes from the environment.
      * These variables are not registered in any GNode, therefore they must
      * be freed as soon as they are not used anymore. */
     VAR_FROM_ENV = 0x02,
     /* The variable is exported to the environment, to be used by child
 @@ -346,58 +346,58 @@ GNode_FindVar(GNode *ctxt, const char *v
     return HashTable_FindValueHash(&ctxt->context, varname, hash);
+}
 /*-
  *-----------------------------------------------------------------------
  * VarFind --
  *	Find the given variable in the given context and any other contexts
  *	indicated.
+ *
  * Input:
  *	name		name to find
  *	ctxt		context in which to find it
  *	flags		FIND_GLOBAL	look in VAR_GLOBAL as well
- *			FIND_CMD	look in VAR_CMD as well
+ *			FIND_CMD	look in VAR_CMDLINE as well
  *			FIND_ENV	look in the environment as well
+ *
  * Results:
  *	A pointer to the structure describing the desired variable or
  *	NULL if the variable does not exist.
  *-----------------------------------------------------------------------
  */
 static Var *
 VarFind(const char *name, GNode *ctxt, VarFindFlags flags)
+{
     Var *var;
     unsigned int nameHash;
     /*
      * If the variable name begins with a '.', it could very well be one of
      * the local ones.  We check the name against all the local variables
      * and substitute the short version in for 'name' if it matches one of
      * them.
      */
     name = CanonicalVarname(name);
     nameHash = Hash_Hash(name);
     /*
      * First look for the variable in the given context. If it's not there,
-     * look for it in VAR_CMD, VAR_GLOBAL and the environment, in that order,
+     * look for it in VAR_CMDLINE, VAR_GLOBAL and the environment, in that order,
      * depending on the FIND_* flags in 'flags'
      */
     var = GNode_FindVar(ctxt, name, nameHash);
-    if (var == NULL && (flags & FIND_CMD) && ctxt != VAR_CMD)
+    if (var == NULL && (flags & FIND_CMD) && ctxt != VAR_CMDLINE)
-	var = GNode_FindVar(VAR_CMD, name, nameHash);
+	var = GNode_FindVar(VAR_CMDLINE, name, nameHash);
     if (!opts.checkEnvFirst && var == NULL && (flags & FIND_GLOBAL) &&
 	ctxt != VAR_GLOBAL)
+    {
 	var = GNode_FindVar(VAR_GLOBAL, name, nameHash);
 	if (var == NULL && ctxt != VAR_INTERNAL) {
 	    /* VAR_INTERNAL is subordinate to VAR_GLOBAL */
 	    var = GNode_FindVar(VAR_INTERNAL, name, nameHash);
+	}
+    }
     if (var == NULL && (flags & FIND_ENV)) {
 	char *env;
 @@ -784,44 +784,44 @@ Var_Set_with_flags(const char *name, con
 	/* TODO: handle errors */
 	name = name_freeIt;
+    }
     if (name[0] == '\0') {
 	VAR_DEBUG2("Var_Set(\"%s\", \"%s\", ...) "
 		   "name expands to empty string - ignored\n",
 		   unexpanded_name, val);
 	free(name_freeIt);
 	return;
+    }
     if (ctxt == VAR_GLOBAL) {
-	v = VarFind(name, VAR_CMD, 0);
+	v = VarFind(name, VAR_CMDLINE, 0);
 	if (v != NULL) {
 	    if (v->flags & VAR_FROM_CMD) {
 		VAR_DEBUG3("%s:%s = %s ignored!\n", ctxt->name, name, val);
 		goto out;
+	    }
 	    VarFreeEnv(v, TRUE);
+	}
+    }
     /*
      * We only look for a variable in the given context since anything set
      * here will override anything in a lower context, so there's not much
      * point in searching them all just to save a bit of memory...
      */
     v = VarFind(name, ctxt, 0);
     if (v == NULL) {
-	if (ctxt == VAR_CMD && !(flags & VAR_NO_EXPORT)) {
+	if (ctxt == VAR_CMDLINE && !(flags & VAR_NO_EXPORT)) {
 	    /*
 	     * This var would normally prevent the same name being added
 	     * to VAR_GLOBAL, so delete it from there if needed.
 	     * Otherwise -V name may show the wrong value.
 	     */
 	    Var_Delete(name, VAR_GLOBAL);
+	}
 	VarAdd(name, val, ctxt, flags);
     } else {
 	if ((v->flags & VAR_READONLY) && !(flags & VAR_SET_READONLY)) {
 	    VAR_DEBUG3("%s:%s = %s ignored (read-only)\n",
 		       ctxt->name, name, val);
 	    goto out;
 @@ -830,27 +830,27 @@ Var_Set_with_flags(const char *name, con
 	if (val)
 	    Buf_AddStr(&v->val, val);
 	VAR_DEBUG3("%s:%s = %s\n", ctxt->name, name, val);
 	if (v->flags & VAR_EXPORTED) {
 	    Var_Export1(name, VAR_EXPORT_PARENT);
+	}
+    }
     /*
      * Any variables given on the command line are automatically exported
      * to the environment (as per POSIX standard)
      * Other than internals.
      */
-    if (ctxt == VAR_CMD && !(flags & VAR_NO_EXPORT) && name[0] != '.') {
+    if (ctxt == VAR_CMDLINE && !(flags & VAR_NO_EXPORT) && name[0] != '.') {
 	if (v == NULL) {
 	    /* we just added it */
 	    v = VarFind(name, ctxt, 0);
+	}
 	if (v != NULL)
 	    v->flags |= VAR_FROM_CMD;
 	/*
 	 * If requested, don't export these in the environment
 	 * individually.  We still put them in MAKEOVERRIDES so
 	 * that the command-line settings continue to override
 	 * Makefile settings.
 	 */
 	if (!opts.varNoExportEnv)
 @@ -873,32 +873,32 @@ out:
  *	Set the variable name to the value val in the given context.
+ *
  *	If the variable doesn't yet exist, it is created.
  *	Otherwise the new value overwrites and replaces the old value.
+ *
  * Input:
  *	name		name of variable to set
  *	val		value to give to the variable
  *	ctxt		context in which to set it
+ *
  * Notes:
  *	The variable is searched for only in its context before being
  *	created in that context. I.e. if the context is VAR_GLOBAL,
- *	only VAR_GLOBAL->context is searched. Likewise if it is VAR_CMD, only
+ *	only VAR_GLOBAL->context is searched. Likewise if it is VAR_CMDLINE,
- *	VAR_CMD->context is searched. This is done to avoid the literally
+ *	only VAR_CMDLINE->context is searched. This is done to avoid the
- *	thousands of unnecessary strcmp's that used to be done to
+ *	literally thousands of unnecessary strcmp's that used to be done to
  *	set, say, $(@) or $(<).
  *	If the context is VAR_GLOBAL though, we check if the variable
- *	was set in VAR_CMD from the command line and skip it if so.
+ *	was set in VAR_CMDLINE from the command line and skip it if so.
  *-----------------------------------------------------------------------
  */
 void
 Var_Set(const char *name, const char *val, GNode *ctxt)
+{
     Var_Set_with_flags(name, val, ctxt, 0);
+}
 /*-
  *-----------------------------------------------------------------------
  * Var_Append --
  *	The variable of the given name has the given value appended to it in
  *	the given context.
 @@ -936,27 +936,27 @@ Var_Append(const char *name, const char
 	if (name[0] == '\0') {
 	    VAR_DEBUG2("Var_Append(\"%s\", \"%s\", ...) "
 		      "name expands to empty string - ignored\n",
 		      unexpanded_name, val);
 	    free(name_freeIt);
 	    return;
+	}
+    }
     v = VarFind(name, ctxt, ctxt == VAR_GLOBAL ? (FIND_CMD | FIND_ENV) : 0);
     if (v == NULL) {
 	Var_Set(name, val, ctxt);
-    } else if (ctxt == VAR_CMD || !(v->flags & VAR_FROM_CMD)) {
+    } else if (ctxt == VAR_CMDLINE || !(v->flags & VAR_FROM_CMD)) {
 	Buf_AddByte(&v->val, ' ');
 	Buf_AddStr(&v->val, val);
 	VAR_DEBUG3("%s:%s = %s\n",
 	    ctxt->name, name, Buf_GetAll(&v->val, NULL));
 	if (v->flags & VAR_FROM_ENV) {
 	    HashEntry *h;
 	    /*
 	     * If the original variable came from the environment, we
 	     * have to install it in the global context (we could place
 	     * it in the environment, but then we should provide a way to
 @@ -3318,63 +3318,63 @@ bad_modifier:
 cleanup:
     *pp = p;
     free(*freePtr);
     *freePtr = NULL;
     *exprFlags = st.exprFlags;
     return var_Error;
+}
 static Boolean
 VarIsDynamic(GNode *ctxt, const char *varname, size_t namelen)
+{
     if ((namelen == 1 ||
 	 (namelen == 2 && (varname[1] == 'F' || varname[1] == 'D'))) &&
-	(ctxt == VAR_CMD || ctxt == VAR_GLOBAL))
+	(ctxt == VAR_CMDLINE || ctxt == VAR_GLOBAL))
+    {
 	/*
 	 * If substituting a local variable in a non-local context,
 	 * assume it's for dynamic source stuff. We have to handle
 	 * this specially and return the longhand for the variable
 	 * with the dollar sign escaped so it makes it back to the
 	 * caller. Only four of the local variables are treated
 	 * specially as they are the only four that will be set
 	 * when dynamic sources are expanded.
 	 */
 	switch (varname[0]) {
 	case '@':
 	case '%':
 	case '*':
 	case '!':
 	    return TRUE;
+	}
 	return FALSE;
+    }
     if ((namelen == 7 || namelen == 8) && varname[0] == '.' &&
-	ch_isupper(varname[1]) && (ctxt == VAR_CMD || ctxt == VAR_GLOBAL))
+	ch_isupper(varname[1]) && (ctxt == VAR_CMDLINE || ctxt == VAR_GLOBAL))
+    {
 	return strcmp(varname, ".TARGET") == 0 ||
 	       strcmp(varname, ".ARCHIVE") == 0 ||
 	       strcmp(varname, ".PREFIX") == 0 ||
 	       strcmp(varname, ".MEMBER") == 0;
+    }
     return FALSE;
+}
 static const char *
 UndefinedShortVarValue(char varname, const GNode *ctxt, VarEvalFlags eflags)
+{
-    if (ctxt == VAR_CMD || ctxt == VAR_GLOBAL) {
+    if (ctxt == VAR_CMDLINE || ctxt == VAR_GLOBAL) {
 	/*
 	 * If substituting a local variable in a non-local context,
 	 * assume it's for dynamic source stuff. We have to handle
 	 * this specially and return the longhand for the variable
 	 * with the dollar sign escaped so it makes it back to the
 	 * caller. Only four of the local variables are treated
 	 * specially as they are the only four that will be set
 	 * when dynamic sources are expanded.
 	 */
 	switch (varname) {
 	case '@':
 	    return "$(.TARGET)";
 	case '%':
 @@ -3591,27 +3591,27 @@ Var_Parse(const char **pp, GNode *ctxt,
 	    *out_val = var_Error;
 	    return VPR_PARSE_MSG;
+	}
 	v = VarFind(varname, ctxt, FIND_ENV | FIND_GLOBAL | FIND_CMD);
 	/* At this point, p points just after the variable name,
 	 * either at ':' or at endc. */
 	/*
 	 * Check also for bogus D and F forms of local variables since we're
 	 * in a local context and the name is the right length.
 	 */
-	if (v == NULL && ctxt != VAR_CMD && ctxt != VAR_GLOBAL &&
+	if (v == NULL && ctxt != VAR_CMDLINE && ctxt != VAR_GLOBAL &&
 	    namelen == 2 && (varname[1] == 'F' || varname[1] == 'D') &&
 	    strchr("@%?*!<>", varname[0]) != NULL)
+	{
 	    /*
 	     * Well, it's local -- go look for it.
 	     */
 	    char name[] = { varname[0], '\0' };
 	    v = VarFind(name, ctxt, 0);
 	    if (v != NULL) {
 		if (varname[1] == 'D') {
 		    extramodifiers = "H:";
 		} else { /* F */
 @@ -3852,27 +3852,27 @@ Var_Subst(const char *str, GNode *ctxt,
+	}
+    }
     *out_res = Buf_DestroyCompact(&buf);
     return VPR_OK;
+}
 /* Initialize the variables module. */
 void
 Var_Init(void)
+{
     VAR_INTERNAL = Targ_NewGN("Internal");
     VAR_GLOBAL = Targ_NewGN("Global");
-    VAR_CMD = Targ_NewGN("Command");
+    VAR_CMDLINE = Targ_NewGN("Command");
+}
 /* Clean up the variables module. */
 void
 Var_End(void)
+{
     Var_Stats();
+}
 void
 Var_Stats(void)
+{
     HashTable_DebugStats(&VAR_GLOBAL->context, "VAR_GLOBAL");

 @@ -1,14 +1,14 @@
-/*	$NetBSD: job.c,v 1.293 2020/10/26 23:28:52 rillig Exp $	*/
+/*	$NetBSD: job.c,v 1.294 2020/10/30 07:19:30 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.293 2020/10/26 23:28:52 rillig Exp $");
+MAKE_RCSID("$NetBSD: job.c,v 1.294 2020/10/30 07:19:30 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
 @@ -2049,27 +2049,27 @@ Shell_Init(void)
 	 * We are using the default shell, which may be an absolute
 	 * path if DEFSHELL_CUSTOM is defined.
 	 */
 	shellName = commandShell->name;
 #ifdef DEFSHELL_CUSTOM
 	if (*shellName == '/') {
 	    shellPath = shellName;
 	    shellName = strrchr(shellPath, '/');
 	    shellName++;
 	} else
 #endif
 	shellPath = str_concat3(_PATH_DEFSHELLDIR, "/", shellName);
+    }
-    Var_Set_with_flags(".SHELL", shellPath, VAR_CMD, VAR_SET_READONLY);
+    Var_Set_with_flags(".SHELL", shellPath, VAR_CMDLINE, VAR_SET_READONLY);
     if (commandShell->exit == NULL) {
 	commandShell->exit = "";
+    }
     if (commandShell->echo == NULL) {
 	commandShell->echo = "";
+    }
     if (commandShell->hasErrCtl && commandShell->exit[0] != '\0') {
 	if (shellErrFlag &&
 	    strcmp(commandShell->exit, &shellErrFlag[1]) != 0) {
 	    free(shellErrFlag);
 	    shellErrFlag = NULL;
+	}
 	if (!shellErrFlag) {

 @@ -1,14 +1,14 @@
-/*	$NetBSD: targ.c,v 1.125 2020/10/26 21:34:10 rillig Exp $	*/
+/*	$NetBSD: targ.c,v 1.126 2020/10/30 07:19:30 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.
 @@ -111,27 +111,27 @@
  * Debugging:
  *	Targ_PrintGraph
  *			Print out the entire graphm all variables and
  *			statistics for the directory cache. Should print
  *			something for suffixes, too, but...
  */
 #include <time.h>
 #include "make.h"
 #include "dir.h"
 /*	"@(#)targ.c	8.2 (Berkeley) 3/19/94"	*/
-MAKE_RCSID("$NetBSD: targ.c,v 1.125 2020/10/26 21:34:10 rillig Exp $");
+MAKE_RCSID("$NetBSD: targ.c,v 1.126 2020/10/30 07:19:30 rillig Exp $");
 static GNodeList *allTargets;	/* the list of all targets found so far */
 #ifdef CLEANUP
 static GNodeList *allGNs;	/* List of all the GNodes */
 #endif
 static HashTable targets;	/* a hash table of same */
 #ifdef CLEANUP
 static void TargFreeGN(void *);
 #endif
 void
 Targ_Init(void)
 @@ -528,27 +528,27 @@ PrintOnlySources(void)
  *			3 => after processing, an error occurred
  */
 void
 Targ_PrintGraph(int pass)
+{
     debug_printf("#*** Input graph:\n");
     Targ_PrintNodes(allTargets, pass);
     debug_printf("\n\n");
     debug_printf("#\n#   Files that are only sources:\n");
     PrintOnlySources();
     debug_printf("#*** Global Variables:\n");
     Var_Dump(VAR_GLOBAL);
     debug_printf("#*** Command-line Variables:\n");
-    Var_Dump(VAR_CMD);
+    Var_Dump(VAR_CMDLINE);
     debug_printf("\n");
     Dir_PrintDirectories();
     debug_printf("\n");
     Suff_PrintAll();
+}
 /* Propagate some type information to cohort nodes (those from the ::
  * dependency operator).
+ *
  * Should be called after the makefiles are parsed but before any action is
  * taken. */
 void
 Targ_Propagate(void)