varmod-loop.mk revision 1.19
1 # $NetBSD: varmod-loop.mk,v 1.19 2022/08/23 17:40:43 rillig Exp $ 2 # 3 # Tests for the :@var (a] ...${var}...@ variable modifier. 4 5 # Force the test results to be independent of the default value of this 6 # setting, which is 'yes' for NetBSD's usr.bin/make but 'no' for the bmake 7 # distribution and pkgsrc/devel/bmake. 8 .MAKE.SAVE_DOLLARS= yes 9 10 all: varname-overwriting-target 11 all: mod-loop-dollar 12 13 varname-overwriting-target: 14 # Even "@" works as a variable name since the variable is installed 15 # in the "current" scope, which in this case is the one from the 16 # target. Because of this, after the loop has finished, '$@' is 17 # undefined. This is something that make doesn't expect, this may 18 # even trigger an assertion failure somewhere. 19 @echo :$@: :${:U1 2 3:@\@@x${@}y@}: :$@: 20 21 22 23 # Demonstrate that it is possible to generate dollar signs using the 24 # :@ modifier. 25 # 26 # These are edge cases that could have resulted in a parse error as well 27 # since the $@ at the end could have been interpreted as a variable, which 28 # would mean a missing closing @ delimiter. 29 mod-loop-dollar: 30 @echo $@:${:U1:@word@${word}$@:Q}: 31 @echo $@:${:U2:@word@$${word}$$@:Q}: 32 @echo $@:${:U3:@word@$$${word}$$$@:Q}: 33 @echo $@:${:U4:@word@$$$${word}$$$$@:Q}: 34 @echo $@:${:U5:@word@$$$$${word}$$$$$@:Q}: 35 @echo $@:${:U6:@word@$$$$$${word}$$$$$$@:Q}: 36 37 # It may happen that there are nested :@ modifiers that use the same name for 38 # for the loop variable. These modifiers influence each other. 39 # 40 # As of 2020-10-18, the :@ modifier is implemented by actually setting a 41 # variable in the scope of the expression and deleting it again after the 42 # loop. This is different from the .for loops, which substitute the variable 43 # expression with ${:Uvalue}, leading to different unwanted side effects. 44 # 45 # To make the behavior more predictable, the :@ modifier should restore the 46 # loop variable to the value it had before the loop. This would result in 47 # the string "1a b c1 2a b c2 3a b c3", making the two loops independent. 48 .if ${:U1 2 3:@i@$i${:Ua b c:@i@$i@}${i:Uu}@} != "1a b cu 2a b cu 3a b cu" 49 . error 50 .endif 51 52 # During the loop, the variable is actually defined and nonempty. 53 # If the loop were implemented in the same way as the .for loop, the variable 54 # would be neither defined nor nonempty since all expressions of the form 55 # ${var} would have been replaced with ${:Uword} before evaluating them. 56 .if defined(var) 57 . error 58 .endif 59 .if ${:Uword:@var@${defined(var):?def:undef} ${empty(var):?empty:nonempty}@} \ 60 != "def nonempty" 61 . error 62 .endif 63 .if defined(var) 64 . error 65 .endif 66 67 # Assignment using the ':=' operator, combined with the :@var@ modifier 68 # 69 8_DOLLARS= $$$$$$$$ 70 # This string literal is written with 8 dollars, and this is saved as the 71 # variable value. But as soon as this value is evaluated, it goes through 72 # Var_Subst, which replaces each '$$' with a single '$'. This could be 73 # prevented by VARE_EVAL_KEEP_DOLLAR, but that flag is usually removed 74 # before expanding subexpressions. See ApplyModifier_Loop and 75 # ParseModifierPart for examples. 76 # 77 .MAKEFLAGS: -dcp 78 USE_8_DOLLARS= ${:U1:@var@${8_DOLLARS}@} ${8_DOLLARS} $$$$$$$$ 79 .if ${USE_8_DOLLARS} != "\$\$\$\$ \$\$\$\$ \$\$\$\$" 80 . error 81 .endif 82 # 83 SUBST_CONTAINING_LOOP:= ${USE_8_DOLLARS} 84 # The ':=' assignment operator evaluates the variable value using the mode 85 # VARE_KEEP_DOLLAR_UNDEF, which means that some dollar signs are preserved, 86 # but not all. The dollar signs in the top-level expression and in the 87 # indirect ${8_DOLLARS} are preserved. 88 # 89 # The variable modifier :@var@ does not preserve the dollar signs though, no 90 # matter in which context it is evaluated. What happens in detail is: 91 # First, the modifier part "${8_DOLLARS}" is parsed without expanding it. 92 # Next, each word of the value is expanded on its own, and at this moment 93 # in ApplyModifier_Loop, the flag keepDollar is not passed down to 94 # ModifyWords, resulting in "$$$$" for the first word of USE_8_DOLLARS. 95 # 96 # The remaining words of USE_8_DOLLARS are not affected by any variable 97 # modifier and are thus expanded with the flag keepDollar in action. 98 # The variable SUBST_CONTAINING_LOOP therefore gets assigned the raw value 99 # "$$$$ $$$$$$$$ $$$$$$$$". 100 # 101 # The variable expression in the condition then expands this raw stored value 102 # once, resulting in "$$ $$$$ $$$$". The effects from VARE_KEEP_DOLLAR no 103 # longer take place since they had only been active during the evaluation of 104 # the variable assignment. 105 .if ${SUBST_CONTAINING_LOOP} != "\$\$ \$\$\$\$ \$\$\$\$" 106 . error 107 .endif 108 .MAKEFLAGS: -d0 109 110 # After looping over the words of the expression, the loop variable gets 111 # undefined. The modifier ':@' uses an ordinary global variable for this, 112 # which is different from the '.for' loop, which replaces ${var} with 113 # ${:Uvalue} in the body of the loop. This choice of implementation detail 114 # can be used for a nasty side effect. The expression ${:U:@VAR@@} evaluates 115 # to an empty string, plus it undefines the variable 'VAR'. This is the only 116 # possibility to undefine a global variable during evaluation. 117 GLOBAL= before-global 118 RESULT:= ${:U${GLOBAL} ${:U:@GLOBAL@@} ${GLOBAL:Uundefined}} 119 .if ${RESULT} != "before-global undefined" 120 . error 121 .endif 122 123 # The above side effect of undefining a variable from a certain scope can be 124 # further combined with the otherwise undocumented implementation detail that 125 # the argument of an '.if' directive is evaluated in cmdline scope. Putting 126 # these together makes it possible to undefine variables from the cmdline 127 # scope, something that is not possible in a straight-forward way. 128 .MAKEFLAGS: CMDLINE=cmdline 129 .if ${:U${CMDLINE}${:U:@CMDLINE@@}} != "cmdline" 130 . error 131 .endif 132 # Now the cmdline variable got undefined. 133 .if ${CMDLINE} != "cmdline" 134 . error 135 .endif 136 # At this point, it still looks as if the cmdline variable were defined, 137 # since the value of CMDLINE is still "cmdline". That impression is only 138 # superficial though, the cmdline variable is actually deleted. To 139 # demonstrate this, it is now possible to override its value using a global 140 # variable, something that was not possible before: 141 CMDLINE= global 142 .if ${CMDLINE} != "global" 143 . error 144 .endif 145 # Now undefine that global variable again, to get back to the original value. 146 .undef CMDLINE 147 .if ${CMDLINE} != "cmdline" 148 . error 149 .endif 150 # What actually happened is that when CMDLINE was set by the '.MAKEFLAGS' 151 # target in the cmdline scope, that same variable was exported to the 152 # environment, see Var_SetWithFlags. 153 .unexport CMDLINE 154 .if ${CMDLINE} != "cmdline" 155 . error 156 .endif 157 # The above '.unexport' has no effect since UnexportVar requires a global 158 # variable of the same name to be defined, otherwise nothing is unexported. 159 CMDLINE= global 160 .unexport CMDLINE 161 .undef CMDLINE 162 .if ${CMDLINE} != "cmdline" 163 . error 164 .endif 165 # This still didn't work since there must not only be a global variable, the 166 # variable must be marked as exported as well, which it wasn't before. 167 CMDLINE= global 168 .export CMDLINE 169 .unexport CMDLINE 170 .undef CMDLINE 171 .if ${CMDLINE:Uundefined} != "undefined" 172 . error 173 .endif 174 # Finally the variable 'CMDLINE' from the cmdline scope is gone, and all its 175 # traces from the environment are gone as well. To do that, a global variable 176 # had to be defined and exported, something that is far from obvious. To 177 # recap, here is the essence of the above story: 178 .MAKEFLAGS: CMDLINE=cmdline # have a cmdline + environment variable 179 .if ${:U:@CMDLINE@@}} # undefine cmdline, keep environment 180 .endif 181 CMDLINE= global # needed for deleting the environment 182 .export CMDLINE # needed for deleting the environment 183 .unexport CMDLINE # delete the environment 184 .undef CMDLINE # delete the global helper variable 185 .if ${CMDLINE:Uundefined} != "undefined" 186 . error # 'CMDLINE' is gone now from all scopes 187 .endif 188 189 190 # In the loop body text of the ':@' modifier, a literal '$' is written as '$$', 191 # not '\$'. In the following example, each '$$' turns into a single '$', 192 # except for '$i', which is replaced with the then-current value '1' of the 193 # iteration variable. 194 # 195 # FIXME: broken since var.c 1.1028 from 2022-08-08. 196 all: varmod-loop-literal-dollar 197 varmod-loop-literal-dollar: .PHONY 198 : ${:U1:@i@ t=$$(( $${t:-0} + $i ))@} 199 200 201 all: .PHONY 202
Indexes created Wed Oct 22 13:09:56 GMT 2025