 @@ -1,14 +1,14 @@
-/*	$NetBSD: cond.c,v 1.330 2022/02/11 21:18:09 rillig Exp $	*/
+/*	$NetBSD: cond.c,v 1.331 2022/03/03 19:36:35 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -85,27 +85,27 @@
  *	Cond_restore_depth
  *			Save and restore the nesting of the conditions, at
  *			the start and end of including another makefile, to
  *			ensure that in each makefile the conditional
  *			directives are well-balanced.
  */
 #include <errno.h>
 #include "make.h"
 #include "dir.h"
 /*	"@(#)cond.c	8.2 (Berkeley) 1/2/94"	*/
-MAKE_RCSID("$NetBSD: cond.c,v 1.330 2022/02/11 21:18:09 rillig Exp $");
+MAKE_RCSID("$NetBSD: cond.c,v 1.331 2022/03/03 19:36:35 rillig Exp $");
 /*
  * Conditional expressions conform to this grammar:
  *	Or -> And ('||' And)*
  *	And -> Term ('&&' Term)*
  *	Term -> Function '(' Argument ')'
  *	Term -> Leaf Operator Leaf
  *	Term -> Leaf
  *	Term -> '(' Or ')'
  *	Term -> '!' Term
  *	Leaf -> "string"
  *	Leaf -> Number
  *	Leaf -> VariableExpression
 @@ -547,27 +547,27 @@ EvalNotEmpty(CondParser *par, const char
 	 * XXX: Whitespace should count as empty, just as in
 	 * CondParser_FuncCallEmpty.
 	 */
 	if (par->plain)
 		return value[0] != '\0';
 	return par->evalBare(value) != par->negateEvalBare;
+}
 /* Evaluate a numerical comparison, such as in ".if ${VAR} >= 9". */
 static bool
 EvalCompareNum(double lhs, ComparisonOp op, double rhs)
+{
-	DEBUG3(COND, "lhs = %f, rhs = %f, op = %.2s\n", lhs, rhs, opname[op]);
+	DEBUG3(COND, "Comparing %f %s %f\n", lhs, opname[op], rhs);
 	switch (op) {
 	case LT:
 		return lhs < rhs;
 	case LE:
 		return lhs <= rhs;
 	case GT:
 		return lhs > rhs;
 	case GE:
 		return lhs >= rhs;
 	case NE:
 		return lhs != rhs;
 	default:
 @@ -576,28 +576,27 @@ EvalCompareNum(double lhs, ComparisonOp
+}
 static Token
 EvalCompareStr(CondParser *par, const char *lhs,
 	       ComparisonOp op, const char *rhs)
+{
 	if (op != EQ && op != NE) {
 		Parse_Error(PARSE_FATAL,
 		    "String comparison operator must be either == or !=");
 		par->printedError = true;
 		return TOK_ERROR;
+	}
-	DEBUG3(COND, "lhs = \"%s\", rhs = \"%s\", op = %.2s\n",
+	DEBUG3(COND, "Comparing \"%s\" %s \"%s\"\n", lhs, opname[op], rhs);
 	    lhs, rhs, opname[op]);
 	return ToToken((op == EQ) == (strcmp(lhs, rhs) == 0));
+}
 /* Evaluate a comparison, such as "${VAR} == 12345". */
 static Token
 EvalCompare(CondParser *par, const char *lhs, bool lhsQuoted,
 	    ComparisonOp op, const char *rhs, bool rhsQuoted)
+{
 	double left, right;
 	if (!rhsQuoted && !lhsQuoted)
 		if (TryParseNumber(lhs, &left) && TryParseNumber(rhs, &right))
 			return ToToken(EvalCompareNum(left, op, right));

 @@ -1,15 +1,15 @@
 CondParser_Eval: !(${:UINF} > 1e100)
 make: "cond-cmp-numeric.mk" line 11: String comparison operator must be either == or !=
 CondParser_Eval: ${:UNaN} > NaN
 make: "cond-cmp-numeric.mk" line 16: String comparison operator must be either == or !=
 CondParser_Eval: !(${:UNaN} == NaN)
-lhs = "NaN", rhs = "NaN", op = ==
+Comparing "NaN" == "NaN"
 CondParser_Eval: 123 ! 123
 make: "cond-cmp-numeric.mk" line 34: Malformed conditional (123 ! 123)
 CondParser_Eval: ${:U 123} < 124
-lhs = 123.000000, rhs = 124.000000, op = <
+Comparing 123.000000 < 124.000000
 CondParser_Eval: ${:U123 } < 124
 make: "cond-cmp-numeric.mk" line 50: String comparison operator must be either == or !=
 make: Fatal errors encountered -- cannot continue
 make: stopped in unit-tests
 exit status 1

 @@ -1,62 +1,62 @@
 CondParser_Eval: ${:Uvalue} != value
-lhs = "value", rhs = "value", op = !=
+Comparing "value" != "value"
 CondParser_Eval: ${:U} != "
-lhs = "", rhs = "", op = !=
+Comparing "" != ""
 CondParser_Eval: ${:U#hash} != "#hash"
-lhs = "#hash", rhs = "#hash", op = !=
+Comparing "#hash" != "#hash"
 CondParser_Eval: ${:U\\} != "\\
-lhs = "\", rhs = "\", op = !=
+Comparing "\" != "\"
 CondParser_Eval: ${:U#hash} != #hash
-lhs = "#hash", rhs = "#hash", op = !=
+Comparing "#hash" != "#hash"
 CondParser_Eval: 0 # This is treated as a comment, but why?
 CondParser_Eval: ${0 # comment :?yes:no} != no
 CondParser_Eval: 0 # comment
-lhs = "no", rhs = "no", op = !=
+Comparing "no" != "no"
 CondParser_Eval: ${1 # comment :?yes:no} != yes
 CondParser_Eval: 1 # comment
-lhs = "yes", rhs = "yes", op = !=
+Comparing "yes" != "yes"
 CondParser_Eval: ${UNDEF:Uundefined}!=undefined
-lhs = "undefined", rhs = "undefined", op = !=
+Comparing "undefined" != "undefined"
 CondParser_Eval: ${UNDEF:U12345}>12345
-lhs = 12345.000000, rhs = 12345.000000, op = >
+Comparing 12345.000000 > 12345.000000
 CondParser_Eval: ${UNDEF:U12345}<12345
-lhs = 12345.000000, rhs = 12345.000000, op = <
+Comparing 12345.000000 < 12345.000000
 CondParser_Eval: (${UNDEF:U0})||0
 CondParser_Eval: ${:Uvar}&&name != "var&&name"
-lhs = "var&&name", rhs = "var&&name", op = !=
+Comparing "var&&name" != "var&&name"
 CondParser_Eval: ${:Uvar}||name != "var||name"
-lhs = "var||name", rhs = "var||name", op = !=
+Comparing "var||name" != "var||name"
 CondParser_Eval: bare
 make: "cond-token-plain.mk" line 105: A bare word is treated like defined(...), and the variable 'bare' is not defined.
 CondParser_Eval: VAR
 make: "cond-token-plain.mk" line 111: A bare word is treated like defined(...).
 CondParser_Eval: V${:UA}R
 make: "cond-token-plain.mk" line 118: ok
 CondParser_Eval: V${UNDEF}AR
 make: "cond-token-plain.mk" line 126: Undefined variables in bare words expand to an empty string.
 CondParser_Eval: 0${:Ux00}
 make: "cond-token-plain.mk" line 134: Numbers can be composed from literals and variable expressions.
 CondParser_Eval: 0${:Ux01}
 make: "cond-token-plain.mk" line 138: Numbers can be composed from literals and variable expressions.
 CondParser_Eval: "" ==
 make: "cond-token-plain.mk" line 144: Missing right-hand side of operator '=='
 CondParser_Eval: == ""
 make: "cond-token-plain.mk" line 152: Malformed conditional (== "")
 CondParser_Eval: \\
 make: "cond-token-plain.mk" line 167: The variable '\\' is not defined.
 CondParser_Eval: \\
 make: "cond-token-plain.mk" line 172: Now the variable '\\' is defined.
 CondParser_Eval: "unquoted\"quoted" != unquoted"quoted
-lhs = "unquoted"quoted", rhs = "unquoted"quoted", op = !=
+Comparing "unquoted"quoted" != "unquoted"quoted"
 CondParser_Eval: $$$$$$$$ != ""
 CondParser_Eval: left == right
 make: "cond-token-plain.mk" line 195: Malformed conditional (left == right)
 CondParser_Eval: ${0:?:} || left == right
 CondParser_Eval: 0
 make: "cond-token-plain.mk" line 201: Malformed conditional (${0:?:} || left == right)
 CondParser_Eval: left == right || ${0:?:}
 make: "cond-token-plain.mk" line 206: Malformed conditional (left == right || ${0:?:})
 make: "cond-token-plain.mk" line 225: Malformed conditional (VAR.${IF_COUNT::+=1} != "")
 make: Fatal errors encountered -- cannot continue
 make: stopped in unit-tests
 exit status 1

 @@ -1,39 +1,39 @@
 Global: SPECIALS = \: : \\ * \*
 CondParser_Eval: ${SPECIALS:M${:U}\:} != ${SPECIALS:M\:${:U}}
 Var_Parse: ${SPECIALS:M${:U}\:} != ${SPECIALS:M\:${:U}} (eval-defined)
 Evaluating modifier ${SPECIALS:M...} on value "\: : \\ * \*"
 Pattern for ':M' is "\:"
 ModifyWords: split "\: : \\ * \*" into 5 words
 Result of ${SPECIALS:M${:U}\:} is ":"
 Var_Parse: ${SPECIALS:M\:${:U}} (eval-defined)
 Evaluating modifier ${SPECIALS:M...} on value "\: : \\ * \*"
 Pattern for ':M' is ":"
 ModifyWords: split "\: : \\ * \*" into 5 words
 Result of ${SPECIALS:M\:${:U}} is ":"
-lhs = ":", rhs = ":", op = !=
+Comparing ":" != ":"
 Global: VALUES = : :: :\:
 CondParser_Eval: ${VALUES:M\:${:U\:}} != ${VALUES:M${:U\:}\:}
 Var_Parse: ${VALUES:M\:${:U\:}} != ${VALUES:M${:U\:}\:} (eval-defined)
 Evaluating modifier ${VALUES:M...} on value ": :: :\:"
 Var_Parse: ${:U:} (eval-defined)
 Evaluating modifier ${:U} on value "" (eval-defined, undefined)
 Result of ${:U} is "" (eval-defined, defined)
 Pattern for ':M' is ":"
 ModifyWords: split ": :: :\:" into 3 words
 Result of ${VALUES:M\:${:U\:}} is ":"
 Var_Parse: ${VALUES:M${:U\:}\:} (eval-defined)
 Evaluating modifier ${VALUES:M...} on value ": :: :\:"
 Var_Parse: ${:U\:}\: (eval-defined)
 Evaluating modifier ${:U...} on value "" (eval-defined, undefined)
 Result of ${:U\:} is ":" (eval-defined, defined)
 Pattern for ':M' is ":\:"
 ModifyWords: split ": :: :\:" into 3 words
 Result of ${VALUES:M${:U\:}\:} is "::"
-lhs = ":", rhs = "::", op = !=
+Comparing ":" != "::"
 make: "varmod-match-escape.mk" line 42: warning: XXX: Oops
 Global: .MAKEFLAGS =  -r -k -d cv -d
 Global: .MAKEFLAGS =  -r -k -d cv -d 0
 make: "varmod-match-escape.mk" line 67: Dollar followed by nothing
 make: Fatal errors encountered -- cannot continue
 make: stopped in unit-tests
 exit status 1

 @@ -1,12 +1,12 @@
 make: "opt-debug-file.mk" line 43: This goes to stderr only, once.
 make: "opt-debug-file.mk" line 45: This goes to stderr only, once.
 make: "opt-debug-file.mk" line 47: This goes to stderr, and in addition to the debug log.
 CondParser_Eval: ${:!cat opt-debug-file.debuglog!:Maddition:[#]} != 1
-lhs = 1.000000, rhs = 1.000000, op = !=
+Comparing 1.000000 != 1.000000
 make: Missing delimiter for modifier ':S'
 make: Missing delimiter for modifier ':S'
 make: Missing delimiter for modifier ':S'
 CondParser_Eval: ${:!cat opt-debug-file.debuglog!:Mdelimiter:[#]} != 1
-lhs = 1.000000, rhs = 1.000000, op = !=
+Comparing 1.000000 != 1.000000
 Cannot open debug file "/nonexistent-6f21c672-a22d-4ef7/opt-debug-file.debuglog"
 exit status 2

 @@ -13,46 +13,46 @@ ParseDependency(: )
 CondParser_Eval: ${:!echo "\$UT_VAR"!} != "<>"
 Var_Parse: ${:!echo "\$UT_VAR"!} != "<>" (eval-defined)
 Evaluating modifier ${:!...} on value "" (eval-defined, undefined)
 Modifier part: "echo "$UT_VAR""
 Capturing the output of command "echo "$UT_VAR""
 Var_Parse: ${.MAKE.EXPORTED:O:u} (eval)
 Evaluating modifier ${.MAKE.EXPORTED:O} on value "UT_VAR"
 Result of ${.MAKE.EXPORTED:O} is "UT_VAR"
 Evaluating modifier ${.MAKE.EXPORTED:u} on value "UT_VAR"
 Result of ${.MAKE.EXPORTED:u} is "UT_VAR"
 Var_Parse: ${UT_VAR} (eval)
 Var_Parse: ${REF}> (eval)
 Result of ${:!echo "\$UT_VAR"!} is "<>" (eval-defined, defined)
-lhs = "<>", rhs = "<>", op = !=
+Comparing "<>" != "<>"
 Parsing line 50: : ${UT_VAR:N*}
 Var_Parse: ${UT_VAR:N*} (eval-defined)
 Var_Parse: ${REF}> (eval-defined)
 Evaluating modifier ${UT_VAR:N...} on value "<>"
 Pattern for ':N' is "*"
 ModifyWords: split "<>" into 1 word
 Result of ${UT_VAR:N*} is ""
 ParseDependency(: )
 Parsing line 54: REF=		defined
 Global: REF = defined
 CondParser_Eval: ${:!echo "\$UT_VAR"!} != "<defined>"
 Var_Parse: ${:!echo "\$UT_VAR"!} != "<defined>" (eval-defined)
 Evaluating modifier ${:!...} on value "" (eval-defined, undefined)
 Modifier part: "echo "$UT_VAR""
 Capturing the output of command "echo "$UT_VAR""
 Var_Parse: ${.MAKE.EXPORTED:O:u} (eval)
 Evaluating modifier ${.MAKE.EXPORTED:O} on value "UT_VAR"
 Result of ${.MAKE.EXPORTED:O} is "UT_VAR"
 Evaluating modifier ${.MAKE.EXPORTED:u} on value "UT_VAR"
 Result of ${.MAKE.EXPORTED:u} is "UT_VAR"
 Var_Parse: ${UT_VAR} (eval)
 Var_Parse: ${REF}> (eval)
 Result of ${:!echo "\$UT_VAR"!} is "<defined>" (eval-defined, defined)
-lhs = "<defined>", rhs = "<defined>", op = !=
+Comparing "<defined>" != "<defined>"
 Parsing line 62: all:
 ParseDependency(all:)
 Global: .ALLTARGETS =  all
 Parsing line 63: .MAKEFLAGS: -d0
 ParseDependency(.MAKEFLAGS: -d0)
 Global: .MAKEFLAGS =  -r -k -d cpv -d
 Global: .MAKEFLAGS =  -r -k -d cpv -d 0
 exit status 0

 @@ -1,13 +1,13 @@
 CondParser_Eval: ${.MAKE.MAKEFILES:T} != "${.PARSEFILE} null"
-lhs = "directive-include.mk null", rhs = "directive-include.mk null", op = !=
+Comparing "directive-include.mk null" != "directive-include.mk null"
 CondParser_Eval: ${.MAKE.MAKEFILES:T} != "${.PARSEFILE} null"
-lhs = "directive-include.mk null", rhs = "directive-include.mk null", op = !=
+Comparing "directive-include.mk null" != "directive-include.mk null"
 make: "directive-include.mk" line 25: Could not find nonexistent.mk
 make: "directive-include.mk" line 47: Could not find "
 make: "directive-include.mk" line 52: Unknown modifier "Z"
 make: "directive-include.mk" line 52: Could not find nonexistent.mk
 make: "directive-include.mk" line 57: Cannot open /nonexistent
 make: "directive-include.mk" line 62: Invalid line type
 make: Fatal errors encountered -- cannot continue
 make: stopped in unit-tests
 exit status 1

 @@ -1,30 +1,30 @@
 make: Bad conditional expression 'variable expression == "literal"' in 'variable expression == "literal"?bad:bad'
 make: "varmod-ifelse.mk" line 27: Malformed conditional (${${:Uvariable expression} == "literal":?bad:bad})
 make: Bad conditional expression ' == ""' in ' == ""?bad-assign:bad-assign'
 make: Bad conditional expression ' == ""' in ' == ""?bad-cond:bad-cond'
 make: "varmod-ifelse.mk" line 44: Malformed conditional (${${UNDEF} == "":?bad-cond:bad-cond})
 make: Bad conditional expression '1 == == 2' in '1 == == 2?yes:no'
 make: "varmod-ifelse.mk" line 66: Malformed conditional (${1 == == 2:?yes:no} != "")
 CondParser_Eval: "${1 == == 2:?yes:no}" != ""
 CondParser_Eval: 1 == == 2
-lhs = 1.000000, rhs = 0.000000, op = ==
+Comparing 1.000000 == 0.000000
 make: Bad conditional expression '1 == == 2' in '1 == == 2?yes:no'
-lhs = "", rhs = "", op = !=
+Comparing "" != ""
 make: "varmod-ifelse.mk" line 92: warning: Oops, the parse error should have been propagated.
 CondParser_Eval: ${ ${:U\$}{VAR} == value :?ok:bad} != "ok"
 CondParser_Eval: ${VAR} == value
-lhs = "value", rhs = "value", op = ==
+Comparing "value" == "value"
-lhs = "ok", rhs = "ok", op = !=
+Comparing "ok" != "ok"
 make: "varmod-ifelse.mk" line 153: no.
 make: "varmod-ifelse.mk" line 154: String comparison operator must be either == or !=
 make: Bad conditional expression 'string == "literal" || no >= 10' in 'string == "literal" || no >= 10?yes:no'
 make: "varmod-ifelse.mk" line 154: .
 make: Bad conditional expression 'string == "literal" &&  >= 10' in 'string == "literal" &&  >= 10?yes:no'
 make: "varmod-ifelse.mk" line 159: .
 make: Bad conditional expression 'string == "literal" ||  >= 10' in 'string == "literal" ||  >= 10?yes:no'
 make: "varmod-ifelse.mk" line 160: .
 make: "varmod-ifelse.mk" line 167: true
 make: "varmod-ifelse.mk" line 169: false
 make: Bad conditional expression '	' in '	?true:false'
 make: "varmod-ifelse.mk" line 171:
 make: Fatal errors encountered -- cannot continue

 @@ -1,16 +1,16 @@
 Parsing line 78: USE_8_DOLLARS=	${:U1:@var@${8_DOLLARS}@} ${8_DOLLARS} $$$$$$$$
 CondParser_Eval: ${USE_8_DOLLARS} != "\$\$\$\$ \$\$\$\$ \$\$\$\$"
-lhs = "$$$$ $$$$ $$$$", rhs = "$$$$ $$$$ $$$$", op = !=
+Comparing "$$$$ $$$$ $$$$" != "$$$$ $$$$ $$$$"
 Parsing line 83: SUBST_CONTAINING_LOOP:= ${USE_8_DOLLARS}
 CondParser_Eval: ${SUBST_CONTAINING_LOOP} != "\$\$ \$\$\$\$ \$\$\$\$"
-lhs = "$$ $$$$ $$$$", rhs = "$$ $$$$ $$$$", op = !=
+Comparing "$$ $$$$ $$$$" != "$$ $$$$ $$$$"
 Parsing line 108: .MAKEFLAGS: -d0
 ParseDependency(.MAKEFLAGS: -d0)
 :varname-overwriting-target: :x1y x2y x3y: ::
 mod-loop-dollar:1:
 mod-loop-dollar:${word}$:
 mod-loop-dollar:$3$:
 mod-loop-dollar:$${word}$$:
 mod-loop-dollar:$$5$$:
 mod-loop-dollar:$$${word}$$$:
 exit status 0

 @@ -1,12 +1,12 @@
 CondParser_Eval: ${NUMBERS:M[A-Z]*} != "One Two Three Four"
-lhs = "One Two Three Four", rhs = "One Two Three Four", op = !=
+Comparing "One Two Three Four" != "One Two Three Four"
 CondParser_Eval: ${NUMBERS:M[^A-Z]*} != "five six seven"
-lhs = "five six seven", rhs = "five six seven", op = !=
+Comparing "five six seven" != "five six seven"
 CondParser_Eval: ${NUMBERS:M[^s]*[ex]} != "One Three five"
-lhs = "One Three five", rhs = "One Three five", op = !=
+Comparing "One Three five" != "One Three five"
 CondParser_Eval: ${:U****************:M****************b}
 CondParser_Eval: ${:Ua \$ sign:M*$$*} != "\$"
-lhs = "$", rhs = "$", op = !=
+Comparing "$" != "$"
 CondParser_Eval: ${:Ua \$ sign any-asterisk:M*\$*} != "any-asterisk"
-lhs = "any-asterisk", rhs = "any-asterisk", op = !=
+Comparing "any-asterisk" != "any-asterisk"
 exit status 0

 @@ -1,32 +1,32 @@
 Parsing line 10: ORIG_SHELL:=	${.SHELL}
 Global: ORIG_SHELL =
 Var_Parse: ${.SHELL} (eval-keep-dollar-and-undefined)
 Global:delete .SHELL (not found)
 Command: .SHELL = (details omitted)
 Global: ORIG_SHELL = (details omitted)
 Parsing line 12: .SHELL=		overwritten
 Global: .SHELL = overwritten
 CondParser_Eval: ${.SHELL} != ${ORIG_SHELL}
 Var_Parse: ${.SHELL} != ${ORIG_SHELL} (eval-defined)
 Var_Parse: ${ORIG_SHELL} (eval-defined)
-lhs = "(details omitted)", rhs = "(details omitted)", op = !=
+Comparing "(details omitted)" != "(details omitted)"
 Parsing line 19: .MAKEFLAGS: .SHELL+=appended
 ParseDependency(.MAKEFLAGS: .SHELL+=appended)
 Ignoring append to .SHELL since it is read-only
 CondParser_Eval: ${.SHELL} != ${ORIG_SHELL}
 Var_Parse: ${.SHELL} != ${ORIG_SHELL} (eval-defined)
 Var_Parse: ${ORIG_SHELL} (eval-defined)
-lhs = "(details omitted)", rhs = "(details omitted)", op = !=
+Comparing "(details omitted)" != "(details omitted)"
 Parsing line 27: .undef .SHELL
 Global:delete .SHELL
 Parsing line 28: .SHELL=		newly overwritten
 Global: .SHELL = newly overwritten
 CondParser_Eval: ${.SHELL} != ${ORIG_SHELL}
 Var_Parse: ${.SHELL} != ${ORIG_SHELL} (eval-defined)
 Var_Parse: ${ORIG_SHELL} (eval-defined)
-lhs = "(details omitted)", rhs = "(details omitted)", op = !=
+Comparing "(details omitted)" != "(details omitted)"
 Parsing line 33: .MAKEFLAGS: -d0
 ParseDependency(.MAKEFLAGS: -d0)
 Global: .MAKEFLAGS =  -r -k -d cpv -d
 Global: .MAKEFLAGS =  -r -k -d cpv -d 0
 exit status 0

 @@ -1,10 +1,10 @@
 Global:delete DOLLAR (not found)
 Command: DOLLAR = $$$$
 Global: .MAKEOVERRIDES =  VAR DOLLAR
 CondParser_Eval: ${DOLLAR} != "\$\$"
 Var_Parse: ${DOLLAR} != "\$\$" (eval-defined)
-lhs = "$$", rhs = "$$", op = !=
+Comparing "$$" != "$$"
 Global: .MAKEFLAGS =  -r -k -D VAR -D VAR -d cv -d
 Global: .MAKEFLAGS =  -r -k -D VAR -D VAR -d cv -d 0
 make: Unterminated quoted string [make VAR=initial UNBALANCED=']
 exit status 0

 @@ -1,6 +1,6 @@
 CondParser_Eval: ${:U12345} > ${:U55555}
-lhs = 12345.000000, rhs = 55555.000000, op = >
+Comparing 12345.000000 > 55555.000000
 CondParser_Eval: "string" != "string"
-lhs = "string", rhs = "string", op = !=
+Comparing "string" != "string"
 CondParser_Eval: "nonempty"
 exit status 0