 @@ -1,28 +1,67 @@
-# $NetBSD: varmod-defined.mk,v 1.3 2020/08/25 21:58:08 rillig Exp $
+# $NetBSD: varmod-defined.mk,v 1.4 2020/09/03 18:52:36 rillig Exp $
+#
 # Tests for the :D variable modifier, which returns the given string
 # if the variable is defined.  It is closely related to the :U modifier.
 DEF=	defined
 .undef UNDEF
 # Since DEF is defined, the value of the expression is "value", not
 # "defined".
+#
 .if ${DEF:Dvalue} != "value"
 .error
 .endif
 # Since UNDEF is not defined, the "value" is ignored.  Instead of leaving the
 # expression undefined, it is set to "", exactly to allow the expression to
 # be used in .if conditions.  In this place, other undefined expressions
 # would generate an error message.
 # XXX: Ideally the error message would be "undefined variable", but as of
 # 2020-08-25 it is "Malformed conditional".
+#
 .if ${UNDEF:Dvalue} != ""
 .error
 .endif
 # The modifier text may contain plain text as well as expressions.
+#
 .if ${DEF:D<${DEF}>} != "<defined>"
 .  error
 .endif
 # Special characters that would be interpreted differently can be escaped.
 # These are '}' (the closing character of the expression), ':', '$' and '\'.
 # Any other backslash sequences are preserved.
+#
 # The escaping rules for string literals in conditions are completely
 # different though. There, any character may be escaped using a backslash.
+#
 .if ${DEF:D \} \: \$ \\ \) \n } != " } : \$ \\ \\) \\n "
 .  error
 .endif
 # Like in several other places in variable expressions, when
 # ApplyModifier_Defined calls Var_Parse, double dollars lead to a parse
 # error that is silently ignored.  This makes all dollar signs disappear,
 # except for the last, which is a well-formed variable expression.
+#
 .if ${DEF:D$$$$$${DEF}} != "defined"
 .  error
 .endif
 # Any other text is written without any further escaping.  In contrast
 # to the :M modifier, parentheses and braces do not need to be nested.
 # Instead, the :D modifier is implemented sanely by parsing nested
 # expressions as such, without trying any shortcuts. See ApplyModifier_Match
 # for an inferior variant.
+#
 .if ${DEF:D!&((((} != "!&(((("
 .  error
 .endif
 # TODO: Add more tests for parsing the plain text part, to cover each branch
 # of ApplyModifier_Defined.
 all:
 	@:;

 @@ -1,14 +1,14 @@
-# $NetBSD: varmod-undefined.mk,v 1.3 2020/08/23 20:49:33 rillig Exp $
+# $NetBSD: varmod-undefined.mk,v 1.4 2020/09/03 18:52:36 rillig Exp $
+#
 # Tests for the :U variable modifier, which returns the given string
 # if the variable is undefined.
+#
 # The pattern ${:Uword} is heavily used when expanding .for loops.
 # This is how an expanded .for loop looks like.
 # .for word in one
 # .  if ${word} != one
 # .    error ${word}
 # .  endif
 # .endfor
 @@ -36,20 +36,30 @@
 # The escaping rules for the :U modifier (left-hand side) and condition
 # string literals (right-hand side) are completely different.
+#
 # In the :U modifier, the backslash only escapes very few characters, all
 # other backslashes are retained.
+#
 # In condition string literals, the backslash always escapes the following
 # character, no matter whether it would be necessary or not.
+#
 # In both contexts, \n is an escaped letter n, not a newline; that's what
 # the .newline variable is for.
+#
 # Whitespace at the edges is preserved, on both sides of the comparison.
+#
 .if ${:U \: \} \$ \\ \a \b \n } != " : } \$ \\ \\a \\b \\n "
 .error
 .endif
 # Even after the :U modifier has been applied, the expression still remembers
 # that it originated from an undefined variable, and the :U modifier can
 # be used to overwrite the value of the expression.
+#
 .if ${UNDEF:Uvalue:S,a,X,} != "vXlue"
 .  error
 .elif ${UNDEF:Uvalue:S,a,X,:Uwas undefined} != "was undefined"
 .  error
 .endif
 all:
 	@:;