1# $NetBSD: varmod-assign.mk,v 1.25 2024/08/29 20:20:36 rillig Exp $ 2# 3# Tests for the obscure ::= variable modifiers, which perform variable 4# assignments during evaluation, just like the = operator in C. 5 6.if !make(target) 7 8all: mod-assign-empty-{1,2,3} 9all: mod-assign-parse-{1,2,3} 10all: mod-assign-shell-error 11 12# In the following loop expression, 13# the '::?=' modifier applies the assignment operator '?=' 3 times. The 14# operator '?=' only has an effect for the first time, therefore the variable 15# FIRST ends up with the value 1. 16.if "${1 2 3:L:@i@${FIRST::?=$i}@} first=${FIRST}" != " first=1" 17. error 18.endif 19 20# In the following loop expression, 21# the modifier '::=' applies the assignment operator '=' 3 times. The 22# operator '=' overwrites the previous value, therefore the variable LAST ends 23# up with the value 3. 24.if "${1 2 3:L:@i@${LAST::=$i}@} last=${LAST}" != " last=3" 25. error 26.endif 27 28# In the following loop expression, 29# the modifier '::+=' applies the assignment operator '+=' 3 times. The 30# operator '+=' appends 3 times to the variable, therefore the variable 31# APPENDED ends up with the value "1 2 3". 32.if "${1 2 3:L:@i@${APPENDED::+=$i}@} appended=${APPENDED}" != " appended=1 2 3" 33. error 34.endif 35 36# In the following loop expression, 37# the modifier '::!=' applies the assignment operator '!=' 3 times. Just as 38# with the modifier '::=', the last value is stored in the RAN variable. 39.if "${1 2 3:L:@i@${RAN::!=${i:%=echo '<%>';}}@} ran=${RAN}" != " ran=<3>" 40. error 41.endif 42 43# When a '::=' modifier is evaluated as part of an .if condition, it happens 44# in the command line scope. 45.if "${FIRST}, ${LAST}, ${APPENDED}, ${RAN}" != "1, 3, 1 2 3, <3>" 46. error 47.endif 48 49# Tests for nested assignments, which are hard to read and therefore seldom 50# used in practice. 51 52# The condition "1" is true, therefore THEN1 gets assigned a value, 53# and the inner IT1 as well. Nothing surprising here. 54.if "${1:?${THEN1::=then1${IT1::=t1}}:${ELSE1::=else1${IE1::=e1}}} ${THEN1}${ELSE1}${IT1}${IE1}" != " then1t1" 55. error 56.endif 57 58# The condition "0" is false, therefore ELSE2 gets assigned a value, 59# and the inner IE2 as well. Nothing surprising here as well. 60.if "${0:?${THEN2::=then2${IT2::=t2}}:${ELSE2::=else2${IE2::=e2}}} ${THEN2}${ELSE2}${IT2}${IE2}" != " else2e2" 61. error 62.endif 63 64# The same effects happen when the variables are defined elsewhere. 65SINK3:= ${1:?${THEN3::=then3${IT3::=t3}}:${ELSE3::=else3${IE3::=e3}}} ${THEN3}${ELSE3}${IT3}${IE3} 66SINK4:= ${0:?${THEN4::=then4${IT4::=t4}}:${ELSE4::=else4${IE4::=e4}}} ${THEN4}${ELSE4}${IT4}${IE4} 67.if ${SINK3} != " then3t3" 68. error 69.endif 70.if ${SINK4} != " else4e4" 71. error 72.endif 73 74mod-assign-empty-1: 75 # Assigning to the empty variable would obviously not work since that 76 # variable is write-protected. 77# expect: make: Bad modifier ":" 78 @echo $@: ${::=value} 79 80mod-assign-empty-2: 81 # In this variant, it is not as obvious that the name of the 82 # expression is empty. 83# expect: make: Bad modifier ":" 84 @echo $@: ${:Uvalue::=overwritten} 85 86mod-assign-empty-3: 87 # The :L modifier sets the value of the expression to its variable 88 # name. The name of the expression is "VAR", therefore assigning to 89 # that variable works. 90# expect: mod-assign-empty-3: VAR=overwritten 91 @echo $@: ${VAR:L::=overwritten} VAR=${VAR} 92 93mod-assign-parse-1: 94 # The modifier for assignment operators starts with a ':'. 95 # An 'x' after that is an invalid modifier. 96# expect: make: Unknown modifier ":x" 97 @echo ${ASSIGN::x} 98 99mod-assign-parse-2: 100 # When parsing an assignment operator fails because the operator is 101 # incomplete, make falls back to the SysV modifier. 102 @echo ${SYSV::=sysv\:x}${SYSV::x=:y} 103 104mod-assign-parse-3: 105# expect: make: Unfinished modifier ('}' missing) 106 @echo ${ASSIGN::=value # missing closing brace 107 108mod-assign-shell-error: 109 # If the command succeeds, the variable is assigned. 110 @${SH_OK::!= echo word; true } echo ok=${SH_OK} 111 112 # If the command fails, the variable keeps its previous value. 113 @${SH_ERR::=previous} 114 @${SH_ERR::!= echo word; (exit 13) } echo err=${SH_ERR} 115 116# XXX: The ::= modifier expands its right-hand side exactly once. 117# This differs subtly from normal assignments such as '+=' or '=', which copy 118# their right-hand side literally. 119APPEND.prev= previous 120APPEND.var= ${APPEND.prev} 121APPEND.indirect= indirect $${:Unot expanded} 122APPEND.dollar= $${APPEND.indirect} 123.if ${APPEND.var::+=${APPEND.dollar}} != "" 124. error 125.endif 126.if ${APPEND.var} != "previous indirect \${:Unot expanded}" 127. error 128.endif 129 130 131# The assignment modifier can be used in an expression that is 132# enclosed in parentheses. In such a case, parsing stops at the first ')', 133# not at the first '}'. 134VAR= previous 135_:= $(VAR::=current}) 136.if ${VAR} != "current}" 137. error 138.endif 139 140 141# Before var.c 1.888 from 2021-03-15, an expression using the modifier '::=' 142# expanded its variable name once too often during evaluation. This was only 143# relevant for variable names containing a '$' sign in their actual name, not 144# the usual VAR.${param}. 145.MAKEFLAGS: -dv 146param= twice 147VARNAME= VAR.$${param} # Indirect variable name because of the '$', 148 # to avoid difficult escaping rules. 149 150${VARNAME}= initial-value # Sets 'VAR.${param}' to 'expanded'. 151.if defined(VAR.twice) # At this point, the '$$' is not expanded. 152. error 153.endif 154.if ${${VARNAME}::=assigned-value} # Here the variable name gets expanded once 155. error # too often. 156.endif 157.if defined(VAR.twice) 158. error The variable name in the '::=' modifier is expanded once too often. 159.endif 160.if ${${VARNAME}} != "assigned-value" 161. error 162.endif 163.MAKEFLAGS: -d0 164 165 166# Conditional directives are evaluated in command line scope. An assignment 167# modifier that creates a new variable creates it in the command line scope. 168# Existing variables are updated in their previous scope, and environment 169# variables are created in the global scope, as in other situations. 170.MAKEFLAGS: CMD_CMD_VAR=cmd-value 171CMD_GLOBAL_VAR=global-value 172export CMD_ENV_VAR=env-value 173.MAKEFLAGS: -dv 174# expect-reset 175# expect: Command: CMD_CMD_VAR = new-value 176# expect: Global: CMD_GLOBAL_VAR = new-value 177# expect: Global: CMD_ENV_VAR = new-value 178# expect: Global: ignoring delete 'CMD_NEW_VAR' as it is not found 179# expect: Command: CMD_NEW_VAR = new-value 180.if ${CMD_CMD_VAR::=new-value} \ 181 || ${CMD_GLOBAL_VAR::=new-value} \ 182 || ${CMD_ENV_VAR::=new-value} \ 183 || "${CMD_NEW_VAR::=new-value}" 184. error 185.endif 186.MAKEFLAGS: -d0 187 188# Run the 'target' test in a separate sub-make, with reduced debug logging. 189all: run-target 190run-target: .PHONY 191 @${MAKE} -r -f ${MAKEFILE} -dv target 2>&1 | grep ': TARGET_' 192 193.else # make(target) 194 195# The commands of a target are evaluated in target scope. An assignment 196# modifier that creates a new variable creates it in the target scope. 197# Existing variables are updated in their previous scope, and environment 198# variables are created in the global scope, as in other situations. 199# 200# expect: target: TARGET_TARGET_VAR = new-value 201# expect: Global: TARGET_GLOBAL_VAR = new-value 202# expect: Global: TARGET_ENV_VAR = new-value 203# expect: target: TARGET_NEW_VAR = new-value 204.MAKEFLAGS: TARGET_CMD_VAR=cmd-value 205TARGET_GLOBAL_VAR=global-value 206export TARGET_ENV_VAR=env-value 207target: .PHONY TARGET_TARGET_VAR=target-value 208 : ${TARGET_TARGET_VAR::=new-value} 209 : ${TARGET_CMD_VAR::=new-value} 210 : ${TARGET_GLOBAL_VAR::=new-value} 211 : ${TARGET_ENV_VAR::=new-value} 212 : ${TARGET_NEW_VAR::=new-value} 213 214.endif 215