diff options
Diffstat (limited to 'contrib/bmake/unit-tests/directive-for.mk')
| -rwxr-xr-x | contrib/bmake/unit-tests/directive-for.mk | 245 |
1 files changed, 203 insertions, 42 deletions
diff --git a/contrib/bmake/unit-tests/directive-for.mk b/contrib/bmake/unit-tests/directive-for.mk index 153762509b7a..becc314226dc 100755 --- a/contrib/bmake/unit-tests/directive-for.mk +++ b/contrib/bmake/unit-tests/directive-for.mk @@ -1,4 +1,4 @@ -# $NetBSD: directive-for.mk,v 1.10 2020/12/27 09:58:35 rillig Exp $ +# $NetBSD: directive-for.mk,v 1.24 2023/12/06 22:28:20 rillig Exp $ # # Tests for the .for directive. # @@ -8,11 +8,13 @@ # .for _FILE_ in values # .for .FILE. in values # .for _f_ in values - -# Using the .for loop, lists of values can be produced. -# In simple cases, the :@var@${var}@ variable modifier can be used to -# reach the same effects. # +# See also: +# varmod-loop.mk The ':@var@...@' modifier + +# A typical use case for a .for loop is to populate a variable with a list of +# values depending on other variables. In simple cases, the same effect can +# be achieved using the ':@var@${var}@' modifier. .undef NUMBERS .for num in 1 2 3 NUMBERS+= ${num} @@ -21,8 +23,9 @@ NUMBERS+= ${num} . error .endif + # The .for loop also works for multiple iteration variables. -# This is something that the variable modifier :@ cannot do. +# This is something that the modifier :@ cannot do as easily. .for name value in VARNAME value NAME2 value2 ${name}= ${value} .endfor @@ -30,12 +33,12 @@ ${name}= ${value} . error .endif + # The .for loop splits the items at whitespace, taking quotes into account, -# just like the :M or :S variable modifiers. -# -# Until 2012-06-03, it had split the items exactly at whitespace, without -# taking the quotes into account. This had resulted in 10 words. +# just like the :M or :S modifiers. # +# Until 2012-06-03, the .for loop had split the items exactly at whitespace, +# without taking the quotes into account. This had resulted in 10 words. .undef WORDS .for var in one t\ w\ o "three three" 'four four' `five six` WORDS+= counted @@ -44,16 +47,19 @@ WORDS+= counted . error .endif + # In the body of the .for loop, the iteration variables can be accessed # like normal variables, even though they are not really variables. # -# Instead, the expression ${var} is transformed into ${:U1}, ${:U2} and so -# on, before the loop body is evaluated. +# Instead, before interpreting the body of the .for loop, the body is +# generated by replacing each expression ${var} with ${:U1}, ${:U2} and so +# on. # -# A notable effect of this implementation technique is that the .for +# A noticeable effect of this implementation technique is that the .for # iteration variables and the normal global variables live in separate -# namespaces and do not influence each other. -# +# namespaces and do not influence each other. The "scope" of the .for loop +# variables is restricted to the current makefile, it does not reach over to +# any included makefiles. var= value before var2= value before .for var var2 in 1 2 3 4 @@ -66,9 +72,8 @@ var2= value before .endif # Everything from the paragraph above also applies if the loop body is -# empty, even if there is no actual iteration since the loop items are -# also empty. -# +# empty. In this particular example, the items to be iterated are empty as +# well. var= value before var2= value before .for var var2 in ${:U} @@ -80,13 +85,15 @@ var2= value before . warning After the .for loop, var2 must still have its original value. .endif -# Until 2008-12-21, the values of the iteration variables were simply -# inserted as plain text and then parsed as usual, which made it possible -# to achieve all kinds of strange effects. +# Before for.c 1.39 from 2008-12-21, the values of the iteration variables +# were simply inserted as plain text and then parsed as usual, which made it +# possible to achieve all kinds of strange effects, such as generating '.if' +# directives or inserting '$' characters in random places, thereby changing +# how following '$' are interpreted. # -# Before that date, the .for loop expanded to: +# Before that date, the .for loop below expanded to: # EXPANSION+= value -# Since that date, the .for loop expands to: +# Since that date, the .for loop below expands to: # EXPANSION${:U+}= value # EXPANSION= before @@ -102,13 +109,16 @@ EXPANSION${plus}= value .endif # When the outer .for loop is expanded, it sees the expression ${i} and -# expands it. The inner loop then has nothing more to expand. +# expands it. The inner loop then only sees the expression ${:Uouter} and +# has nothing more to expand. .for i in outer . for i in inner +# expect+1: outer . info ${i} . endfor .endfor + # From https://gnats.netbsd.org/29985. # # Until 2008-12-21, the .for loop was expanded by replacing the variable @@ -121,39 +131,190 @@ EXPANSION${plus}= value # like "a:\ a:\file.txt" that ended in a single backslash. Since then, the # variable values have been replaced with expressions of the form ${:U...}, # which are not interpreted as code anymore. -# -# As of 2020-09-22, a comment in for.c says that it may be possible to -# produce an "unwanted substitution", but there is no demonstration code yet. -# -# The above changes prevent a backslash at the end of a word from being -# interpreted as part of the code. Because of this, the trailingBackslash -# hack in Var_Subst is no longer needed and as of 2020-09-22, has been -# removed. .for path in a:\ a:\file.txt d:\\ d:\\file.txt . info ${path} .endfor +# expect-2: a:\ a:\file.txt +# expect-3: d:\\ +# expect-4: d:\\file.txt + # Ensure that braces and parentheses are properly escaped by the .for loop. # Each line must print the same word 3 times. -# See GetEscapes. +# See ForLoop_SubstBody. .for v in ( [ { ) ] } (()) [[]] {{}} )( ][ }{ . info $v ${v} $(v) .endfor +# expect-02: ( ( ( +# expect-03: [ [ [ +# expect-04: { { { +# expect-05: ) ) ) +# expect-06: ] ] ] +# expect-07: } } } +# expect-08: (()) (()) (()) +# expect-09: [[]] [[]] [[]] +# expect-10: {{}} {{}} {{}} +# expect-11: )( )( )( +# expect-12: ][ ][ ][ +# expect-13: }{ }{ }{ -# As of 2020-10-25, the variable names may contain arbitrary characters, -# except for whitespace. This allows for creative side effects. Hopefully -# nobody is misusing this "feature". +# Before 2023-05-09, the variable names could contain arbitrary characters, +# except for whitespace, allowing for creative side effects, as usual for +# arbitrary code injection. var= outer +# expect+1: invalid character ':' in .for loop variable name .for var:Q in value "quoted" -. info ${var} ${var:Q} ${var:Q:Q} +. info <${var}> <${var:Q}> <${var:Q:Q}> +.endfor + +# Before 2023-05-09, when variable names could contain '$', the short +# expression '$$' was preserved, the long expressions were substituted. +# expect+1: invalid character '$' in .for loop variable name +.for $ in value +. info <$$> <${$}> <$($)> +.endfor + + +# https://gnats.netbsd.org/53146 mentions the idea of using a dynamic +# variable name in .for loops, based on some other variable. The .for loops +# are already tricky enough to understand in detail, even without this +# possibility, therefore the variable names are restricted to using harmless +# characters only. +INDIRECT= direct +# expect+1: invalid character '$' in .for loop variable name +.for $(INDIRECT) in value +# If the variable name could be chosen dynamically, the iteration variable +# might have been 'direct', thereby expanding the expression '${direct}'. +. info <$(INDIRECT)> <$(direct)> <$($(INDIRECT))> +.endfor + + +# Regular global variables and the "variables" from the .for loop don't +# interfere with each other. In the following snippet, the variable 'DIRECT' +# is used both as a global variable, as well as an iteration variable in the +# .for loop. The expression '${INDIRECT}' refers to the global variable, not +# to the one from the .for loop. +DIRECT= global +INDIRECT= ${DIRECT} +.for DIRECT in iteration +. if "${DIRECT} ${INDIRECT}" != "iteration global" +. error +. endif .endfor # XXX: A parse error or evaluation error in the items of the .for loop -# should skip the whole loop. As of 2020-12-27, the loop is expanded twice. -.for var in word1 ${:Uword2:Z} word3 -. info XXX: Not reached ${var} +# should skip the whole loop. As of 2023-05-09, the loop is expanded as +# usual. +# expect+1: Unknown modifier "Z" +.for var in word1 before-${:Uword2:Z}-after word3 +. info XXX: Should not reach ${var} +.endfor +# expect-2: XXX: Should not reach word1 +# expect-3: XXX: Should not reach before--after +# expect-4: XXX: Should not reach word3 + + +# An empty list of variables to the left of the 'in' is a parse error. +.for in value # expect+0: no iteration variables in for +. error +.endfor + +# An empty list of iteration values to the right of the 'in' is accepted. +# Unlike in the shell, it is not a parse error. +.for var in +. error +.endfor + +# If the iteration values become empty after expanding the expressions, the +# body of the loop is not evaluated. It is not a parse error. +.for var in ${:U} +. error +.endfor + + +# The loop body can be empty. +.for var in 1 2 3 +.endfor + + +# A mismatched .if inside a .for loop is detected each time when the loop body +# is processed. +.for var in value +. if 0 +.endfor # expect+0: 1 open conditional + +# If there are no iteration values, the loop body is not processed, and the +# check for mismatched conditionals is not performed. +.for var in ${:U} +. if 0 +.endfor + + +# When a .for without the corresponding .endfor occurs in an inactive branch +# of an .if, the .for directive is just skipped, it does not even need a +# corresponding .endfor. In other words, the behavior of the parser depends +# on the actual values of the conditions in the .if clauses. +.if 0 +. for var in value # does not need a corresponding .endfor +.endif +.endfor # expect+0: for-less endfor +.endif # expect+0: if-less endif + + +# When a .for without the corresponding .endfor occurs in an active branch of +# an .if, the parser just counts the number of .for and .endfor directives, +# without looking at any other directives. +.if 1 +. for var in value +. endif # expect+0: if-less endif +. endfor # no 'for-less endfor' +.endif # no 'if-less endif' + + +# Before for.c 1.172 from 2023-05-08, when make parsed a .for loop, it +# assumed that there was no line continuation between the '.' and the 'for' +# or 'endfor', as there is no practical reason to break the line at this +# point. +# +# When make scanned the outer .for loop, it did not recognize the inner .for +# loop as such and instead treated it as an unknown directive. The body of +# the outer .for loop thus ended above the '.endfor'. +# +# When make scanned the inner .for loop, it did not recognize the inner +# .endfor as such, which led to a parse error 'Unexpected end of file in .for +# loop' from the '.endfor' line, followed by a second parse error 'for-less +# .endfor' from the '.\\n endfor' line. +.MAKEFLAGS: -df +.for outer in o +.\ + for inner in i +.\ + endfor +.endfor +.MAKEFLAGS: -d0 + + +# When there is a variable definition 'scope=cmdline' from the command line +# (which has higher precedence than global variables) and a .for loop iterates +# over a variable of the same name, the expression '${scope}' expands to the +# value from the .for loop. This is because when the body of the .for loop is +# expanded, the expression '${scope}' is textually replaced with ${:Uloop}', +# without resolving any other variable names (ForLoop_SubstBody). Later, when +# the body of the .for loop is actually interpreted, the body text doesn't +# contain the word 'scope' anymore. +.MAKEFLAGS: scope=cmdline +.for scope in loop +. if ${scope} != "loop" +. error +. endif .endfor -all: - @:; + +# Since at least 1993, iteration stops at the first newline. +# Back then, the .newline variable didn't exist, therefore it was unlikely +# that a newline ever occurred. +.for var in a${.newline}b${.newline}c +. info newline-item=(${var}) +.endfor +# expect-2: newline-item=(a) |