Source-Changes-HG archive

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index][Old Index]

[src/trunk]: src/usr.bin/make make: remove VarFlags from debug logging



details:   https://anonhg.NetBSD.org/src/rev/6d37a7d28054
branches:  trunk
changeset: 982184:6d37a7d28054
user:      rillig <rillig%NetBSD.org@localhost>
date:      Sat Apr 03 22:02:59 2021 +0000

description:
make: remove VarFlags from debug logging

Before the introduction of ExprDefined, VarFlags contained whether the
expression was defined or not, which was useful to know since the final
value of the expression depends on this information.  The other VarFlags
do not influence the evaluation, so there is no point logging them.

diffstat:

 usr.bin/make/unit-tests/directive-export-impl.exp  |  32 +++++-----
 usr.bin/make/unit-tests/directive-unexport-env.exp |   8 +-
 usr.bin/make/unit-tests/var-eval-short.exp         |  12 ++--
 usr.bin/make/unit-tests/var-op-append.exp          |   4 +-
 usr.bin/make/unit-tests/vardebug.exp               |  64 +++++++++++-----------
 usr.bin/make/unit-tests/varmod-assign.exp          |   4 +-
 usr.bin/make/unit-tests/varmod-defined.exp         |   8 +-
 usr.bin/make/unit-tests/varmod-indirect.exp        |  32 +++++-----
 usr.bin/make/unit-tests/varmod-match-escape.exp    |  32 +++++-----
 usr.bin/make/unit-tests/varname-empty.exp          |  28 ++++----
 usr.bin/make/unit-tests/varname.exp                |   8 +-
 usr.bin/make/var.c                                 |  12 +--
 12 files changed, 120 insertions(+), 124 deletions(-)

diffs (truncated from 542 to 300 lines):

diff -r f737b46cac51 -r 6d37a7d28054 usr.bin/make/unit-tests/directive-export-impl.exp
--- a/usr.bin/make/unit-tests/directive-export-impl.exp Sat Apr 03 21:55:27 2021 +0000
+++ b/usr.bin/make/unit-tests/directive-export-impl.exp Sat Apr 03 22:02:59 2021 +0000
@@ -5,46 +5,46 @@
 ParseReadLine (32): ': ${UT_VAR:N*}'
 Var_Parse: ${UT_VAR:N*} (eval-defined)
 Var_Parse: ${REF}> (eval-defined)
-Applying ${UT_VAR:N...} to "<>" (eval-defined, VFL_EXPORTED|VFL_REEXPORT, regular)
+Applying ${UT_VAR:N...} to "<>" (eval-defined, regular)
 Pattern[UT_VAR] for [<>] is [*]
 ModifyWords: split "<>" into 1 words
-Result of ${UT_VAR:N*} is "" (eval-defined, VFL_EXPORTED|VFL_REEXPORT, regular)
+Result of ${UT_VAR:N*} is "" (eval-defined, regular)
 ParseDoDependency(: )
 CondParser_Eval: ${:!echo "\$UT_VAR"!} != "<>"
 Var_Parse: ${:!echo "\$UT_VAR"!} != "<>" (eval-defined)
-Applying ${:!...} to "" (eval-defined, none, undefined)
+Applying ${:!...} to "" (eval-defined, undefined)
 Modifier part: "echo "$UT_VAR""
 Var_Parse: ${.MAKE.EXPORTED:O:u} (eval)
-Applying ${.MAKE.EXPORTED:O} to "UT_VAR" (eval, none, regular)
-Result of ${.MAKE.EXPORTED:O} is "UT_VAR" (eval, none, regular)
-Applying ${.MAKE.EXPORTED:u} to "UT_VAR" (eval, none, regular)
-Result of ${.MAKE.EXPORTED:u} is "UT_VAR" (eval, none, regular)
+Applying ${.MAKE.EXPORTED:O} to "UT_VAR" (eval, regular)
+Result of ${.MAKE.EXPORTED:O} is "UT_VAR" (eval, regular)
+Applying ${.MAKE.EXPORTED:u} to "UT_VAR" (eval, regular)
+Result of ${.MAKE.EXPORTED:u} is "UT_VAR" (eval, regular)
 Var_Parse: ${UT_VAR} (eval)
 Var_Parse: ${REF}> (eval)
-Result of ${:!echo "\$UT_VAR"!} is "<>" (eval-defined, none, defined)
+Result of ${:!echo "\$UT_VAR"!} is "<>" (eval-defined, defined)
 lhs = "<>", rhs = "<>", op = !=
 ParseReadLine (49): ': ${UT_VAR:N*}'
 Var_Parse: ${UT_VAR:N*} (eval-defined)
 Var_Parse: ${REF}> (eval-defined)
-Applying ${UT_VAR:N...} to "<>" (eval-defined, VFL_EXPORTED|VFL_REEXPORT, regular)
+Applying ${UT_VAR:N...} to "<>" (eval-defined, regular)
 Pattern[UT_VAR] for [<>] is [*]
 ModifyWords: split "<>" into 1 words
-Result of ${UT_VAR:N*} is "" (eval-defined, VFL_EXPORTED|VFL_REEXPORT, regular)
+Result of ${UT_VAR:N*} is "" (eval-defined, regular)
 ParseDoDependency(: )
 ParseReadLine (53): 'REF=              defined'
 Global:REF = defined
 CondParser_Eval: ${:!echo "\$UT_VAR"!} != "<defined>"
 Var_Parse: ${:!echo "\$UT_VAR"!} != "<defined>" (eval-defined)
-Applying ${:!...} to "" (eval-defined, none, undefined)
+Applying ${:!...} to "" (eval-defined, undefined)
 Modifier part: "echo "$UT_VAR""
 Var_Parse: ${.MAKE.EXPORTED:O:u} (eval)
-Applying ${.MAKE.EXPORTED:O} to "UT_VAR" (eval, none, regular)
-Result of ${.MAKE.EXPORTED:O} is "UT_VAR" (eval, none, regular)
-Applying ${.MAKE.EXPORTED:u} to "UT_VAR" (eval, none, regular)
-Result of ${.MAKE.EXPORTED:u} is "UT_VAR" (eval, none, regular)
+Applying ${.MAKE.EXPORTED:O} to "UT_VAR" (eval, regular)
+Result of ${.MAKE.EXPORTED:O} is "UT_VAR" (eval, regular)
+Applying ${.MAKE.EXPORTED:u} to "UT_VAR" (eval, regular)
+Result of ${.MAKE.EXPORTED:u} is "UT_VAR" (eval, regular)
 Var_Parse: ${UT_VAR} (eval)
 Var_Parse: ${REF}> (eval)
-Result of ${:!echo "\$UT_VAR"!} is "<defined>" (eval-defined, none, defined)
+Result of ${:!echo "\$UT_VAR"!} is "<defined>" (eval-defined, defined)
 lhs = "<defined>", rhs = "<defined>", op = !=
 ParseReadLine (61): 'all:'
 ParseDoDependency(all:)
diff -r f737b46cac51 -r 6d37a7d28054 usr.bin/make/unit-tests/directive-unexport-env.exp
--- a/usr.bin/make/unit-tests/directive-unexport-env.exp        Sat Apr 03 21:55:27 2021 +0000
+++ b/usr.bin/make/unit-tests/directive-unexport-env.exp        Sat Apr 03 22:02:59 2021 +0000
@@ -5,10 +5,10 @@
 Global:.MAKE.EXPORTED = UT_EXPORTED
 make: "directive-unexport-env.mk" line 21: The directive .unexport-env does not take arguments
 Var_Parse: ${.MAKE.EXPORTED:O:u} (eval)
-Applying ${.MAKE.EXPORTED:O} to "UT_EXPORTED" (eval, none, regular)
-Result of ${.MAKE.EXPORTED:O} is "UT_EXPORTED" (eval, none, regular)
-Applying ${.MAKE.EXPORTED:u} to "UT_EXPORTED" (eval, none, regular)
-Result of ${.MAKE.EXPORTED:u} is "UT_EXPORTED" (eval, none, regular)
+Applying ${.MAKE.EXPORTED:O} to "UT_EXPORTED" (eval, regular)
+Result of ${.MAKE.EXPORTED:O} is "UT_EXPORTED" (eval, regular)
+Applying ${.MAKE.EXPORTED:u} to "UT_EXPORTED" (eval, regular)
+Result of ${.MAKE.EXPORTED:u} is "UT_EXPORTED" (eval, regular)
 Unexporting "UT_EXPORTED"
 Global:delete .MAKE.EXPORTED
 Global:.MAKEFLAGS =  -r -k -d v -d
diff -r f737b46cac51 -r 6d37a7d28054 usr.bin/make/unit-tests/var-eval-short.exp
--- a/usr.bin/make/unit-tests/var-eval-short.exp        Sat Apr 03 21:55:27 2021 +0000
+++ b/usr.bin/make/unit-tests/var-eval-short.exp        Sat Apr 03 22:02:59 2021 +0000
@@ -4,20 +4,20 @@
 make: "var-eval-short.mk" line 91: Malformed conditional (0 && ${:Uword:localtime=${FAIL}})
 CondParser_Eval: 0 && ${0:?${FAIL}then:${FAIL}else}
 Var_Parse: ${0:?${FAIL}then:${FAIL}else} (parse-only)
-Applying ${0:?...} to "" (parse-only, none, undefined)
+Applying ${0:?...} to "" (parse-only, undefined)
 Modifier part: "${FAIL}then"
 Modifier part: "${FAIL}else"
-Result of ${0:?${FAIL}then:${FAIL}else} is "" (parse-only, none, defined)
+Result of ${0:?${FAIL}then:${FAIL}else} is "" (parse-only, defined)
 ParseReadLine (156): 'DEFINED= defined'
 Global:DEFINED = defined
 CondParser_Eval: 0 && ${DEFINED:L:?${FAIL}then:${FAIL}else}
 Var_Parse: ${DEFINED:L:?${FAIL}then:${FAIL}else} (parse-only)
-Applying ${DEFINED:L} to "defined" (parse-only, none, regular)
-Result of ${DEFINED:L} is "defined" (parse-only, none, regular)
-Applying ${DEFINED:?...} to "defined" (parse-only, none, regular)
+Applying ${DEFINED:L} to "defined" (parse-only, regular)
+Result of ${DEFINED:L} is "defined" (parse-only, regular)
+Applying ${DEFINED:?...} to "defined" (parse-only, regular)
 Modifier part: "${FAIL}then"
 Modifier part: "${FAIL}else"
-Result of ${DEFINED:?${FAIL}then:${FAIL}else} is "defined" (parse-only, none, regular)
+Result of ${DEFINED:?${FAIL}then:${FAIL}else} is "defined" (parse-only, regular)
 ParseReadLine (159): '.MAKEFLAGS: -d0'
 ParseDoDependency(.MAKEFLAGS: -d0)
 Global:.MAKEFLAGS =  -r -k -d cpv -d
diff -r f737b46cac51 -r 6d37a7d28054 usr.bin/make/unit-tests/var-op-append.exp
--- a/usr.bin/make/unit-tests/var-op-append.exp Sat Apr 03 21:55:27 2021 +0000
+++ b/usr.bin/make/unit-tests/var-op-append.exp Sat Apr 03 22:02:59 2021 +0000
@@ -1,6 +1,6 @@
 Var_Parse: ${:U\$\$\$\$\$\$\$\$} (eval)
-Applying ${:U...} to "" (eval, none, undefined)
-Result of ${:U\$\$\$\$\$\$\$\$} is "$$$$$$$$" (eval, none, defined)
+Applying ${:U...} to "" (eval, undefined)
+Result of ${:U\$\$\$\$\$\$\$\$} is "$$$$$$$$" (eval, defined)
 Global:VAR.$$$$$$$$ = dollars
 Global:.MAKEFLAGS =  -r -k -d v -d
 Global:.MAKEFLAGS =  -r -k -d v -d 0
diff -r f737b46cac51 -r 6d37a7d28054 usr.bin/make/unit-tests/vardebug.exp
--- a/usr.bin/make/unit-tests/vardebug.exp      Sat Apr 03 21:55:27 2021 +0000
+++ b/usr.bin/make/unit-tests/vardebug.exp      Sat Apr 03 22:02:59 2021 +0000
@@ -6,73 +6,73 @@
 Global:delete VAR
 Global:delete VAR (not found)
 Var_Parse: ${:U} (eval)
-Applying ${:U} to "" (eval, none, undefined)
-Result of ${:U} is "" (eval, none, defined)
+Applying ${:U} to "" (eval, undefined)
+Result of ${:U} is "" (eval, defined)
 Var_Set("${:U}", "empty name", ...) name expands to empty string - ignored
 Var_Parse: ${:U} (eval)
-Applying ${:U} to "" (eval, none, undefined)
-Result of ${:U} is "" (eval, none, defined)
+Applying ${:U} to "" (eval, undefined)
+Result of ${:U} is "" (eval, defined)
 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]} (eval-defined)
-Applying ${VAR:M...} to "1 2 3" (eval-defined, none, regular)
+Applying ${VAR:M...} to "1 2 3" (eval-defined, regular)
 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" (eval-defined, none, regular)
+Result of ${VAR:M[2]} is "2" (eval-defined, regular)
 Var_Parse: ${VAR:N[2]} (eval-defined)
-Applying ${VAR:N...} to "1 2 3" (eval-defined, none, regular)
+Applying ${VAR:N...} to "1 2 3" (eval-defined, regular)
 Pattern[VAR] for [1 2 3] is [[2]]
 ModifyWords: split "1 2 3" into 3 words
-Result of ${VAR:N[2]} is "1 3" (eval-defined, none, regular)
+Result of ${VAR:N[2]} is "1 3" (eval-defined, regular)
 Var_Parse: ${VAR:S,2,two,} (eval-defined)
-Applying ${VAR:S...} to "1 2 3" (eval-defined, none, regular)
+Applying ${VAR:S...} to "1 2 3" (eval-defined, regular)
 Modifier part: "2"
 Modifier part: "two"
 ModifyWords: split "1 2 3" into 3 words
-Result of ${VAR:S,2,two,} is "1 two 3" (eval-defined, none, regular)
+Result of ${VAR:S,2,two,} is "1 two 3" (eval-defined, regular)
 Var_Parse: ${VAR:Q} (eval-defined)
-Applying ${VAR:Q} to "1 2 3" (eval-defined, none, regular)
-Result of ${VAR:Q} is "1\ 2\ 3" (eval-defined, none, regular)
+Applying ${VAR:Q} to "1 2 3" (eval-defined, regular)
+Result of ${VAR:Q} is "1\ 2\ 3" (eval-defined, regular)
 Var_Parse: ${VAR:tu:tl:Q} (eval-defined)
-Applying ${VAR:t...} to "1 2 3" (eval-defined, none, regular)
-Result of ${VAR:tu} is "1 2 3" (eval-defined, none, regular)
-Applying ${VAR:t...} to "1 2 3" (eval-defined, none, regular)
-Result of ${VAR:tl} is "1 2 3" (eval-defined, none, regular)
-Applying ${VAR:Q} to "1 2 3" (eval-defined, none, regular)
-Result of ${VAR:Q} is "1\ 2\ 3" (eval-defined, none, regular)
+Applying ${VAR:t...} to "1 2 3" (eval-defined, regular)
+Result of ${VAR:tu} is "1 2 3" (eval-defined, regular)
+Applying ${VAR:t...} to "1 2 3" (eval-defined, regular)
+Result of ${VAR:tl} is "1 2 3" (eval-defined, regular)
+Applying ${VAR:Q} to "1 2 3" (eval-defined, regular)
+Result of ${VAR:Q} is "1\ 2\ 3" (eval-defined, regular)
 Var_Parse: ${:Uvalue:${:UM*e}:Mvalu[e]} (eval-defined)
-Applying ${:U...} to "" (eval-defined, none, undefined)
-Result of ${:Uvalue} is "value" (eval-defined, none, defined)
+Applying ${:U...} to "" (eval-defined, undefined)
+Result of ${:Uvalue} is "value" (eval-defined, defined)
 Var_Parse: ${:UM*e}:Mvalu[e]} (eval-defined)
-Applying ${:U...} to "" (eval-defined, none, undefined)
-Result of ${:UM*e} is "M*e" (eval-defined, none, defined)
+Applying ${:U...} to "" (eval-defined, undefined)
+Result of ${:UM*e} is "M*e" (eval-defined, defined)
 Indirect modifier "M*e" from "${:UM*e}"
-Applying ${:M...} to "value" (eval-defined, none, defined)
+Applying ${:M...} to "value" (eval-defined, defined)
 Pattern[] for [value] is [*e]
 ModifyWords: split "value" into 1 words
 VarMatch [value] [*e]
-Result of ${:M*e} is "value" (eval-defined, none, defined)
-Applying ${:M...} to "value" (eval-defined, none, defined)
+Result of ${:M*e} is "value" (eval-defined, defined)
+Applying ${:M...} to "value" (eval-defined, defined)
 Pattern[] for [value] is [valu[e]]
 ModifyWords: split "value" into 1 words
 VarMatch [value] [valu[e]]
-Result of ${:Mvalu[e]} is "value" (eval-defined, none, defined)
+Result of ${:Mvalu[e]} is "value" (eval-defined, defined)
 Var_Parse: ${:UVAR} (eval)
-Applying ${:U...} to "" (eval, none, undefined)
-Result of ${:UVAR} is "VAR" (eval, none, defined)
+Applying ${:U...} to "" (eval, undefined)
+Result of ${:UVAR} is "VAR" (eval, defined)
 Global:delete VAR
 Var_Parse: ${:Uvariable:unknown} (eval-defined)
-Applying ${:U...} to "" (eval-defined, none, undefined)
-Result of ${:Uvariable} is "variable" (eval-defined, none, defined)
-Applying ${:u...} to "variable" (eval-defined, none, defined)
+Applying ${:U...} to "" (eval-defined, undefined)
+Result of ${:Uvariable} is "variable" (eval-defined, defined)
+Applying ${:u...} to "variable" (eval-defined, defined)
 make: "vardebug.mk" line 44: Unknown modifier "unknown"
-Result of ${:unknown} is error (eval-defined, none, defined)
+Result of ${:unknown} is error (eval-defined, defined)
 make: "vardebug.mk" line 44: Malformed conditional (${:Uvariable:unknown})
 Var_Parse: ${UNDEFINED} (eval-defined)
 make: "vardebug.mk" line 53: Malformed conditional (${UNDEFINED})
diff -r f737b46cac51 -r 6d37a7d28054 usr.bin/make/unit-tests/varmod-assign.exp
--- a/usr.bin/make/unit-tests/varmod-assign.exp Sat Apr 03 21:55:27 2021 +0000
+++ b/usr.bin/make/unit-tests/varmod-assign.exp Sat Apr 03 22:02:59 2021 +0000
@@ -4,10 +4,10 @@
 Global:VAR.${param} = initial-value
 Var_Parse: ${${VARNAME}::=assigned-value} (eval-defined)
 Var_Parse: ${VARNAME}::=assigned-value} (eval-defined)
-Applying ${VAR.${param}::...} to "initial-value" (eval-defined, none, regular)
+Applying ${VAR.${param}::...} to "initial-value" (eval-defined, regular)
 Modifier part: "assigned-value"
 Global:VAR.${param} = assigned-value
-Result of ${VAR.${param}::=assigned-value} is "" (eval-defined, none, regular)
+Result of ${VAR.${param}::=assigned-value} is "" (eval-defined, regular)
 Var_Parse: ${${VARNAME}} != "assigned-value" (eval-defined)
 Var_Parse: ${VARNAME}} != "assigned-value" (eval-defined)
 Global:.MAKEFLAGS =  -r -k -d v -d
diff -r f737b46cac51 -r 6d37a7d28054 usr.bin/make/unit-tests/varmod-defined.exp
--- a/usr.bin/make/unit-tests/varmod-defined.exp        Sat Apr 03 21:55:27 2021 +0000
+++ b/usr.bin/make/unit-tests/varmod-defined.exp        Sat Apr 03 22:02:59 2021 +0000
@@ -3,12 +3,12 @@
 Var_Parse: ${8_DOLLARS} (eval-keep-dollar-and-undefined)
 Global:VAR = $$$$$$$$
 Var_Parse: ${VAR:D${8_DOLLARS}} (eval-keep-dollar-and-undefined)
-Applying ${VAR:D...} to "$$$$$$$$" (eval-keep-dollar-and-undefined, none, regular)
+Applying ${VAR:D...} to "$$$$$$$$" (eval-keep-dollar-and-undefined, regular)
 Var_Parse: ${8_DOLLARS}} (eval-keep-dollar-and-undefined)
-Result of ${VAR:D${8_DOLLARS}} is "$$$$$$$$" (eval-keep-dollar-and-undefined, none, regular)
+Result of ${VAR:D${8_DOLLARS}} is "$$$$$$$$" (eval-keep-dollar-and-undefined, regular)
 Global:VAR = $$$$$$$$
 Var_Parse: ${VAR:@var@${8_DOLLARS}@} (eval-keep-dollar-and-undefined)
-Applying ${VAR:@...} to "$$$$$$$$" (eval-keep-dollar-and-undefined, none, regular)
+Applying ${VAR:@...} to "$$$$$$$$" (eval-keep-dollar-and-undefined, regular)
 Modifier part: "var"
 Modifier part: "${8_DOLLARS}"
 ModifyWords: split "$$$$$$$$" into 1 words
@@ -16,7 +16,7 @@
 Var_Parse: ${8_DOLLARS} (eval-keep-undefined)
 ModifyWord_Loop: in "$$$$$$$$", replace "var" with "${8_DOLLARS}" to "$$$$"
 Global:delete var
-Result of ${VAR:@var@${8_DOLLARS}@} is "$$$$" (eval-keep-dollar-and-undefined, none, regular)
+Result of ${VAR:@var@${8_DOLLARS}@} is "$$$$" (eval-keep-dollar-and-undefined, regular)
 Global:VAR = $$$$
 Global:.MAKEFLAGS =  -r -k -d v -d
 Global:.MAKEFLAGS =  -r -k -d v -d 0
diff -r f737b46cac51 -r 6d37a7d28054 usr.bin/make/unit-tests/varmod-indirect.exp
--- a/usr.bin/make/unit-tests/varmod-indirect.exp       Sat Apr 03 21:55:27 2021 +0000
+++ b/usr.bin/make/unit-tests/varmod-indirect.exp       Sat Apr 03 22:02:59 2021 +0000
@@ -17,40 +17,40 @@
 ParseReadLine (169): '_:=      before ${UNDEF:${:US,a,a,}} after'
 Var_Parse: ${UNDEF:${:US,a,a,}} after (eval-keep-dollar-and-undefined)
 Var_Parse: ${:US,a,a,}} after (eval-keep-dollar-and-undefined)
-Applying ${:U...} to "" (eval-keep-dollar-and-undefined, none, undefined)
-Result of ${:US,a,a,} is "S,a,a," (eval-keep-dollar-and-undefined, none, defined)
+Applying ${:U...} to "" (eval-keep-dollar-and-undefined, undefined)
+Result of ${:US,a,a,} is "S,a,a," (eval-keep-dollar-and-undefined, defined)
 Indirect modifier "S,a,a," from "${:US,a,a,}"
-Applying ${UNDEF:S...} to "" (eval-keep-dollar-and-undefined, none, undefined)
+Applying ${UNDEF:S...} to "" (eval-keep-dollar-and-undefined, undefined)
 Modifier part: "a"
 Modifier part: "a"
 ModifyWords: split "" into 1 words
-Result of ${UNDEF:S,a,a,} is "" (eval-keep-dollar-and-undefined, none, undefined)
+Result of ${UNDEF:S,a,a,} is "" (eval-keep-dollar-and-undefined, undefined)
 Var_Parse: ${:US,a,a,}} after (eval-keep-dollar-and-undefined)
-Applying ${:U...} to "" (eval-keep-dollar-and-undefined, none, undefined)



Home | Main Index | Thread Index | Old Index