Thu Mar 3 19:40:54 2022 UTC ()

make: improve local variable name in ParseWord in conditions

That function not only parses function arguments but also bare words, so
the name argBuf didn't match anymore.

No binary change.


(rillig)

diff -r1.331 -r1.332 src/usr.bin/make/cond.c

--- src/usr.bin/make/cond.c 2022/03/03 19:36:35	1.331
+++ src/usr.bin/make/cond.c 2022/03/03 19:40:54	1.332

 @@ -1,14 +1,14 @@
-/*	$NetBSD: cond.c,v 1.331 2022/03/03 19:36:35 rillig Exp $	*/
+/*	$NetBSD: cond.c,v 1.332 2022/03/03 19:40:54 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.331 2022/03/03 19:36:35 rillig Exp $");
+MAKE_RCSID("$NetBSD: cond.c,v 1.332 2022/03/03 19:40:54 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
 @@ -203,69 +203,69 @@ CondParser_SkipWhitespace(CondParser *pa
+{
 	cpp_skip_whitespace(&par->p);
+}
 /*
  * Parse a single word, taking into account balanced parentheses as well as
  * embedded expressions.  Used for the argument of a built-in function as
  * well as for bare words, which are then passed to the default function.
  */
 static char *
 ParseWord(const char **pp, bool doEval)
+{
 	const char *p = *pp;
-	Buffer argBuf;
+	Buffer word;
 	int paren_depth;
-	Buf_InitSize(&argBuf, 16);
+	Buf_InitSize(&word, 16);
 	paren_depth = 0;
 	for (;;) {
 		char ch = *p;
 		if (ch == '\0' || ch == ' ' || ch == '\t')
 			break;
 		if ((ch == '&' || ch == '|') && paren_depth == 0)
 			break;
 		if (ch == '$') {
 			/*
 			 * Parse the variable expression and install it as
 			 * part of the argument if it's valid. We tell
 			 * Var_Parse to complain on an undefined variable,
 			 * (XXX: but Var_Parse ignores that request)
 			 * so we don't need to do it. Nor do we return an
 			 * error, though perhaps we should.
 			 */
 			VarEvalMode emode = doEval
 			    ? VARE_UNDEFERR
 			    : VARE_PARSE_ONLY;
 			FStr nestedVal;
 			(void)Var_Parse(&p, SCOPE_CMDLINE, emode, &nestedVal);
 			/* TODO: handle errors */
-			Buf_AddStr(&argBuf, nestedVal.str);
+			Buf_AddStr(&word, nestedVal.str);
 			FStr_Done(&nestedVal);
 			continue;
+		}
 		if (ch == '(')
 			paren_depth++;
 		else if (ch == ')' && --paren_depth < 0)
 			break;
-		Buf_AddByte(&argBuf, ch);
+		Buf_AddByte(&word, ch);
 		p++;
+	}
 	cpp_skip_hspace(&p);
 	*pp = p;
-	return Buf_DoneData(&argBuf);
+	return Buf_DoneData(&word);
+}
 /* Parse the function argument, including the surrounding parentheses. */
 static char *
 ParseFuncArg(CondParser *par, const char **pp, bool doEval, const char *func)
+{
 	const char *p = *pp;
 	char *res;
 	p++;			/* Skip opening '(' - verified by caller */
 	cpp_skip_hspace(&p);
 	res = ParseWord(&p, doEval);
 	cpp_skip_hspace(&p);