Aren/NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

make: remove VarFlags from debug logging

Browse Source 
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.
This commit is contained in:
rillig 2021-04-03 22:02:59 +00:00
parent 567911c217
commit c71fbc370e
12 changed files with 120 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
usr.bin/make/unit-tests/directive-export-impl.exp
View File

@ -5,46 +5,46 @@ Global:.MAKE.EXPORTED = UT_VAR
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:)

8
usr.bin/make/unit-tests/directive-unexport-env.exp
View File

@ -5,10 +5,10 @@ Global:UT_UNEXPORTED = value
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

12
usr.bin/make/unit-tests/var-eval-short.exp
View File

@ -4,20 +4,20 @@ make: "var-eval-short.mk" line 91: Invalid time value: ${FAIL}}
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

4
usr.bin/make/unit-tests/var-op-append.exp
View File

@ -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

64
usr.bin/make/unit-tests/vardebug.exp
View File

@ -6,73 +6,73 @@ Global:VAR = overwritten
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})

4
usr.bin/make/unit-tests/varmod-assign.exp
View File

@ -4,10 +4,10 @@ Var_Parse: ${VARNAME} (eval)
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

8
usr.bin/make/unit-tests/varmod-defined.exp
View File

@ -3,12 +3,12 @@ Global:VAR =
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 @@ Global:var = $$$$$$$$
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

32
usr.bin/make/unit-tests/varmod-indirect.exp
View File

@ -17,40 +17,40 @@ Global:_ = before ${UNDEF} after
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)
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)
Global:_ = before ${UNDEF:S,a,a,} after
ParseReadLine (179): '_:= before ${UNDEF:${:U}} after'
Var_Parse: ${UNDEF:${:U}} after (eval-keep-dollar-and-undefined)
Var_Parse: ${:U}} after (eval-keep-dollar-and-undefined)
Applying ${:U} to "" (eval-keep-dollar-and-undefined, none, undefined)
Result of ${:U} is "" (eval-keep-dollar-and-undefined, none, defined)
Applying ${:U} to "" (eval-keep-dollar-and-undefined, undefined)
Result of ${:U} is "" (eval-keep-dollar-and-undefined, defined)
Indirect modifier "" from "${:U}"
Var_Parse: ${:U}} after (eval-keep-dollar-and-undefined)
Applying ${:U} to "" (eval-keep-dollar-and-undefined, none, undefined)
Result of ${:U} is "" (eval-keep-dollar-and-undefined, none, defined)
Applying ${:U} to "" (eval-keep-dollar-and-undefined, undefined)
Result of ${:U} is "" (eval-keep-dollar-and-undefined, defined)
Global:_ = before ${UNDEF:} after
ParseReadLine (184): '_:= before ${UNDEF:${:UZ}} after'
Var_Parse: ${UNDEF:${:UZ}} after (eval-keep-dollar-and-undefined)
Var_Parse: ${:UZ}} after (eval-keep-dollar-and-undefined)
Applying ${:U...} to "" (eval-keep-dollar-and-undefined, none, undefined)
Result of ${:UZ} is "Z" (eval-keep-dollar-and-undefined, none, defined)
Applying ${:U...} to "" (eval-keep-dollar-and-undefined, undefined)
Result of ${:UZ} is "Z" (eval-keep-dollar-and-undefined, defined)
Indirect modifier "Z" from "${:UZ}"
Applying ${UNDEF:Z} to "" (eval-keep-dollar-and-undefined, none, undefined)
Applying ${UNDEF:Z} to "" (eval-keep-dollar-and-undefined, undefined)
make: "varmod-indirect.mk" line 184: Unknown modifier "Z"
Result of ${UNDEF:Z} is error (eval-keep-dollar-and-undefined, none, undefined)
Result of ${UNDEF:Z} is error (eval-keep-dollar-and-undefined, undefined)
Var_Parse: ${:UZ}} after (eval-keep-dollar-and-undefined)
Applying ${:U...} to "" (eval-keep-dollar-and-undefined, none, undefined)
Result of ${:UZ} is "Z" (eval-keep-dollar-and-undefined, none, defined)
Applying ${:U...} to "" (eval-keep-dollar-and-undefined, undefined)
Result of ${:UZ} is "Z" (eval-keep-dollar-and-undefined, defined)
Global:_ = before ${UNDEF:Z} after
ParseReadLine (186): '.MAKEFLAGS: -d0'
ParseDoDependency(.MAKEFLAGS: -d0)

32
usr.bin/make/unit-tests/varmod-match-escape.exp
View File

@ -1,10 +1,10 @@
Global:SPECIALS = \: : \\ * \*
CondParser_Eval: ${SPECIALS:M${:U}\:} != ${SPECIALS:M\:${:U}}
Var_Parse: ${SPECIALS:M${:U}\:} != ${SPECIALS:M\:${:U}} (eval-defined)
Applying ${SPECIALS:M...} to "\: : \\ * \*" (eval-defined, none, regular)
Applying ${SPECIALS:M...} to "\: : \\ * \*" (eval-defined, regular)
Var_Parse: ${:U}\: (eval-defined)
Applying ${:U} to "" (eval-defined, none, undefined)
Result of ${:U} is "" (eval-defined, none, defined)
Applying ${:U} to "" (eval-defined, undefined)
Result of ${:U} is "" (eval-defined, defined)
Pattern[SPECIALS] for [\: : \\ * \*] is [\:]
ModifyWords: split "\: : \\ * \*" into 5 words
VarMatch [\:] [\:]
@ -12,12 +12,12 @@ VarMatch [:] [\:]
VarMatch [\\] [\:]
VarMatch [*] [\:]
VarMatch [\*] [\:]
Result of ${SPECIALS:M${:U}\:} is ":" (eval-defined, none, regular)
Result of ${SPECIALS:M${:U}\:} is ":" (eval-defined, regular)
Var_Parse: ${SPECIALS:M\:${:U}} (eval-defined)
Applying ${SPECIALS:M...} to "\: : \\ * \*" (eval-defined, none, regular)
Applying ${SPECIALS:M...} to "\: : \\ * \*" (eval-defined, regular)
Var_Parse: ${:U} (eval-defined)
Applying ${:U} to "" (eval-defined, none, undefined)
Result of ${:U} is "" (eval-defined, none, defined)
Applying ${:U} to "" (eval-defined, undefined)
Result of ${:U} is "" (eval-defined, defined)
Pattern[SPECIALS] for [\: : \\ * \*] is [:]
ModifyWords: split "\: : \\ * \*" into 5 words
VarMatch [\:] [:]
@ -25,32 +25,32 @@ VarMatch [:] [:]
VarMatch [\\] [:]
VarMatch [*] [:]
VarMatch [\*] [:]
Result of ${SPECIALS:M\:${:U}} is ":" (eval-defined, none, regular)
Result of ${SPECIALS:M\:${:U}} is ":" (eval-defined, regular)
lhs = ":", rhs = ":", op = !=
Global:VALUES = : :: :\:
CondParser_Eval: ${VALUES:M\:${:U\:}} != ${VALUES:M${:U\:}\:}
Var_Parse: ${VALUES:M\:${:U\:}} != ${VALUES:M${:U\:}\:} (eval-defined)
Applying ${VALUES:M...} to ": :: :\:" (eval-defined, none, regular)
Applying ${VALUES:M...} to ": :: :\:" (eval-defined, regular)
Var_Parse: ${:U:} (eval-defined)
Applying ${:U} to "" (eval-defined, none, undefined)
Result of ${:U} is "" (eval-defined, none, defined)
Applying ${:U} to "" (eval-defined, undefined)
Result of ${:U} is "" (eval-defined, defined)
Pattern[VALUES] for [: :: :\:] is [:]
ModifyWords: split ": :: :\:" into 3 words
VarMatch [:] [:]
VarMatch [::] [:]
VarMatch [:\:] [:]
Result of ${VALUES:M\:${:U\:}} is ":" (eval-defined, none, regular)
Result of ${VALUES:M\:${:U\:}} is ":" (eval-defined, regular)
Var_Parse: ${VALUES:M${:U\:}\:} (eval-defined)
Applying ${VALUES:M...} to ": :: :\:" (eval-defined, none, regular)
Applying ${VALUES:M...} to ": :: :\:" (eval-defined, regular)
Var_Parse: ${:U\:}\: (eval-defined)
Applying ${:U...} to "" (eval-defined, none, undefined)
Result of ${:U\:} is ":" (eval-defined, none, defined)
Applying ${:U...} to "" (eval-defined, undefined)
Result of ${:U\:} is ":" (eval-defined, defined)
Pattern[VALUES] for [: :: :\:] is [:\:]
ModifyWords: split ": :: :\:" into 3 words
VarMatch [:] [:\:]
VarMatch [::] [:\:]
VarMatch [:\:] [:\:]
Result of ${VALUES:M${:U\:}\:} is "::" (eval-defined, none, regular)
Result of ${VALUES:M${:U\:}\:} is "::" (eval-defined, regular)
lhs = ":", rhs = "::", op = !=
make: "varmod-match-escape.mk" line 42: warning: XXX: Oops
Global:.MAKEFLAGS = -r -k -d cv -d

28
usr.bin/make/unit-tests/varname-empty.exp
View File

@ -1,12 +1,12 @@
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}", "cmdline-u", ...) name expands to empty string - ignored
Var_Set("", "cmdline-plain", ...) name expands to empty string - ignored
Global:.CURDIR = <curdir>
Var_Parse: ${MAKE_OBJDIR_CHECK_WRITABLE:U} (eval)
Applying ${MAKE_OBJDIR_CHECK_WRITABLE:U} to "" (eval, none, undefined)
Result of ${MAKE_OBJDIR_CHECK_WRITABLE:U} is "" (eval, none, defined)
Applying ${MAKE_OBJDIR_CHECK_WRITABLE:U} to "" (eval, undefined)
Result of ${MAKE_OBJDIR_CHECK_WRITABLE:U} is "" (eval, defined)
Global:.OBJDIR = <curdir>
Global:delete .PATH (not found)
Global:.PATH = .
@ -24,22 +24,22 @@ Var_Set("", "", ...) name expands to empty string - ignored
Var_Set("", "subst", ...) name expands to empty string - ignored
Var_Set("", "shell-output", ...) name expands to empty string - ignored
Var_Parse: ${:Ufallback} != "fallback" (eval-defined)
Applying ${:U...} to "" (eval-defined, none, undefined)
Result of ${:Ufallback} is "fallback" (eval-defined, none, defined)
Applying ${:U...} to "" (eval-defined, undefined)
Result of ${:Ufallback} is "fallback" (eval-defined, defined)
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}", "assigned indirectly", ...) name expands to empty string - ignored
Var_Parse: ${:Ufallback} != "fallback" (eval-defined)
Applying ${:U...} to "" (eval-defined, none, undefined)
Result of ${:Ufallback} is "fallback" (eval-defined, none, defined)
Applying ${:U...} to "" (eval-defined, undefined)
Result of ${:Ufallback} is "fallback" (eval-defined, defined)
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}", "appended indirectly", ...) name expands to empty string - ignored
Var_Parse: ${:Ufallback} != "fallback" (eval-defined)
Applying ${:U...} to "" (eval-defined, none, undefined)
Result of ${:Ufallback} is "fallback" (eval-defined, none, defined)
Applying ${:U...} to "" (eval-defined, undefined)
Result of ${:Ufallback} is "fallback" (eval-defined, defined)
Global:.MAKEFLAGS = -r -d v -d
Global:.MAKEFLAGS = -r -d v -d 0
out: fallback

8
usr.bin/make/unit-tests/varname.exp
View File

@ -5,14 +5,14 @@ Var_Parse: ${VARNAME} (eval)
Global:VAR((( = 3 open parentheses
Var_Parse: ${VAR(((}}}}" != "3 open parentheses}}}" (eval)
Var_Parse: ${:UVAR(((}= try1 (eval-defined)
Applying ${:U...} to "" (eval-defined, none, undefined)
Result of ${:UVAR(((} is "VAR(((" (eval-defined, none, defined)
Applying ${:U...} to "" (eval-defined, undefined)
Result of ${:UVAR(((} is "VAR(((" (eval-defined, defined)
Global:.ALLTARGETS = VAR(((=)
make: "varname.mk" line 30: No closing parenthesis in archive specification
make: "varname.mk" line 30: Error in archive specification: "VAR"
Var_Parse: ${:UVAR\(\(\(}= try2 (eval-defined)
Applying ${:U...} to "" (eval-defined, none, undefined)
Result of ${:UVAR\(\(\(} is "VAR\(\(\(" (eval-defined, none, defined)
Applying ${:U...} to "" (eval-defined, undefined)
Result of ${:UVAR\(\(\(} is "VAR\(\(\(" (eval-defined, defined)
Global:.ALLTARGETS = VAR(((=) VAR\(\(\(=
make: "varname.mk" line 35: Invalid line type
Var_Parse: ${VARNAME} (eval)

12
usr.bin/make/var.c
View File

@ -1,4 +1,4 @@
/* $NetBSD: var.c,v 1.898 2021/04/03 21:55:27 rillig Exp $ */
/* $NetBSD: var.c,v 1.899 2021/04/03 22:02:59 rillig Exp $ */
/*
* Copyright (c) 1988, 1989, 1990, 1993
@ -140,7 +140,7 @@
#include "metachar.h"
/* "@(#)var.c 8.3 (Berkeley) 3/19/94" */
MAKE_RCSID("$NetBSD: var.c,v 1.898 2021/04/03 21:55:27 rillig Exp $");
MAKE_RCSID("$NetBSD: var.c,v 1.899 2021/04/03 22:02:59 rillig Exp $");
typedef enum VarFlags {
VFL_NONE = 0,
@ -3639,16 +3639,14 @@ static void
LogBeforeApply(const ModChain *ch, const char *mod)
{
const Expr *expr = ch->expr;
char vflags_str[VarFlags_ToStringSize];
bool is_single_char = mod[0] != '\0' && IsDelimiter(mod[1], ch);
/* At this point, only the first character of the modifier can
* be used since the end of the modifier is not yet known. */
debug_printf("Applying ${%s:%c%s} to \"%s\" (%s, %s, %s)\n",
debug_printf("Applying ${%s:%c%s} to \"%s\" (%s, %s)\n",
expr->name, mod[0], is_single_char ? "" : "...",
expr->value.str,
VarEvalFlags_ToString(expr->eflags),
VarFlags_ToString(vflags_str, expr->varFlags),
ExprDefined_Name[expr->defined]);
}
@ -3657,14 +3655,12 @@ LogAfterApply(const ModChain *ch, const char *p, const char *mod)
{
const Expr *expr = ch->expr;
const char *value = expr->value.str;
char vflags_str[VarFlags_ToStringSize];
const char *quot = value == var_Error ? "" : "\"";
debug_printf("Result of ${%s:%.*s} is %s%s%s (%s, %s, %s)\n",
debug_printf("Result of ${%s:%.*s} is %s%s%s (%s, %s)\n",
expr->name, (int)(p - mod), mod,
quot, value == var_Error ? "error" : value, quot,
VarEvalFlags_ToString(expr->eflags),
VarFlags_ToString(vflags_str, expr->varFlags),
ExprDefined_Name[expr->defined]);
}