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(1): use consistent naming scheme for condi...
details: https://anonhg.NetBSD.org/src/rev/ba11cbf6683d
branches: trunk
changeset: 976015:ba11cbf6683d
user: rillig <rillig%NetBSD.org@localhost>
date: Fri Sep 11 04:57:15 2020 +0000
description:
make(1): use consistent naming scheme for condition parsing functions
diffstat:
usr.bin/make/cond.c | 118 ++++++++++++++++++++++++++--------------------------
1 files changed, 59 insertions(+), 59 deletions(-)
diffs (truncated from 385 to 300 lines):
diff -r 5129d21c8669 -r ba11cbf6683d usr.bin/make/cond.c
--- a/usr.bin/make/cond.c Fri Sep 11 04:40:26 2020 +0000
+++ b/usr.bin/make/cond.c Fri Sep 11 04:57:15 2020 +0000
@@ -1,4 +1,4 @@
-/* $NetBSD: cond.c,v 1.124 2020/09/11 04:40:26 rillig Exp $ */
+/* $NetBSD: cond.c,v 1.125 2020/09/11 04:57:15 rillig Exp $ */
/*
* Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
@@ -70,14 +70,14 @@
*/
#ifndef MAKE_NATIVE
-static char rcsid[] = "$NetBSD: cond.c,v 1.124 2020/09/11 04:40:26 rillig Exp $";
+static char rcsid[] = "$NetBSD: cond.c,v 1.125 2020/09/11 04:57:15 rillig Exp $";
#else
#include <sys/cdefs.h>
#ifndef lint
#if 0
static char sccsid[] = "@(#)cond.c 8.2 (Berkeley) 1/2/94";
#else
-__RCSID("$NetBSD: cond.c,v 1.124 2020/09/11 04:40:26 rillig Exp $");
+__RCSID("$NetBSD: cond.c,v 1.125 2020/09/11 04:57:15 rillig Exp $");
#endif
#endif /* not lint */
#endif
@@ -140,8 +140,8 @@
*
* TOK_FALSE is 0 and TOK_TRUE 1 so we can directly assign C comparisons.
*
- * All non-terminal functions (CondE, CondF and CondT) return either
- * TOK_FALSE, TOK_TRUE, or TOK_ERROR on error.
+ * All non-terminal functions (CondParser_Expr, CondParser_Factor and
+ * CondParser_Term) return either TOK_FALSE, TOK_TRUE, or TOK_ERROR on error.
*/
typedef enum {
TOK_FALSE = 0, TOK_TRUE = 1, TOK_AND, TOK_OR, TOK_NOT,
@@ -154,8 +154,8 @@
Token curr; /* Single push-back token used in parsing */
} CondParser;
-static Token CondE(CondParser *par, Boolean);
-static CondEvalResult do_Cond_EvalExpression(CondParser *par, Boolean *);
+static Token CondParser_Expr(CondParser *par, Boolean);
+static CondEvalResult CondParser_Eval(CondParser *par, Boolean *value);
static unsigned int cond_depth = 0; /* current .if nesting level */
static unsigned int cond_min_depth = 0; /* depth at makefile open */
@@ -173,7 +173,7 @@
static Boolean lhsStrict;
static int
-istoken(const char *str, const char *tok, size_t len)
+is_token(const char *str, const char *tok, size_t len)
{
return strncmp(str, tok, len) == 0 && !isalpha((unsigned char)str[len]);
}
@@ -290,7 +290,7 @@
/* Test whether the given variable is defined. */
static Boolean
-CondDoDefined(int argLen MAKE_ATTR_UNUSED, const char *arg)
+FuncDefined(int argLen MAKE_ATTR_UNUSED, const char *arg)
{
char *freeIt;
Boolean result = Var_Value(arg, VAR_CMD, &freeIt) != NULL;
@@ -307,14 +307,14 @@
/* See if the given target is being made. */
static Boolean
-CondDoMake(int argLen MAKE_ATTR_UNUSED, const char *arg)
+FuncMake(int argLen MAKE_ATTR_UNUSED, const char *arg)
{
return Lst_Find(create, CondFindStrMatch, arg) != NULL;
}
/* See if the given file exists. */
static Boolean
-CondDoExists(int argLen MAKE_ATTR_UNUSED, const char *arg)
+FuncExists(int argLen MAKE_ATTR_UNUSED, const char *arg)
{
Boolean result;
char *path;
@@ -335,7 +335,7 @@
/* See if the given node exists and is an actual target. */
static Boolean
-CondDoTarget(int argLen MAKE_ATTR_UNUSED, const char *arg)
+FuncTarget(int argLen MAKE_ATTR_UNUSED, const char *arg)
{
GNode *gn;
@@ -346,7 +346,7 @@
/* See if the given node exists and is an actual target with commands
* associated with it. */
static Boolean
-CondDoCommands(int argLen MAKE_ATTR_UNUSED, const char *arg)
+FuncCommands(int argLen MAKE_ATTR_UNUSED, const char *arg)
{
GNode *gn;
@@ -364,7 +364,7 @@
* Returns TRUE if the conversion succeeded.
*/
static Boolean
-CondCvtArg(const char *str, double *value)
+TryParseNumber(const char *str, double *value)
{
char *eptr, ech;
unsigned long l_val;
@@ -515,16 +515,16 @@
Boolean doNot; /* TRUE if default function should be negated */
Boolean (*defProc)(int, const char *); /* Default function to apply */
} ifs[] = {
- { "def", 3, FALSE, CondDoDefined },
- { "ndef", 4, TRUE, CondDoDefined },
- { "make", 4, FALSE, CondDoMake },
- { "nmake", 5, TRUE, CondDoMake },
- { "", 0, FALSE, CondDoDefined },
+ { "def", 3, FALSE, FuncDefined },
+ { "ndef", 4, TRUE, FuncDefined },
+ { "make", 4, FALSE, FuncMake },
+ { "nmake", 5, TRUE, FuncMake },
+ { "", 0, FALSE, FuncDefined },
{ NULL, 0, FALSE, NULL }
};
static Token
-compare_expression(CondParser *par, Boolean doEval)
+CondParser_Comparison(CondParser *par, Boolean doEval)
{
Token t;
const char *lhs;
@@ -579,7 +579,7 @@
goto done;
}
/* For .ifxxx <number> compare against zero */
- if (CondCvtArg(lhs, &left)) {
+ if (TryParseNumber(lhs, &left)) {
t = left != 0.0;
goto done;
}
@@ -637,7 +637,7 @@
* lhs and the rhs to a double and compare the two.
*/
- if (!CondCvtArg(lhs, &left) || !CondCvtArg(rhs, &right))
+ if (!TryParseNumber(lhs, &left) || !TryParseNumber(rhs, &right))
goto do_string_compare;
if (DEBUG(COND)) {
@@ -718,14 +718,14 @@
}
static Boolean
-CondDoEmpty(int arglen, const char *arg MAKE_ATTR_UNUSED)
+FuncEmpty(int arglen, const char *arg MAKE_ATTR_UNUSED)
{
/* Magic values ahead, see ParseEmptyArg. */
return arglen == 1;
}
static Token
-compare_function(CondParser *par, Boolean doEval)
+CondParser_Func(CondParser *par, Boolean doEval)
{
static const struct fn_def {
const char *fn_name;
@@ -733,12 +733,12 @@
int (*fn_getarg)(Boolean, const char **, char **, const char *);
Boolean (*fn_proc)(int, const char *);
} fn_defs[] = {
- { "defined", 7, ParseFuncArg, CondDoDefined },
- { "make", 4, ParseFuncArg, CondDoMake },
- { "exists", 6, ParseFuncArg, CondDoExists },
- { "empty", 5, ParseEmptyArg, CondDoEmpty },
- { "target", 6, ParseFuncArg, CondDoTarget },
- { "commands", 8, ParseFuncArg, CondDoCommands },
+ { "defined", 7, ParseFuncArg, FuncDefined },
+ { "make", 4, ParseFuncArg, FuncMake },
+ { "exists", 6, ParseFuncArg, FuncExists },
+ { "empty", 5, ParseEmptyArg, FuncEmpty },
+ { "target", 6, ParseFuncArg, FuncTarget },
+ { "commands", 8, ParseFuncArg, FuncCommands },
{ NULL, 0, NULL, NULL },
};
const struct fn_def *fn_def;
@@ -749,7 +749,7 @@
const char *cp1;
for (fn_def = fn_defs; fn_def->fn_name != NULL; fn_def++) {
- if (!istoken(cp, fn_def->fn_name, fn_def->fn_name_len))
+ if (!is_token(cp, fn_def->fn_name, fn_def->fn_name_len))
continue;
cp += fn_def->fn_name_len;
/* There can only be whitespace before the '(' */
@@ -773,7 +773,7 @@
/* Push anything numeric through the compare expression */
cp = par->p;
if (isdigit((unsigned char)cp[0]) || strchr("+-", cp[0]))
- return compare_expression(par, doEval);
+ return CondParser_Comparison(par, doEval);
/*
* Most likely we have a naked token to apply the default function to.
@@ -787,7 +787,7 @@
for (cp1 = cp; isspace((unsigned char)*cp1); cp1++)
continue;
if (*cp1 == '=' || *cp1 == '!')
- return compare_expression(par, doEval);
+ return CondParser_Comparison(par, doEval);
par->p = cp;
/*
@@ -803,7 +803,7 @@
/* Return the next token or comparison result from the parser. */
static Token
-CondToken(CondParser *par, Boolean doEval)
+CondParser_Token(CondParser *par, Boolean doEval)
{
Token t;
@@ -852,10 +852,10 @@
case '"':
case '$':
- return compare_expression(par, doEval);
+ return CondParser_Comparison(par, doEval);
default:
- return compare_function(par, doEval);
+ return CondParser_Func(par, doEval);
}
}
@@ -869,11 +869,11 @@
* TOK_TRUE, TOK_FALSE or TOK_ERROR.
*/
static Token
-CondT(CondParser *par, Boolean doEval)
+CondParser_Term(CondParser *par, Boolean doEval)
{
Token t;
- t = CondToken(par, doEval);
+ t = CondParser_Token(par, doEval);
if (t == TOK_EOF) {
/*
@@ -885,14 +885,14 @@
/*
* T -> ( E )
*/
- t = CondE(par, doEval);
+ t = CondParser_Expr(par, doEval);
if (t != TOK_ERROR) {
- if (CondToken(par, doEval) != TOK_RPAREN) {
+ if (CondParser_Token(par, doEval) != TOK_RPAREN) {
t = TOK_ERROR;
}
}
} else if (t == TOK_NOT) {
- t = CondT(par, doEval);
+ t = CondParser_Term(par, doEval);
if (t == TOK_TRUE) {
t = TOK_FALSE;
} else if (t == TOK_FALSE) {
@@ -910,13 +910,13 @@
* TOK_TRUE, TOK_FALSE or TOK_ERROR
*/
static Token
-CondF(CondParser *par, Boolean doEval)
+CondParser_Factor(CondParser *par, Boolean doEval)
{
Token l, o;
- l = CondT(par, doEval);
+ l = CondParser_Term(par, doEval);
if (l != TOK_ERROR) {
- o = CondToken(par, doEval);
+ o = CondParser_Token(par, doEval);
if (o == TOK_AND) {
/*
@@ -928,9 +928,9 @@
* or not.
*/
if (l == TOK_TRUE) {
- l = CondF(par, doEval);
+ l = CondParser_Factor(par, doEval);
} else {
- (void)CondF(par, FALSE);
+ (void)CondParser_Factor(par, FALSE);
}
} else {
/*
@@ -950,13 +950,13 @@
* TOK_TRUE, TOK_FALSE or TOK_ERROR.
*/
Home |
Main Index |
Thread Index |
Old Index