Sun Oct 18 21:36:22 2020 UTC ()

make(1): explain existing tests for the ::= assignment modifiers


(rillig)

diff -r1.5 -r1.6 src/usr.bin/make/unit-tests/varmod-assign.exp
diff -r1.6 -r1.7 src/usr.bin/make/unit-tests/varmod-assign.mk

--- src/usr.bin/make/unit-tests/varmod-assign.exp 2020/08/25 21:16:53	1.5
+++ src/usr.bin/make/unit-tests/varmod-assign.exp 2020/10/18 21:36:22	1.6

 @@ -1,26 +1,26 @@
 mod-assign: first=1.
 mod-assign: last=3.
 mod-assign: appended=1 2 3.
 mod-assign: ran:3.
 mod-assign: global: 1, 3, 1 2 3, 3.
 mod-assign-nested: then1t1
 mod-assign-nested: else2e2
 mod-assign-nested: then3t3
 mod-assign-nested: else4e4
 make: Bad modifier `:' for
-value}
+mod-assign-empty: value}
 make: Bad modifier `:' for
 mod-assign-empty: overwritten}
 mod-assign-empty: VAR=overwritten
 make: Unknown modifier ':'
 sysv:y
 make: Unfinished modifier for ASSIGN ('}' missing)
 ok=word
 make: " echo word; false " returned non-zero status
 err=previous
 exit status 0

--- src/usr.bin/make/unit-tests/varmod-assign.mk 2020/08/25 21:16:53	1.6
+++ src/usr.bin/make/unit-tests/varmod-assign.mk 2020/10/18 21:36:22	1.7

 @@ -1,14 +1,14 @@
-# $NetBSD: varmod-assign.mk,v 1.6 2020/08/25 21:16:53 rillig Exp $
+# $NetBSD: varmod-assign.mk,v 1.7 2020/10/18 21:36:22 rillig Exp $
+#
 # Tests for the obscure ::= variable modifiers, which perform variable
 # assignments during evaluation, just like the = operator in C.
 all:	mod-assign
 all:	mod-assign-nested
 all:	mod-assign-empty
 all:	mod-assign-parse
 all:	mod-assign-shell-error
 mod-assign:
 	# The ::?= modifier applies the ?= assignment operator 3 times.
 	# The ?= operator only has an effect for the first time, therefore
 @@ -41,33 +41,45 @@ mod-assign-nested:
 	@echo $@: ${1:?${THEN1::=then1${IT1::=t1}}:${ELSE1::=else1${IE1::=e1}}}${THEN1}${ELSE1}${IT1}${IE1}
 	# The condition "0" is false, therefore ELSE1 gets assigned a value,
 	# and IE1 as well.  Nothing surprising here as well.
 	@echo $@: ${0:?${THEN2::=then2${IT2::=t2}}:${ELSE2::=else2${IE2::=e2}}}${THEN2}${ELSE2}${IT2}${IE2}
 	# The same effects happen when the variables are defined elsewhere.
 	@echo $@: ${SINK3:Q}
 	@echo $@: ${SINK4:Q}
 SINK3:=	${1:?${THEN3::=then3${IT3::=t3}}:${ELSE3::=else3${IE3::=e3}}}${THEN3}${ELSE3}${IT3}${IE3}
 SINK4:=	${0:?${THEN4::=then4${IT4::=t4}}:${ELSE4::=else4${IE4::=e4}}}${THEN4}${ELSE4}${IT4}${IE4}
 mod-assign-empty:
-	# Assigning to the empty variable would obviously not work since that variable
+	# Assigning to the empty variable would obviously not work since that
-	# is write-protected.  Therefore it is rejected early as a "bad modifier".
+	# variable is write-protected.  Therefore it is rejected early with a
-	@echo ${::=value}
+	# "Bad modifier" message.
+	#
 	# XXX: The error message is hard to read since the variable name is
 	# empty.  This leads to a trailing space in the error message.
 	@echo $@: ${::=value}
 	# In this variant, it is not as obvious that the name of the
 	# expression is empty.  Assigning to it is rejected as well, with the
 	# same "Bad modifier" message.
+	#
 	# XXX: The error message is hard to read since the variable name is
 	# empty.  This leads to a trailing space in the error message.
 	@echo $@: ${:Uvalue::=overwritten}
-	# The :L modifier sets the variable's value to its name.
+	# The :L modifier sets the value of the expression to its variable
-	# Since the name is still "VAR", assigning to that variable works.
+	# name.  The name of the expression is "VAR", therefore assigning to
 	# that variable works.
 	@echo $@: ${VAR:L::=overwritten} VAR=${VAR}
 mod-assign-parse:
 	# The modifier for assignment operators starts with a ':'.
 	# An 'x' after that is an invalid modifier.
 	@echo ${ASSIGN::x}	# 'x' is an unknown assignment operator
 	# When parsing an assignment operator fails because the operator is
 	# incomplete, make falls back to the SysV modifier.
 	@echo ${SYSV::=sysv\:x}${SYSV::x=:y}
 	@echo ${ASSIGN::=value	# missing closing brace