 @@ -1,14 +1,14 @@
-/*	$NetBSD: cond.c,v 1.275 2021/09/21 21:43:32 rillig Exp $	*/
+/*	$NetBSD: cond.c,v 1.276 2021/09/21 22:38:25 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.275 2021/09/21 21:43:32 rillig Exp $");
+MAKE_RCSID("$NetBSD: cond.c,v 1.276 2021/09/21 22:38:25 rillig Exp $");
 /*
  * The parsing of conditional expressions is based on this grammar:
  *	Or -> And
  *	Or -> Or '||' And
  *	And -> Term
  *	And -> And '&&' Term
  *	Term -> Function '(' Argument ')'
  *	Term -> Leaf Operator Leaf
  *	Term -> Leaf
  *	Term -> '(' Or ')'
  *	Term -> '!' Term
  *	Leaf -> "string"
 @@ -144,58 +144,60 @@ typedef enum ComparisonOp {
 typedef struct CondParser {
 	/*
 	 * The plain '.if ${VAR}' evaluates to true if the value of the
 	 * expression has length > 0.  The other '.if' variants delegate
 	 * to evalBare instead.
 	 */
 	bool plain;
 	/* The function to apply on unquoted bare words. */
 	bool (*evalBare)(size_t, const char *);
 	bool negateEvalBare;
 	/*
 	 * Whether the left-hand side of a comparison may NOT be an unquoted
 	 * string.  This is allowed for expressions of the form
 	 * ${condition:?:}, see ApplyModifier_IfElse.  Such a condition is
 	 * expanded before it is evaluated, due to ease of implementation.
 	 * This means that at the point where the condition is evaluated,
 	 * make cannot know anymore whether the left-hand side had originally
 	 * been a variable expression or a plain word.
+	 *
 	 * In all other contexts, the left-hand side must either be a
 	 * variable expression, a quoted string or a number.
 	 */
 	bool lhsStrict;
 	const char *p;		/* The remaining condition to parse */
 	Token curr;		/* Single push-back token used in parsing */
 	/*
 	 * Whether an error message has already been printed for this
 	 * condition. The first available error message is usually the most
 	 * specific one, therefore it makes sense to suppress the standard
 	 * "Malformed conditional" message.
 	 */
 	bool printedError;
 } CondParser;
 static CondResult CondParser_Or(CondParser *par, bool);
 static unsigned int cond_depth = 0;	/* current .if nesting level */
 static unsigned int cond_min_depth = 0;	/* depth at makefile open */
 /* Names for ComparisonOp. */
 static const char *opname[] = { "<", "<=", ">", ">=", "==", "!=" };
 /*
  * Indicate when we should be strict about lhs of comparisons.
  * In strict mode, the lhs must be a variable expression or a string literal
  * in quotes. In non-strict mode it may also be an unquoted string literal.
  * True when CondEvalExpression is called from Cond_EvalLine (.if etc).
  * False when CondEvalExpression is called from ApplyModifier_IfElse
  * since lhs is already expanded, and at that point we cannot tell if
  * it was a variable reference or not.
  */
 static bool lhsStrict;
 static bool
 is_token(const char *str, const char *tok, size_t len)
+{
 	return strncmp(str, tok, len) == 0 && !ch_isalpha(str[len]);
+}
 static Token
 ToToken(bool cond)
+{
 	return cond ? TOK_TRUE : TOK_FALSE;
+}
 /* Push back the most recent token read. We only need one level of this. */
 @@ -672,27 +674,27 @@ length_1:
  *	0
  *	${VAR:Mpattern}
  *	${VAR} == value
  *	${VAR:U0} < 12345
  */
 static Token
 CondParser_Comparison(CondParser *par, bool doEval)
+{
 	Token t = TOK_ERROR;
 	FStr lhs, rhs;
 	ComparisonOp op;
 	bool lhsQuoted, rhsQuoted;
-	CondParser_Leaf(par, doEval, lhsStrict, &lhs, &lhsQuoted);
+	CondParser_Leaf(par, doEval, par->lhsStrict, &lhs, &lhsQuoted);
 	if (lhs.str == NULL)
 		goto done_lhs;
 	CondParser_SkipWhitespace(par);
 	if (!CondParser_ComparisonOp(par, &op)) {
 		/* Unknown operator, compare against an empty string or 0. */
 		t = ToToken(doEval && EvalNotEmpty(par, lhs.str, lhsQuoted));
 		goto done_lhs;
+	}
 	CondParser_SkipWhitespace(par);
 @@ -1053,33 +1055,32 @@ CondParser_Eval(CondParser *par, bool *o
  *	COND_PARSE	if the condition was valid grammatically
  *	COND_INVALID	if not a valid conditional.
+ *
  *	(*value) is set to the boolean value of the condition
  */
 static CondEvalResult
 CondEvalExpression(const char *cond, bool *out_value, bool plain,
 		   bool (*evalBare)(size_t, const char *), bool negate,
 		   bool eprint, bool strictLHS)
+{
 	CondParser par;
 	CondEvalResult rval;
 	lhsStrict = strictLHS;
 	cpp_skip_hspace(&cond);
 	par.plain = plain;
 	par.evalBare = evalBare;
 	par.negateEvalBare = negate;
 	par.lhsStrict = strictLHS;
 	par.p = cond;
 	par.curr = TOK_NONE;
 	par.printedError = false;
 	rval = CondParser_Eval(&par, out_value);
 	if (rval == COND_INVALID && eprint && !par.printedError)
 		Parse_Error(PARSE_FATAL, "Malformed conditional (%s)", cond);
 	return rval;
+}
 /*

 @@ -1,14 +1,14 @@
-# $NetBSD: cond-token-plain.mk,v 1.11 2021/09/21 21:59:56 rillig Exp $
+# $NetBSD: cond-token-plain.mk,v 1.12 2021/09/21 22:38:25 rillig Exp $
+#
 # Tests for plain tokens (that is, string literals without quotes)
 # in .if conditions.
 .MAKEFLAGS: -dc
 .if ${:Uvalue} != value
 .  error
 .endif
 # Malformed condition since comment parsing is done in an early phase
 # and removes the '#' and everything behind it long before the condition
 # parser gets to see it.
 @@ -183,26 +183,27 @@ ${:U\\\\}=	backslash
 .  error
 .else
 .  error
 .endif
 # In a condition in an .if directive, the left-hand side must not be an
 # unquoted string literal.
 # expect+1: Malformed conditional (left == right)
 .if left == right
 .endif
 # Before cond.c 1.276 from 2021-09-21, a variable expression containing the
 # modifier ':?:' allowed unquoted string literals for the rest of the
 # condition.  This was an unintended implementation mistake.
 # expect+1: Malformed conditional (${0:?:} || left == right)
 .if ${0:?:} || left == right
 .endif
 # This affected only the comparisons after the expression, so the following
 # was still a syntax error.
 # expect+1: Malformed conditional (left == right || ${0:?:})
 .if left == right || ${0:?:}
 .endif
 # See cond-token-string.mk for similar tests where the condition is enclosed
 # in "quotes".
 all:
 	@:;

 @@ -43,19 +43,19 @@ make: "cond-token-plain.mk" line 140: Mi
 CondParser_Eval: == ""
 make: "cond-token-plain.mk" line 148: Malformed conditional (== "")
 CondParser_Eval: \\
 make: "cond-token-plain.mk" line 163: The variable '\\' is not defined.
 CondParser_Eval: \\
 make: "cond-token-plain.mk" line 168: Now the variable '\\' is defined.
 CondParser_Eval: "unquoted\"quoted" != unquoted"quoted
 lhs = "unquoted"quoted", rhs = "unquoted"quoted", op = !=
 CondParser_Eval: $$$$$$$$ != ""
 CondParser_Eval: left == right
 make: "cond-token-plain.mk" line 191: Malformed conditional (left == right)
 CondParser_Eval: ${0:?:} || left == right
 CondParser_Eval: 0
-lhs = "left", rhs = "right", op = ==
+make: "cond-token-plain.mk" line 197: Malformed conditional (${0:?:} || left == right)
 CondParser_Eval: left == right || ${0:?:}
-make: "cond-token-plain.mk" line 201: Malformed conditional (left == right || ${0:?:})
+make: "cond-token-plain.mk" line 202: Malformed conditional (left == right || ${0:?:})
 make: Fatal errors encountered -- cannot continue
 make: stopped in unit-tests
 exit status 1