contrib/bmake/unit-tests/cond-func-empty.mk

   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
  12 EMPTY=  # empty
  13 SPACE=  ${:U }
  14 WORD=   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
 149 all:
 150         @:;