1# $NetBSD: cond-func-empty.mk,v 1.8 2020/09/23 08:11:28 rillig Exp $ 2# 3# Tests for the empty() function in .if conditions, which tests a variable 4# expression for emptiness. 5# 6# Note that the argument in the parentheses is indeed a variable name, 7# optionally followed by variable modifiers. This is like the defined() 8# function. 9# 10 11.undef UNDEF 12EMPTY= # empty 13SPACE= ${:U } 14WORD= word 15 16# An undefined variable is empty. 17.if !empty(UNDEF) 18. error 19.endif 20 21# An undefined variable has the empty string as the value, and the :M 22# variable modifier does not change that. 23# 24.if !empty(UNDEF:M*) 25. error 26.endif 27 28# The :S modifier replaces the empty value with an actual word, and 29# after that the expression is no longer empty. Because the variable 30# was undefined in the first place, the expression has the flag VAR_JUNK 31# but not VAR_KEEP, therefore it is still considered undefined. 32# Only very few variable modifiers turn an undefined variable expression 33# into a defined variable expression. The :U and :D modifiers belong to 34# that group, but :S doesn't (see VAR_KEEP). 35# 36# XXX: This is hard to explain to someone who doesn't know these 37# implementation details. 38# 39.if !empty(UNDEF:S,^$,value,W) 40. error 41.endif 42 43# The :U modifier modifies expressions based on undefined variables 44# (VAR_JUNK) by adding the VAR_KEEP flag, which marks the expression 45# as "being interesting enough to be further processed". 46# 47.if empty(UNDEF:S,^$,value,W:Ufallback) 48. error 49.endif 50 51# And now to the surprising part. Applying the following :S modifier to the 52# undefined variable makes it non-empty, but the marker VAR_JUNK is preserved 53# nevertheless. The :U modifier that follows only looks at VAR_JUNK to decide 54# whether the variable is defined or not. This kind of makes sense since the 55# :U modifier tests the _variable_, not the _expression_. 56# 57# But since the variable was undefined to begin with, the fallback value is 58# used in this expression. 59# 60.if ${UNDEF:S,^$,value,W:Ufallback} != "fallback" 61. error 62.endif 63 64# The variable EMPTY is completely empty (0 characters). 65.if !empty(EMPTY) 66. error 67.endif 68 69# The variable SPACE has a single space, which counts as being empty. 70.if !empty(SPACE) 71. error 72.endif 73 74# The variable .newline has a single newline, which counts as being empty. 75.if !empty(.newline) 76. error 77.endif 78 79# The empty variable named "" gets a fallback value of " ", which counts as 80# empty. 81# 82# Contrary to the other functions in conditionals, the trailing space is not 83# stripped off, as can be seen in the -dv debug log. If the space had been 84# stripped, it wouldn't make a difference in this case. 85# 86.if !empty(:U ) 87. error 88.endif 89 90# Now the variable named " " gets a non-empty value, which demonstrates that 91# neither leading nor trailing spaces are trimmed in the argument of the 92# function. If the spaces were trimmed, the variable name would be "" and 93# that variable is indeed undefined. Since ParseEmptyArg calls Var_Parse 94# without VARE_UNDEFERR, the value of the undefined variable is returned as 95# an empty string. 96${:U }= space 97.if empty( ) 98. error 99.endif 100 101# The value of the following expression is " word", which is not empty. 102.if empty(:U word) 103. error 104.endif 105 106# The :L modifier creates a variable expression that has the same value as 107# its name, which both are "VAR" in this case. The value is therefore not 108# empty. 109.if empty(VAR:L) 110. error 111.endif 112 113# The variable WORD has the value "word", which does not count as empty. 114.if empty(WORD) 115. error 116.endif 117 118# The expression ${} for a variable with the empty name always evaluates 119# to an empty string (see Var_Parse, varUndefined). 120.if !empty() 121. error 122.endif 123 124# Ensure that variable expressions that appear as part of the argument are 125# properly parsed. Typical use cases for this are .for loops, which are 126# expanded to exactly these ${:U} expressions. 127# 128# If everything goes well, the argument expands to "WORD", and that variable 129# is defined at the beginning of this file. The surrounding 'W' and 'D' 130# ensure that the parser in ParseEmptyArg has the correct position, both 131# before and after the call to Var_ParsePP. 132.if empty(W${:UOR}D) 133. error 134.endif 135 136# There may be spaces at the outside of the parentheses. 137# Spaces inside the parentheses are interpreted as part of the variable name. 138.if ! empty ( WORD ) 139. error 140.endif 141 142${:U WORD }= variable name with spaces 143 144# Now there is a variable named " WORD ", and it is not empty. 145.if empty ( WORD ) 146. error 147.endif 148 149all: 150 @:; 151