 @@ -1,14 +1,14 @@
-/*	$NetBSD: var.c,v 1.863 2021/03/14 15:24:37 rillig Exp $	*/
+/*	$NetBSD: var.c,v 1.864 2021/03/14 15:43:31 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.
 @@ -130,27 +130,27 @@
 #include <regex.h>
 #endif
 #include <errno.h>
 #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.863 2021/03/14 15:24:37 rillig Exp $");
+MAKE_RCSID("$NetBSD: var.c,v 1.864 2021/03/14 15:43:31 rillig Exp $");
 typedef enum VarFlags {
 	VFL_NONE	= 0,
 	/*
 	 * The variable's value is currently being used by Var_Parse or
 	 * Var_Subst.  This marker is used to avoid endless recursion.
 	 */
 	VFL_IN_USE	= 1 << 0,
 	/*
 	 * The variable comes from the environment.
 	 * These variables are not registered in any GNode, therefore they
 @@ -2496,29 +2496,32 @@ ApplyModifier_Defined(const char **pp, A
 	if (eflags & VARE_WANTRES)
 		Expr_SetValueOwn(expr, Buf_DoneData(&buf));
 	else
 		Buf_Done(&buf);
 	return AMR_OK;
+}
 /* :L */
 static ApplyModifierResult
 ApplyModifier_Literal(const char **pp, ApplyModifiersState *st)
+{
 	Expr *expr = st->expr;
 	(*pp)++;
 	Expr_Define(expr);
 	Expr_SetValueOwn(expr, bmake_strdup(expr->var->name.str));
 	(*pp)++;
 	return AMR_OK;
+}
 static Boolean
 TryParseTime(const char **pp, time_t *out_time)
+{
 	char *end;
 	unsigned long n;
 	if (!ch_isdigit(**pp))
 		return FALSE;
 	errno = 0;
 @@ -2543,121 +2546,127 @@ ApplyModifier_Gmtime(const char **pp, Ap
 	if (mod[6] == '=') {
 		const char *p = mod + 7;
 		if (!TryParseTime(&p, &utc)) {
 			Parse_Error(PARSE_FATAL,
 			    "Invalid time value: %s", mod + 7);
 			return AMR_CLEANUP;
+		}
 		*pp = p;
 	} else {
 		utc = 0;
 		*pp = mod + 6;
+	}
 	Expr_SetValueOwn(st->expr,
 	    VarStrftime(st->expr->value.str, TRUE, utc));
 	return AMR_OK;
+}
 /* :localtime */
 static ApplyModifierResult
 ApplyModifier_Localtime(const char **pp, ApplyModifiersState *st)
+{
 	time_t utc;
 	const char *mod = *pp;
 	if (!ModMatchEq(mod, "localtime", st))
 		return AMR_UNKNOWN;
 	if (mod[9] == '=') {
 		const char *p = mod + 10;
 		if (!TryParseTime(&p, &utc)) {
 			Parse_Error(PARSE_FATAL,
 			    "Invalid time value: %s", mod + 10);
 			return AMR_CLEANUP;
+		}
 		*pp = p;
 	} else {
 		utc = 0;
 		*pp = mod + 9;
+	}
 	Expr_SetValueOwn(st->expr,
 	    VarStrftime(st->expr->value.str, FALSE, utc));
 	return AMR_OK;
+}
 /* :hash */
 static ApplyModifierResult
 ApplyModifier_Hash(const char **pp, ApplyModifiersState *st)
+{
 	if (!ModMatch(*pp, "hash", st))
 		return AMR_UNKNOWN;
 	*pp += 4;
 	Expr_SetValueOwn(st->expr, VarHash(st->expr->value.str));
 	*pp += 4;
 	return AMR_OK;
+}
 /* :P */
 static ApplyModifierResult
 ApplyModifier_Path(const char **pp, ApplyModifiersState *st)
+{
 	Expr *expr = st->expr;
 	GNode *gn;
 	char *path;
 	(*pp)++;
 	Expr_Define(expr);
 	gn = Targ_FindNode(expr->var->name.str);
 	if (gn == NULL || gn->type & OP_NOPATH) {
 		path = NULL;
 	} else if (gn->path != NULL) {
 		path = bmake_strdup(gn->path);
 	} else {
 		SearchPath *searchPath = Suff_FindPath(gn);
 		path = Dir_FindFile(expr->var->name.str, searchPath);
+	}
 	if (path == NULL)
 		path = bmake_strdup(expr->var->name.str);
 	Expr_SetValueOwn(expr, path);
 	(*pp)++;
 	return AMR_OK;
+}
 /* :!cmd! */
 static ApplyModifierResult
 ApplyModifier_ShellCommand(const char **pp, ApplyModifiersState *st)
+{
 	Expr *expr = st->expr;
 	char *cmd;
 	const char *errfmt;
 	VarParseResult res;
 	(*pp)++;
 	res = ParseModifierPart(pp, '!', expr->eflags, st, &cmd);
 	if (res != VPR_OK)
 		return AMR_CLEANUP;
 	errfmt = NULL;
 	if (expr->eflags & VARE_WANTRES)
 		Expr_SetValueOwn(expr, Cmd_Exec(cmd, &errfmt));
 	else
 		Expr_SetValueRefer(expr, "");
 	if (errfmt != NULL)
 		Error(errfmt, cmd);	/* XXX: why still return AMR_OK? */
 	free(cmd);
 	Expr_Define(expr);
 	return AMR_OK;
+}
 /*
  * The :range modifier generates an integer sequence as long as the words.
  * The :range=7 modifier generates an integer sequence from 1 to 7.
  */
 static ApplyModifierResult
 ApplyModifier_Range(const char **pp, ApplyModifiersState *st)
+{
 	size_t n;
 	Buffer buf;
 	size_t i;
 @@ -2939,55 +2948,55 @@ static void
 ModifyWord_Copy(const char *word, SepBuf *buf, void *data MAKE_ATTR_UNUSED)
+{
 	SepBuf_AddStr(buf, word);
+}
 /* :ts<separator> */
 static ApplyModifierResult
 ApplyModifier_ToSep(const char **pp, ApplyModifiersState *st)
+{
 	const char *sep = *pp + 2;
 	/* ":ts<any><endc>" or ":ts<any>:" */
 	if (sep[0] != st->endc && IsDelimiter(sep[1], st)) {
 		st->sep = sep[0];
 		*pp = sep + 1;
 		st->sep = sep[0];
 		goto ok;
+	}
 	/* ":ts<endc>" or ":ts:" */
 	if (IsDelimiter(sep[0], st)) {
 		st->sep = '\0';	/* no separator */
 		*pp = sep;
 		st->sep = '\0';	/* no separator */
 		goto ok;
+	}
 	/* ":ts<unrecognised><unrecognised>". */
 	if (sep[0] != '\\') {
 		(*pp)++;	/* just for backwards compatibility */
 		return AMR_BAD;
+	}
 	/* ":ts\n" */
 	if (sep[1] == 'n') {
 		st->sep = '\n';
 		*pp = sep + 2;
 		st->sep = '\n';
 		goto ok;
+	}
 	/* ":ts\t" */
 	if (sep[1] == 't') {
 		st->sep = '\t';
 		*pp = sep + 2;
 		st->sep = '\t';
 		goto ok;
+	}
 	/* ":ts\x40" or ":ts\100" */
+	{
 		const char *p = sep + 1;
 		int base = 8;	/* assume octal */
 		if (sep[1] == 'x') {
 			base = 16;
 			p++;
 		} else if (!ch_isdigit(sep[1])) {
 			(*pp)++;	/* just for backwards compatibility */
 @@ -3052,51 +3061,51 @@ ApplyModifier_To(const char **pp, ApplyM
 		*pp = mod + 1;
 		return AMR_BAD;	/* Found ":t<endc>" or ":t:". */
+	}
 	if (mod[1] == 's')
 		return ApplyModifier_ToSep(pp, st);
 	if (!IsDelimiter(mod[2], st)) {			/* :t<unrecognized> */
 		*pp = mod + 1;
 		return AMR_BAD;
+	}
 	if (mod[1] == 'A') {				/* :tA */
 		ModifyWords(st, ModifyWord_Realpath, NULL, st->oneBigWord);
 		*pp = mod + 2;
 		ModifyWords(st, ModifyWord_Realpath, NULL, st->oneBigWord);
 		return AMR_OK;
+	}
 	if (mod[1] == 'u') {				/* :tu */
 		Expr_SetValueOwn(expr, str_toupper(expr->value.str));
 		*pp = mod + 2;
 		Expr_SetValueOwn(expr, str_toupper(expr->value.str));
 		return AMR_OK;
+	}
 	if (mod[1] == 'l') {				/* :tl */
 		Expr_SetValueOwn(expr, str_tolower(expr->value.str));
 		*pp = mod + 2;
 		Expr_SetValueOwn(expr, str_tolower(expr->value.str));
 		return AMR_OK;
+	}
 	if (mod[1] == 'W' || mod[1] == 'w') {		/* :tW, :tw */
 		st->oneBigWord = mod[1] == 'W';
 		*pp = mod + 2;
 		st->oneBigWord = mod[1] == 'W';
 		return AMR_OK;
+	}
 	/* Found ":t<unrecognised>:" or ":t<unrecognised><endc>". */
-	*pp = mod + 1;
+	*pp = mod + 1;		/* XXX: unnecessary but observable */
 	return AMR_BAD;
+}
 /* :[#], :[1], :[-1..1], etc. */
 static ApplyModifierResult
 ApplyModifier_Words(const char **pp, ApplyModifiersState *st)
+{
 	Expr *expr = st->expr;
 	char *estr;
 	int first, last;
 	VarParseResult res;
 	const char *p;
 @@ -3206,26 +3215,28 @@ ShuffleStrings(char **strs, size_t n)
 		size_t rndidx = (size_t)random() % (i + 1);
 		char *t = strs[i];
 		strs[i] = strs[rndidx];
 		strs[rndidx] = t;
+	}
+}
 /* :O (order ascending) or :Or (order descending) or :Ox (shuffle) */
 static ApplyModifierResult
 ApplyModifier_Order(const char **pp, ApplyModifiersState *st)
+{
 	const char *mod = (*pp)++;	/* skip past the 'O' in any case */
 	/* TODO: separate parsing from evaluating */
 	Words words = Str_Words(st->expr->value.str, FALSE);
 	if (IsDelimiter(mod[1], st)) {
 		/* :O sorts ascending */
 		qsort(words.words, words.len, sizeof words.words[0],
 		    str_cmp_asc);
 	} else if ((mod[1] == 'r' || mod[1] == 'x') &&
 	    IsDelimiter(mod[2], st)) {
 		(*pp)++;
 		if (mod[1] == 'r') {	/* :Or sorts descending */
 			qsort(words.words, words.len, sizeof words.words[0],
 @@ -3311,26 +3322,28 @@ ApplyModifier_IfElse(const char **pp, Ap
  *			it was not already set.
  *	  ::+=<str>	Appends <str> to variable.
  *	  ::!=<cmd>	Assigns output of <cmd> as the new value of
  *			variable.
  */
 static ApplyModifierResult
 ApplyModifier_Assign(const char **pp, ApplyModifiersState *st)
+{
 	Expr *expr = st->expr;
 	GNode *scope;
 	char *val;
 	VarParseResult res;
 	/* TODO: separate parsing from evaluating */
 	const char *mod = *pp;
 	const char *op = mod + 1;
 	if (op[0] == '=')
 		goto ok;
 	if ((op[0] == '!' || op[0] == '+' || op[0] == '?') && op[1] == '=')
 		goto ok;
 	return AMR_UNKNOWN;	/* "::<unrecognised>" */
 ok:
 	if (expr->var->name.str[0] == '\0') {
 		*pp = mod + 1;
 		return AMR_BAD;
 @@ -3403,49 +3416,56 @@ ApplyModifier_Remember(const char **pp,
 	Expr *expr = st->expr;
 	const char *mod = *pp;
 	if (!ModMatchEq(mod, "_", st))
 		return AMR_UNKNOWN;
 	if (mod[1] == '=') {
 		/*
 		 * XXX: This ad-hoc call to strcspn deviates from the usual
 		 * behavior defined in ParseModifierPart.  This creates an
 		 * unnecessary, undocumented inconsistency in make.
 		 */
 		size_t n = strcspn(mod + 2, ":)}");
 		char *name = bmake_strldup(mod + 2, n);
 		*pp = mod + 2 + n;
 		/*
 		 * FIXME: do not expand the variable name here; it would only
 		 *  work for single-character variable names anyway.
 		 */
 		Var_SetExpand(expr->scope, name, expr->value.str);
 		free(name);
 		*pp = mod + 2 + n;
 	} else {
 		Var_Set(expr->scope, "_", expr->value.str);
 		*pp = mod + 1;
 		Var_Set(expr->scope, "_", expr->value.str);
+	}
 	return AMR_OK;
+}
 /*
  * Apply the given function to each word of the variable value,
  * for a single-letter modifier such as :H, :T.
  */
 static ApplyModifierResult
 ApplyModifier_WordFunc(const char **pp, ApplyModifiersState *st,
 		       ModifyWordProc modifyWord)
+{
 	if (!IsDelimiter((*pp)[1], st))
 		return AMR_UNKNOWN;
 	(*pp)++;
 	ModifyWords(st, modifyWord, NULL, st->oneBigWord);
 	(*pp)++;
 	return AMR_OK;
+}
 static ApplyModifierResult
 ApplyModifier_Unique(const char **pp, ApplyModifiersState *st)
+{
 	if (!IsDelimiter((*pp)[1], st))
 		return AMR_UNKNOWN;
 	(*pp)++;
 	Expr_SetValueOwn(st->expr, VarUniq(st->expr->value.str));
 	return AMR_OK;
 @@ -3507,44 +3527,45 @@ ApplyModifier_SysV(const char **pp, Appl
 	return AMR_OK;
+}
 #endif
 #ifdef SUNSHCMD
 /* :sh */
 static ApplyModifierResult
 ApplyModifier_SunShell(const char **pp, ApplyModifiersState *st)
+{
 	Expr *expr = st->expr;
 	const char *p = *pp;
 	if (!(p[1] == 'h' && IsDelimiter(p[2], st)))
 		return AMR_UNKNOWN;
 	*pp = p + 2;
 	if (expr->eflags & VARE_WANTRES) {
 		const char *errfmt;
 		char *output = Cmd_Exec(expr->value.str, &errfmt);
 		if (errfmt != NULL)
 			Error(errfmt, expr->value.str);
 		Expr_SetValueOwn(expr, output);
 	} else {
 		/*
 		 * TODO: Check whether returning ":sh" would be
 		 *  more consistent with the other modifiers.
+		 *
 		 * TODO: Add a unit test demonstrating that the
 		 *  actual value of this expression has any effect.
 		 */
 		Expr_SetValueRefer(expr, "");
+	}
 	*pp = p + 2;
 	return AMR_OK;
+}
 #endif
 static void
 LogBeforeApply(const ApplyModifiersState *st, const char *mod)
+{
 	const Expr *expr = st->expr;
 	char eflags_str[VarEvalFlags_ToStringSize];
 	char vflags_str[VarFlags_ToStringSize];
 	Boolean is_single_char = mod[0] != '\0' && IsDelimiter(mod[1], st);
 	/* At this point, only the first character of the modifier can