[src/trunk]: src/usr.bin/make make(1): shorten debug output of ApplyModifiers

[rillig <rillig%NetBSD.org@localhost>]

details:   https://anonhg.NetBSD.org/src/rev/9182f2903d58
branches:  trunk
changeset: 954927:9182f2903d58
user:      rillig <rillig%NetBSD.org@localhost>
date:      Sun Sep 13 16:47:24 2020 +0000

description:
make(1): shorten debug output of ApplyModifiers

Having the words "eflags" and "vflags" in the debug output was too
repetitive.  That they are flags is made obvious by the '|' separator,
and the flags have clearly distinguishable names (VARE_* vs. VAR_*),
which lowers the chance for confusion.

diffstat:

 usr.bin/make/unit-tests/counter.exp           |  60 ++++++++++++------------
 usr.bin/make/unit-tests/vardebug.exp          |  64 +++++++++++++-------------
 usr.bin/make/unit-tests/varname-dot-shell.exp |   4 +-
 usr.bin/make/var.c                            |  10 +--
 4 files changed, 68 insertions(+), 70 deletions(-)

diffs (281 lines):

diff -r c0721ab854b6 -r 9182f2903d58 usr.bin/make/unit-tests/counter.exp
--- a/usr.bin/make/unit-tests/counter.exp       Sun Sep 13 15:27:25 2020 +0000
+++ b/usr.bin/make/unit-tests/counter.exp       Sun Sep 13 16:47:24 2020 +0000
@@ -4,85 +4,85 @@
 Global:A = 
 Var_Parse: ${NEXT} with VARE_WANTRES|VARE_ASSIGN
 Var_Parse: ${COUNTER::=${COUNTER} a}${COUNTER:[#]} with VARE_WANTRES|VARE_ASSIGN
-Applying ${COUNTER::...} to "" (eflags = VARE_WANTRES|VARE_ASSIGN, vflags = none)
+Applying ${COUNTER::...} to "" (VARE_WANTRES|VARE_ASSIGN, none)
 Var_Parse: ${COUNTER} a}${COUNTER:[#]} with VARE_WANTRES
 Modifier part: " a"
 Global:COUNTER =  a
-Result of ${COUNTER::=${COUNTER} a} is "" (eflags = VARE_WANTRES|VARE_ASSIGN, vflags = none)
+Result of ${COUNTER::=${COUNTER} a} is "" (VARE_WANTRES|VARE_ASSIGN, none)
 Var_Parse: ${COUNTER} a}${COUNTER:[#]} with VARE_WANTRES|VARE_ASSIGN
 Var_Parse: ${COUNTER:[#]} with VARE_WANTRES|VARE_ASSIGN
-Applying ${COUNTER:[...} to " a" (eflags = VARE_WANTRES|VARE_ASSIGN, vflags = none)
+Applying ${COUNTER:[...} to " a" (VARE_WANTRES|VARE_ASSIGN, none)
 Modifier part: "#"
-Result of ${COUNTER:[#]} is "1" (eflags = VARE_WANTRES|VARE_ASSIGN, vflags = none)
+Result of ${COUNTER:[#]} is "1" (VARE_WANTRES|VARE_ASSIGN, none)
 Global:A = ${COUNTER::= a a}1
 Global:B = 
 Var_Parse: ${NEXT} with VARE_WANTRES|VARE_ASSIGN
 Var_Parse: ${COUNTER::=${COUNTER} a}${COUNTER:[#]} with VARE_WANTRES|VARE_ASSIGN
-Applying ${COUNTER::...} to " a" (eflags = VARE_WANTRES|VARE_ASSIGN, vflags = none)
+Applying ${COUNTER::...} to " a" (VARE_WANTRES|VARE_ASSIGN, none)
 Var_Parse: ${COUNTER} a}${COUNTER:[#]} with VARE_WANTRES
 Modifier part: " a a"
 Global:COUNTER =  a a
-Result of ${COUNTER::=${COUNTER} a} is "" (eflags = VARE_WANTRES|VARE_ASSIGN, vflags = none)
+Result of ${COUNTER::=${COUNTER} a} is "" (VARE_WANTRES|VARE_ASSIGN, none)
 Var_Parse: ${COUNTER} a}${COUNTER:[#]} with VARE_WANTRES|VARE_ASSIGN
 Var_Parse: ${COUNTER:[#]} with VARE_WANTRES|VARE_ASSIGN
-Applying ${COUNTER:[...} to " a a" (eflags = VARE_WANTRES|VARE_ASSIGN, vflags = none)
+Applying ${COUNTER:[...} to " a a" (VARE_WANTRES|VARE_ASSIGN, none)
 Modifier part: "#"
-Result of ${COUNTER:[#]} is "2" (eflags = VARE_WANTRES|VARE_ASSIGN, vflags = none)
+Result of ${COUNTER:[#]} is "2" (VARE_WANTRES|VARE_ASSIGN, none)
 Global:B = ${COUNTER::= a a a}2
 Global:C = 
 Var_Parse: ${NEXT} with VARE_WANTRES|VARE_ASSIGN
 Var_Parse: ${COUNTER::=${COUNTER} a}${COUNTER:[#]} with VARE_WANTRES|VARE_ASSIGN
-Applying ${COUNTER::...} to " a a" (eflags = VARE_WANTRES|VARE_ASSIGN, vflags = none)
+Applying ${COUNTER::...} to " a a" (VARE_WANTRES|VARE_ASSIGN, none)
 Var_Parse: ${COUNTER} a}${COUNTER:[#]} with VARE_WANTRES
 Modifier part: " a a a"
 Global:COUNTER =  a a a
-Result of ${COUNTER::=${COUNTER} a} is "" (eflags = VARE_WANTRES|VARE_ASSIGN, vflags = none)
+Result of ${COUNTER::=${COUNTER} a} is "" (VARE_WANTRES|VARE_ASSIGN, none)
 Var_Parse: ${COUNTER} a}${COUNTER:[#]} with VARE_WANTRES|VARE_ASSIGN
 Var_Parse: ${COUNTER:[#]} with VARE_WANTRES|VARE_ASSIGN
-Applying ${COUNTER:[...} to " a a a" (eflags = VARE_WANTRES|VARE_ASSIGN, vflags = none)
+Applying ${COUNTER:[...} to " a a a" (VARE_WANTRES|VARE_ASSIGN, none)
 Modifier part: "#"
-Result of ${COUNTER:[#]} is "3" (eflags = VARE_WANTRES|VARE_ASSIGN, vflags = none)
+Result of ${COUNTER:[#]} is "3" (VARE_WANTRES|VARE_ASSIGN, none)
 Global:C = ${COUNTER::= a a a a}3
 Global:RELEVANT = no
 Global:RELEVANT = yes (run-time part)
-Result of ${RELEVANT::=yes (run-time part)} is "" (eflags = VARE_WANTRES, vflags = none)
+Result of ${RELEVANT::=yes (run-time part)} is "" (VARE_WANTRES, none)
 Var_Parse: ${A:Q} B=${B:Q} C=${C:Q} COUNTER=${COUNTER:[#]:Q} with VARE_WANTRES
 Var_Parse: ${COUNTER::= a a}1 with VARE_WANTRES
-Applying ${COUNTER::...} to " a a a" (eflags = VARE_WANTRES, vflags = none)
+Applying ${COUNTER::...} to " a a a" (VARE_WANTRES, none)
 Modifier part: " a a"
 Global:COUNTER =  a a
-Result of ${COUNTER::= a a} is "" (eflags = VARE_WANTRES, vflags = none)
-Applying ${A:Q} to "1" (eflags = VARE_WANTRES, vflags = none)
+Result of ${COUNTER::= a a} is "" (VARE_WANTRES, none)
+Applying ${A:Q} to "1" (VARE_WANTRES, none)
 QuoteMeta: [1]
-Result of ${A:Q} is "1" (eflags = VARE_WANTRES, vflags = none)
+Result of ${A:Q} is "1" (VARE_WANTRES, none)
 Var_Parse: ${B:Q} C=${C:Q} COUNTER=${COUNTER:[#]:Q} with VARE_WANTRES
 Var_Parse: ${COUNTER::= a a a}2 with VARE_WANTRES
-Applying ${COUNTER::...} to " a a" (eflags = VARE_WANTRES, vflags = none)
+Applying ${COUNTER::...} to " a a" (VARE_WANTRES, none)
 Modifier part: " a a a"
 Global:COUNTER =  a a a
-Result of ${COUNTER::= a a a} is "" (eflags = VARE_WANTRES, vflags = none)
-Applying ${B:Q} to "2" (eflags = VARE_WANTRES, vflags = none)
+Result of ${COUNTER::= a a a} is "" (VARE_WANTRES, none)
+Applying ${B:Q} to "2" (VARE_WANTRES, none)
 QuoteMeta: [2]
-Result of ${B:Q} is "2" (eflags = VARE_WANTRES, vflags = none)
+Result of ${B:Q} is "2" (VARE_WANTRES, none)
 Var_Parse: ${C:Q} COUNTER=${COUNTER:[#]:Q} with VARE_WANTRES
 Var_Parse: ${COUNTER::= a a a a}3 with VARE_WANTRES
-Applying ${COUNTER::...} to " a a a" (eflags = VARE_WANTRES, vflags = none)
+Applying ${COUNTER::...} to " a a a" (VARE_WANTRES, none)
 Modifier part: " a a a a"
 Global:COUNTER =  a a a a
-Result of ${COUNTER::= a a a a} is "" (eflags = VARE_WANTRES, vflags = none)
-Applying ${C:Q} to "3" (eflags = VARE_WANTRES, vflags = none)
+Result of ${COUNTER::= a a a a} is "" (VARE_WANTRES, none)
+Applying ${C:Q} to "3" (VARE_WANTRES, none)
 QuoteMeta: [3]
-Result of ${C:Q} is "3" (eflags = VARE_WANTRES, vflags = none)
+Result of ${C:Q} is "3" (VARE_WANTRES, none)
 Var_Parse: ${COUNTER:[#]:Q} with VARE_WANTRES
-Applying ${COUNTER:[...} to " a a a a" (eflags = VARE_WANTRES, vflags = none)
+Applying ${COUNTER:[...} to " a a a a" (VARE_WANTRES, none)
 Modifier part: "#"
-Result of ${COUNTER:[#]} is "4" (eflags = VARE_WANTRES, vflags = none)
-Applying ${COUNTER:Q} to "4" (eflags = VARE_WANTRES, vflags = none)
+Result of ${COUNTER:[#]} is "4" (VARE_WANTRES, none)
+Applying ${COUNTER:Q} to "4" (VARE_WANTRES, none)
 QuoteMeta: [4]
-Result of ${COUNTER:Q} is "4" (eflags = VARE_WANTRES, vflags = none)
+Result of ${COUNTER:Q} is "4" (VARE_WANTRES, none)
 A=1 B=2 C=3 COUNTER=4
 Var_Parse: ${RELEVANT::=no} with VARE_WANTRES
-Applying ${RELEVANT::...} to "yes (run-time part)" (eflags = VARE_WANTRES, vflags = none)
+Applying ${RELEVANT::...} to "yes (run-time part)" (VARE_WANTRES, none)
 Modifier part: "no"
 Global:RELEVANT = no
 exit status 0
diff -r c0721ab854b6 -r 9182f2903d58 usr.bin/make/unit-tests/vardebug.exp
--- a/usr.bin/make/unit-tests/vardebug.exp      Sun Sep 13 15:27:25 2020 +0000
+++ b/usr.bin/make/unit-tests/vardebug.exp      Sun Sep 13 16:47:24 2020 +0000
@@ -4,75 +4,75 @@
 Global:delete VAR
 Global:delete VAR (not found)
 Var_Parse: ${:U} with VARE_WANTRES
-Applying ${:U} to "" (eflags = VARE_WANTRES, vflags = VAR_JUNK)
-Result of ${:U} is "" (eflags = VARE_WANTRES, vflags = VAR_JUNK|VAR_KEEP)
+Applying ${:U} to "" (VARE_WANTRES, VAR_JUNK)
+Result of ${:U} is "" (VARE_WANTRES, VAR_JUNK|VAR_KEEP)
 Var_Set("${:U}", "empty name", ...) name expands to empty string - ignored
 Var_Parse: ${:U} with VARE_WANTRES
-Applying ${:U} to "" (eflags = VARE_WANTRES, vflags = VAR_JUNK)
-Result of ${:U} is "" (eflags = VARE_WANTRES, vflags = VAR_JUNK|VAR_KEEP)
+Applying ${:U} to "" (VARE_WANTRES, VAR_JUNK)
+Result of ${:U} is "" (VARE_WANTRES, VAR_JUNK|VAR_KEEP)
 Var_Append("${:U}", "empty name", ...) name expands to empty string - ignored
 Global:FROM_CMDLINE = overwritten ignored!
 Global:VAR = 1
 Global:VAR = 1 2
 Global:VAR = 1 2 3
 Var_Parse: ${VAR:M[2]} with VARE_UNDEFERR|VARE_WANTRES
-Applying ${VAR:M...} to "1 2 3" (eflags = VARE_UNDEFERR|VARE_WANTRES, vflags = none)
+Applying ${VAR:M...} to "1 2 3" (VARE_UNDEFERR|VARE_WANTRES, none)
 Pattern[VAR] for [1 2 3] is [[2]]
 ModifyWords: split "1 2 3" into 3 words
 VarMatch [1] [[2]]
 VarMatch [2] [[2]]
 VarMatch [3] [[2]]
-Result of ${VAR:M[2]} is "2" (eflags = VARE_UNDEFERR|VARE_WANTRES, vflags = none)
+Result of ${VAR:M[2]} is "2" (VARE_UNDEFERR|VARE_WANTRES, none)
 Var_Parse: ${VAR:N[2]} with VARE_UNDEFERR|VARE_WANTRES
-Applying ${VAR:N...} to "1 2 3" (eflags = VARE_UNDEFERR|VARE_WANTRES, vflags = none)
+Applying ${VAR:N...} to "1 2 3" (VARE_UNDEFERR|VARE_WANTRES, none)
 Pattern[VAR] for [1 2 3] is [[2]]
 ModifyWords: split "1 2 3" into 3 words
-Result of ${VAR:N[2]} is "1 3" (eflags = VARE_UNDEFERR|VARE_WANTRES, vflags = none)
+Result of ${VAR:N[2]} is "1 3" (VARE_UNDEFERR|VARE_WANTRES, none)
 Var_Parse: ${VAR:S,2,two,} with VARE_UNDEFERR|VARE_WANTRES
-Applying ${VAR:S...} to "1 2 3" (eflags = VARE_UNDEFERR|VARE_WANTRES, vflags = none)
+Applying ${VAR:S...} to "1 2 3" (VARE_UNDEFERR|VARE_WANTRES, none)
 Modifier part: "2"
 Modifier part: "two"
 ModifyWords: split "1 2 3" into 3 words
-Result of ${VAR:S,2,two,} is "1 two 3" (eflags = VARE_UNDEFERR|VARE_WANTRES, vflags = none)
+Result of ${VAR:S,2,two,} is "1 two 3" (VARE_UNDEFERR|VARE_WANTRES, none)
 Var_Parse: ${VAR:Q} with VARE_UNDEFERR|VARE_WANTRES
-Applying ${VAR:Q} to "1 2 3" (eflags = VARE_UNDEFERR|VARE_WANTRES, vflags = none)
+Applying ${VAR:Q} to "1 2 3" (VARE_UNDEFERR|VARE_WANTRES, none)
 QuoteMeta: [1\ 2\ 3]
-Result of ${VAR:Q} is "1\ 2\ 3" (eflags = VARE_UNDEFERR|VARE_WANTRES, vflags = none)
+Result of ${VAR:Q} is "1\ 2\ 3" (VARE_UNDEFERR|VARE_WANTRES, none)
 Var_Parse: ${VAR:tu:tl:Q} with VARE_UNDEFERR|VARE_WANTRES
-Applying ${VAR:t...} to "1 2 3" (eflags = VARE_UNDEFERR|VARE_WANTRES, vflags = none)
-Result of ${VAR:tu} is "1 2 3" (eflags = VARE_UNDEFERR|VARE_WANTRES, vflags = none)
-Applying ${VAR:t...} to "1 2 3" (eflags = VARE_UNDEFERR|VARE_WANTRES, vflags = none)
-Result of ${VAR:tl} is "1 2 3" (eflags = VARE_UNDEFERR|VARE_WANTRES, vflags = none)
-Applying ${VAR:Q} to "1 2 3" (eflags = VARE_UNDEFERR|VARE_WANTRES, vflags = none)
+Applying ${VAR:t...} to "1 2 3" (VARE_UNDEFERR|VARE_WANTRES, none)
+Result of ${VAR:tu} is "1 2 3" (VARE_UNDEFERR|VARE_WANTRES, none)
+Applying ${VAR:t...} to "1 2 3" (VARE_UNDEFERR|VARE_WANTRES, none)
+Result of ${VAR:tl} is "1 2 3" (VARE_UNDEFERR|VARE_WANTRES, none)
+Applying ${VAR:Q} to "1 2 3" (VARE_UNDEFERR|VARE_WANTRES, none)
 QuoteMeta: [1\ 2\ 3]
-Result of ${VAR:Q} is "1\ 2\ 3" (eflags = VARE_UNDEFERR|VARE_WANTRES, vflags = none)
+Result of ${VAR:Q} is "1\ 2\ 3" (VARE_UNDEFERR|VARE_WANTRES, none)
 Var_Parse: ${:Uvalue:${:UM*e}:Mvalu[e]} with VARE_UNDEFERR|VARE_WANTRES
-Applying ${:U...} to "" (eflags = VARE_UNDEFERR|VARE_WANTRES, vflags = VAR_JUNK)
-Result of ${:Uvalue} is "value" (eflags = VARE_UNDEFERR|VARE_WANTRES, vflags = VAR_JUNK|VAR_KEEP)
+Applying ${:U...} to "" (VARE_UNDEFERR|VARE_WANTRES, VAR_JUNK)
+Result of ${:Uvalue} is "value" (VARE_UNDEFERR|VARE_WANTRES, VAR_JUNK|VAR_KEEP)
 Var_Parse: ${:UM*e}:Mvalu[e]} with VARE_UNDEFERR|VARE_WANTRES
-Applying ${:U...} to "" (eflags = VARE_UNDEFERR|VARE_WANTRES, vflags = VAR_JUNK)
-Result of ${:UM*e} is "M*e" (eflags = VARE_UNDEFERR|VARE_WANTRES, vflags = VAR_JUNK|VAR_KEEP)
+Applying ${:U...} to "" (VARE_UNDEFERR|VARE_WANTRES, VAR_JUNK)
+Result of ${:UM*e} is "M*e" (VARE_UNDEFERR|VARE_WANTRES, VAR_JUNK|VAR_KEEP)
 Indirect modifier "M*e" from "${:UM*e}"
-Applying ${:M...} to "value" (eflags = VARE_UNDEFERR|VARE_WANTRES, vflags = VAR_JUNK|VAR_KEEP)
+Applying ${:M...} to "value" (VARE_UNDEFERR|VARE_WANTRES, VAR_JUNK|VAR_KEEP)
 Pattern[] for [value] is [*e]
 ModifyWords: split "value" into 1 words
 VarMatch [value] [*e]
-Result of ${:M*e} is "value" (eflags = VARE_UNDEFERR|VARE_WANTRES, vflags = VAR_JUNK|VAR_KEEP)
-Applying ${:M...} to "value" (eflags = VARE_UNDEFERR|VARE_WANTRES, vflags = VAR_JUNK|VAR_KEEP)
+Result of ${:M*e} is "value" (VARE_UNDEFERR|VARE_WANTRES, VAR_JUNK|VAR_KEEP)
+Applying ${:M...} to "value" (VARE_UNDEFERR|VARE_WANTRES, VAR_JUNK|VAR_KEEP)
 Pattern[] for [value] is [valu[e]]
 ModifyWords: split "value" into 1 words
 VarMatch [value] [valu[e]]
-Result of ${:Mvalu[e]} is "value" (eflags = VARE_UNDEFERR|VARE_WANTRES, vflags = VAR_JUNK|VAR_KEEP)
+Result of ${:Mvalu[e]} is "value" (VARE_UNDEFERR|VARE_WANTRES, VAR_JUNK|VAR_KEEP)
 Var_Parse: ${:UVAR} with VARE_WANTRES
-Applying ${:U...} to "" (eflags = VARE_WANTRES, vflags = VAR_JUNK)
-Result of ${:UVAR} is "VAR" (eflags = VARE_WANTRES, vflags = VAR_JUNK|VAR_KEEP)
+Applying ${:U...} to "" (VARE_WANTRES, VAR_JUNK)
+Result of ${:UVAR} is "VAR" (VARE_WANTRES, VAR_JUNK|VAR_KEEP)
 Global:delete VAR
 Var_Parse: ${:Uvariable:unknown} with VARE_UNDEFERR|VARE_WANTRES
-Applying ${:U...} to "" (eflags = VARE_UNDEFERR|VARE_WANTRES, vflags = VAR_JUNK)
-Result of ${:Uvariable} is "variable" (eflags = VARE_UNDEFERR|VARE_WANTRES, vflags = VAR_JUNK|VAR_KEEP)
-Applying ${:u...} to "variable" (eflags = VARE_UNDEFERR|VARE_WANTRES, vflags = VAR_JUNK|VAR_KEEP)
+Applying ${:U...} to "" (VARE_UNDEFERR|VARE_WANTRES, VAR_JUNK)
+Result of ${:Uvariable} is "variable" (VARE_UNDEFERR|VARE_WANTRES, VAR_JUNK|VAR_KEEP)
+Applying ${:u...} to "variable" (VARE_UNDEFERR|VARE_WANTRES, VAR_JUNK|VAR_KEEP)
 make: Unknown modifier 'u'
-Result of ${:unknown} is error (eflags = VARE_UNDEFERR|VARE_WANTRES, vflags = VAR_JUNK|VAR_KEEP)
+Result of ${:unknown} is error (VARE_UNDEFERR|VARE_WANTRES, VAR_JUNK|VAR_KEEP)
 make: "vardebug.mk" line 44: Malformed conditional (${:Uvariable:unknown})
 Var_Parse: ${UNDEFINED} with VARE_UNDEFERR|VARE_WANTRES
 make: "vardebug.mk" line 53: Malformed conditional (${UNDEFINED})
diff -r c0721ab854b6 -r 9182f2903d58 usr.bin/make/unit-tests/varname-dot-shell.exp
--- a/usr.bin/make/unit-tests/varname-dot-shell.exp     Sun Sep 13 15:27:25 2020 +0000
+++ b/usr.bin/make/unit-tests/varname-dot-shell.exp     Sun Sep 13 16:47:24 2020 +0000
@@ -13,7 +13,7 @@
 ParseReadLine (24): 'all:'
 ParseReadLine (25): '  @echo ${.SHELL:M*}'
 Var_Parse: ${.SHELL:M*} with VARE_WANTRES
-Applying ${.SHELL:M...} to "(details omitted)" (eflags = VARE_WANTRES, vflags = VAR_READONLY)
+Applying ${.SHELL:M...} to "(details omitted)" (VARE_WANTRES, VAR_READONLY)
 Pattern[.SHELL] for [(details omitted)] is [*]
-Result of ${.SHELL:M*} is "(details omitted)" (eflags = VARE_WANTRES, vflags = VAR_READONLY)
+Result of ${.SHELL:M*} is "(details omitted)" (VARE_WANTRES, VAR_READONLY)
 exit status 0
diff -r c0721ab854b6 -r 9182f2903d58 usr.bin/make/var.c
--- a/usr.bin/make/var.c        Sun Sep 13 15:27:25 2020 +0000
+++ b/usr.bin/make/var.c        Sun Sep 13 16:47:24 2020 +0000
@@ -1,4 +1,4 @@
-/*     $NetBSD: var.c,v 1.512 2020/09/13 15:15:51 rillig Exp $ */
+/*     $NetBSD: var.c,v 1.513 2020/09/13 16:47:24 rillig Exp $ */
 
 /*
  * Copyright (c) 1988, 1989, 1990, 1993
@@ -121,7 +121,7 @@
 #include    "metachar.h"
 
 /*     "@(#)var.c      8.3 (Berkeley) 3/19/94" */
-MAKE_RCSID("$NetBSD: var.c,v 1.512 2020/09/13 15:15:51 rillig Exp $");
+MAKE_RCSID("$NetBSD: var.c,v 1.513 2020/09/13 16:47:24 rillig Exp $");
 
 #define VAR_DEBUG_IF(cond, fmt, ...)   \
     if (!(DEBUG(VAR) && (cond)))       \
@@ -3062,8 +3062,7 @@
 
            /* At this point, only the first character of the modifier can
             * be used since the end of the modifier is not yet known. */
-           VAR_DEBUG("Applying ${%s:%c%s} to \"%s\" "
-                     "(eflags = %s, vflags = %s)\n",
+           VAR_DEBUG("Applying ${%s:%c%s} to \"%s\" (%s, %s)\n",
                      st.v->name, mod[0], is_single_char ? "" : "...", st.val,
                      Enum_FlagsToString(eflags_str, sizeof eflags_str,
                                         st.eflags, VarEvalFlags_ToStringSpecs),
@@ -3207,8 +3206,7 @@
            const char *quot = st.newVal == var_Error ? "" : "\"";
            const char *newVal = st.newVal == var_Error ? "error" : st.newVal;
 
-           VAR_DEBUG("Result of ${%s:%.*s} is %s%s%s "
-                     "(eflags = %s, vflags = %s)\n",
+           VAR_DEBUG("Result of ${%s:%.*s} is %s%s%s (%s, %s)\n",
                      st.v->name, (int)(p - mod), mod, quot, newVal, quot,
                      Enum_FlagsToString(eflags_str, sizeof eflags_str,
                                         st.eflags, VarEvalFlags_ToStringSpecs),