 @@ -1,14 +1,14 @@
-/*	$NetBSD: var.c,v 1.275 2020/07/19 21:30:49 rillig Exp $	*/
+/*	$NetBSD: var.c,v 1.276 2020/07/19 22:04:27 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.
 @@ -59,34 +59,34 @@
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #ifndef MAKE_NATIVE
-static char rcsid[] = "$NetBSD: var.c,v 1.275 2020/07/19 21:30:49 rillig Exp $";
+static char rcsid[] = "$NetBSD: var.c,v 1.276 2020/07/19 22:04:27 rillig Exp $";
 #else
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)var.c	8.3 (Berkeley) 3/19/94";
 #else
-__RCSID("$NetBSD: var.c,v 1.275 2020/07/19 21:30:49 rillig Exp $");
+__RCSID("$NetBSD: var.c,v 1.276 2020/07/19 22:04:27 rillig Exp $");
 #endif
 #endif /* not lint */
 #endif
 /*-
  * var.c --
  *	Variable-handling functions
+ *
  * Interface:
  *	Var_Set		    Set the value of a variable in the given
  *			    context. The variable is created if it doesn't
  *			    yet exist. The value and variable name need not
  *			    be preserved.
 @@ -1298,42 +1298,47 @@ Str_SYSVSubst(Buffer *buf, const char *p
 	/* skip the % */
 	pat = m + 1;
+    }
     if (m != NULL || !lhsHasPercent) {
 	/* Copy the pattern */
 	Buf_AddBytes(buf, len, src);
+    }
     /* append the rest */
     Buf_AddBytes(buf, strlen(pat), pat);
+}
 typedef struct {
     const char *lhs;
     const char *rhs;
 } VarSYSVSubstArgs;
 /* Callback function for VarModify to implement the :%.from=%.to modifier. */
 static Boolean
-VarSYSVMatch(GNode *ctx, Var_Parse_State *vpstate,
+VarSYSVSubst(GNode *ctx, Var_Parse_State *vpstate,
 	     const char *word, Boolean addSpace, Buffer *buf,
 	     void *data)
+{
-    size_t len;
+    const VarSYSVSubstArgs *args = data;
     const char *ptr;
     Boolean hasPercent;
     VarPattern *pat = data;
     if (addSpace && vpstate->varSpace != '\0')
 	Buf_AddByte(buf, vpstate->varSpace);
-    if ((ptr = Str_SYSVMatch(word, pat->lhs, &len, &hasPercent)) != NULL) {
+    size_t len;
-	char *varexp = Var_Subst(NULL, pat->rhs, ctx, VARE_WANTRES);
+    Boolean hasPercent;
     const char *ptr = Str_SYSVMatch(word, args->lhs, &len, &hasPercent);
     if (ptr != NULL) {
 	char *varexp = Var_Subst(NULL, args->rhs, ctx, VARE_WANTRES);
 	Str_SYSVSubst(buf, varexp, ptr, len, hasPercent);
 	free(varexp);
     } else {
 	Buf_AddBytes(buf, strlen(word), word);
+    }
     return TRUE;
+}
 #endif
 /* Callback function for VarModify to implement the :N modifier.
  * Place the word in the buffer if it doesn't match the given pattern. */
 static Boolean
 @@ -3157,89 +3162,81 @@ ApplyModifier_Remember(ApplyModifiersSta
     } else {
 	Var_Set("_", st->nstr, st->ctxt);
+    }
     st->newStr = st->nstr;
     st->termc = *st->cp;
     return TRUE;
+}
 #ifdef SYSVVARSUB
 /* :from=to */
 static int
 ApplyModifier_SysV(ApplyModifiersState *st)
+{
-    /*
+    Boolean eqFound = FALSE;
      * This can either be a bogus modifier or a System-V
      * substitution command.
      */
     VarPattern      pattern;
     /* FIXME: SysV modifiers have nothing to do with :S or :C pattern matching */
     Boolean         eqFound = FALSE;
     pattern.pflags = 0;
     /*
      * First we make a pass through the string trying
      * to verify it is a SYSV-make-style translation:
      * it must be: <string1>=<string2>)
      */
     st->cp = st->tstr;
     int nest = 1;
     while (*st->cp != '\0' && nest > 0) {
 	if (*st->cp == '=') {
 	    eqFound = TRUE;
 	    /* continue looking for st->endc */
 	} else if (*st->cp == st->endc)
 	    nest--;
 	else if (*st->cp == st->startc)
 	    nest++;
 	if (nest > 0)
 	    st->cp++;
+    }
     if (*st->cp != st->endc || !eqFound)
 	return 0;
     st->delim = '=';
     st->cp = st->tstr;
     VarPatternFlags pflags = 0;
     /* FIXME: There's no point in having a single $ at the end of a
      * SysV substitution since that will not be interpreted as an
      * anchor anyway. */
-    pattern.lhs = ParseModifierPart(
+    char *lhs = ParseModifierPart(st->ctxt, &st->cp, st->delim, st->eflags,
-	st->ctxt, &st->cp, st->delim, st->eflags,
+				  &pflags, NULL, NULL);
-	&pattern.pflags, &pattern.leftLen, NULL);
+    if (lhs == NULL)
     if (pattern.lhs == NULL)
 	return 'c';
     st->delim = st->endc;
-    pattern.rhs = ParseModifierPart(
+    char *rhs = ParseModifierPart(st->ctxt, &st->cp, st->delim, st->eflags,
-	st->ctxt, &st->cp, st->delim, st->eflags,
+				  NULL, NULL, NULL);
-	NULL, &pattern.rightLen, &pattern);
+    if (rhs == NULL)
     if (pattern.rhs == NULL)
 	return 'c';
     /*
      * SYSV modifications happen through the whole
      * string. Note the pattern is anchored at the end.
      */
     st->termc = *--st->cp;
     st->delim = '\0';
-    if (pattern.leftLen == 0 && *st->nstr == '\0') {
+    if (lhs[0] == '\0' && *st->nstr == '\0') {
 	st->newStr = st->nstr;	/* special case */
     } else {
-	st->newStr = VarModify(
+	VarSYSVSubstArgs args = { lhs, rhs };
-	    st->ctxt, &st->parsestate, st->nstr, VarSYSVMatch, &pattern);
+	st->newStr = VarModify(st->ctxt, &st->parsestate, st->nstr,
 			       VarSYSVSubst, &args);
+    }
-    free(UNCONST(pattern.lhs));
+    free(lhs);
-    free(UNCONST(pattern.rhs));
+    free(rhs);
     return '=';
+}
 #endif
 /*
  * Now we need to apply any modifiers the user wants applied.
  * These are:
  *  	  :M<pattern>	words which match the given <pattern>.
  *  			<pattern> is of the standard file
  *  			wildcarding form.
  *  	  :N<pattern>	words which do not match the given <pattern>.
  *  	  :S<d><pat1><d><pat2><d>[1gW]
  *  			Substitute <pat2> for <pat1> in the value

 @@ -4,15 +4,15 @@ fun
 fun
 fun
 In the Sun
 acme
 aam.d
 sam.c
 a%.c
 asam.c.c
 asam.c
 a.c.c
 ax:Q b c d eb
 bcd.e
 a.bcd.e
 exit status 0

 @@ -1,14 +1,14 @@
-# $Id: sysv.mk,v 1.6 2020/07/19 14:23:02 rillig Exp $
+# $Id: sysv.mk,v 1.7 2020/07/19 22:04:27 rillig Exp $
 all: foo fun sam bla words ampersand
 FOO ?=
 FOOBAR = ${FOO:=bar}
 _this := ${.PARSEDIR}/${.PARSEFILE}
 B = /b
 S = /
 FUN = ${B}${S}fun
 SUN = the Sun
 @@ -37,20 +37,20 @@ sam:
 	@echo ${SAM:%.c=a%.c}
 	@echo ${SAM:sam%=a%.c}
 BLA=
 bla:
 	@echo $(BLA:%=foo/%x)
 # The :Q looks like a modifier but isn't.
 # It is part of the replacement string.
 words:
 	@echo a${a b c d e:L:%a=x:Q}b
-# As of 2020-07-19, an ampersand can be used in the replacement part
+# Before 2020-07-19, an ampersand could be used in the replacement part
-# of a SysV substitution modifier.  This can either be an intentional
+# of a SysV substitution modifier.  This was probably a copy-and-paste
-# feature or an implementation mistake, as it is not mentioned in the
+# mistake since the SysV modifier code looked a lot like the code for the
-# manual page.
+# :S and :C modifiers.  The ampersand is not mentioned in the manual page.
 ampersand:
 	@echo ${:U${a.bcd.e:L:a.%=%}:Q}
 	@echo ${:U${a.bcd.e:L:a.%=&}:Q}