Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files. =================================================================== RCS file: /ftp/cvs/cvsroot/src/usr.bin/make/cond.c,v rcsdiff: /ftp/cvs/cvsroot/src/usr.bin/make/cond.c,v: warning: Unknown phrases like `commitid ...;' are present. retrieving revision 1.34 retrieving revision 1.57 diff -u -p -r1.34 -r1.57 --- src/usr.bin/make/cond.c 2006/10/15 08:38:21 1.34 +++ src/usr.bin/make/cond.c 2009/01/29 07:48:39 1.57 @@ -1,4 +1,4 @@ -/* $NetBSD: cond.c,v 1.34 2006/10/15 08:38:21 dsl Exp $ */ +/* $NetBSD: cond.c,v 1.57 2009/01/29 07:48:39 enami 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.34 2006/10/15 08:38:21 dsl Exp $"; +static char rcsid[] = "$NetBSD: cond.c,v 1.57 2009/01/29 07:48:39 enami Exp $"; #else #include #ifndef lint #if 0 static char sccsid[] = "@(#)cond.c 8.2 (Berkeley) 1/2/94"; #else -__RCSID("$NetBSD: cond.c,v 1.34 2006/10/15 08:38:21 dsl Exp $"); +__RCSID("$NetBSD: cond.c,v 1.57 2009/01/29 07:48:39 enami Exp $"); #endif #endif /* not lint */ #endif @@ -92,6 +92,7 @@ __RCSID("$NetBSD: cond.c,v 1.34 2006/10/ */ #include +#include /* For strtoul() error checking */ #include "make.h" #include "hash.h" @@ -139,47 +140,41 @@ typedef enum { * last two fields are stored in condInvert and condDefProc, respectively. */ static void CondPushBack(Token); -static int CondGetArg(char **, char **, const char *, Boolean); -static Boolean CondDoDefined(int, char *); -static int CondStrMatch(ClientData, ClientData); -static Boolean CondDoMake(int, char *); -static Boolean CondDoExists(int, char *); -static Boolean CondDoTarget(int, char *); -static Boolean CondDoCommands(int, char *); -static char * CondCvtArg(char *, double *); +static int CondGetArg(char **, char **, const char *); +static Boolean CondDoDefined(int, const char *); +static int CondStrMatch(const void *, const void *); +static Boolean CondDoMake(int, const char *); +static Boolean CondDoExists(int, const char *); +static Boolean CondDoTarget(int, const char *); +static Boolean CondDoCommands(int, const char *); +static Boolean CondCvtArg(char *, double *); static Token CondToken(Boolean); static Token CondT(Boolean); static Token CondF(Boolean); static Token CondE(Boolean); +static int do_Cond_EvalExpression(Boolean *); -static struct If { +static const struct If { const char *form; /* Form of if */ int formlen; /* Length of form */ Boolean doNot; /* TRUE if default function should be negated */ - Boolean (*defProc)(int, char *); /* Default function to apply */ + Boolean (*defProc)(int, const char *); /* Default function to apply */ } ifs[] = { - { "ifdef", 5, FALSE, CondDoDefined }, - { "ifndef", 6, TRUE, CondDoDefined }, - { "ifmake", 6, FALSE, CondDoMake }, - { "ifnmake", 7, TRUE, CondDoMake }, - { "if", 2, FALSE, CondDoDefined }, + { "def", 3, FALSE, CondDoDefined }, + { "ndef", 4, TRUE, CondDoDefined }, + { "make", 4, FALSE, CondDoMake }, + { "nmake", 5, TRUE, CondDoMake }, + { "", 0, FALSE, CondDoDefined }, { NULL, 0, FALSE, NULL } }; -static Boolean condInvert; /* Invert the default function */ -static Boolean (*condDefProc)(int, char *); /* Default function to apply */ +static const struct If *if_info; /* Info for current statement */ static char *condExpr; /* The expression to parse */ static Token condPushBack=None; /* Single push-back token used in * parsing */ -#define MAXIF 64 /* greatest depth of #if'ing */ - -static Boolean finalElse[MAXIF+1][MAXIF+1]; /* Seen final else (stack) */ -static Boolean condStack[MAXIF]; /* Stack of conditionals's values */ -static int condTop = MAXIF; /* Top-most conditional */ -static int skipIfLevel=0; /* Depth of skipped conditionals */ -static Boolean skipLine = FALSE; /* Whether the parse module is skipping - * lines */ +static unsigned int cond_depth = 0; /* current .if nesting level */ +static unsigned int cond_min_depth = 0; /* depth at makefile open */ static int istoken(const char *str, const char *tok, size_t len) @@ -228,21 +223,18 @@ CondPushBack(Token t) *----------------------------------------------------------------------- */ static int -CondGetArg(char **linePtr, char **argPtr, const char *func, Boolean parens) +CondGetArg(char **linePtr, char **argPtr, const char *func) { char *cp; int argLen; Buffer buf; + int paren_depth; + char ch; cp = *linePtr; - if (parens) { - while (*cp != '(' && *cp != '\0') { - cp++; - } - if (*cp == '(') { - cp++; - } - } + if (func != NULL) + /* Skip opening '(' - verfied by caller */ + cp++; if (*cp == '\0') { /* @@ -263,9 +255,15 @@ CondGetArg(char **linePtr, char **argPtr * Create a buffer for the argument and start it out at 16 characters * long. Why 16? Why not? */ - buf = Buf_Init(16); + Buf_Init(&buf, 16); - while ((strchr(" \t)&|", *cp) == NULL) && (*cp != '\0')) { + paren_depth = 0; + for (;;) { + ch = *cp; + if (ch == 0 || ch == ' ' || ch == '\t') + break; + if ((ch == '&' || ch == '|') && paren_depth == 0) + break; if (*cp == '$') { /* * Parse the variable spec and install it as part of the argument @@ -278,32 +276,32 @@ CondGetArg(char **linePtr, char **argPtr void *freeIt; cp2 = Var_Parse(cp, VAR_CMD, TRUE, &len, &freeIt); - Buf_AddBytes(buf, strlen(cp2), (Byte *)cp2); + Buf_AddBytes(&buf, strlen(cp2), cp2); if (freeIt) free(freeIt); cp += len; - } else { - Buf_AddByte(buf, (Byte)*cp); - cp++; + continue; } + if (ch == '(') + paren_depth++; + else + if (ch == ')' && --paren_depth < 0) + break; + Buf_AddByte(&buf, *cp); + cp++; } - Buf_AddByte(buf, (Byte)'\0'); - *argPtr = (char *)Buf_GetAll(buf, &argLen); - Buf_Destroy(buf, FALSE); + *argPtr = Buf_GetAll(&buf, &argLen); + Buf_Destroy(&buf, FALSE); while (*cp == ' ' || *cp == '\t') { cp++; } - if (parens && *cp != ')') { + + if (func != NULL && *cp++ != ')') { Parse_Error(PARSE_WARNING, "Missing closing parenthesis for %s()", func); return (0); - } else if (parens) { - /* - * Advance pointer past close parenthesis. - */ - cp++; } *linePtr = cp; @@ -324,13 +322,11 @@ CondGetArg(char **linePtr, char **argPtr *----------------------------------------------------------------------- */ static Boolean -CondDoDefined(int argLen, char *arg) +CondDoDefined(int argLen, const char *arg) { - char savec = arg[argLen]; char *p1; Boolean result; - arg[argLen] = '\0'; if (Var_Value(arg, VAR_CMD, &p1) != NULL) { result = TRUE; } else { @@ -338,7 +334,6 @@ CondDoDefined(int argLen, char *arg) } if (p1) free(p1); - arg[argLen] = savec; return (result); } @@ -357,9 +352,9 @@ CondDoDefined(int argLen, char *arg) *----------------------------------------------------------------------- */ static int -CondStrMatch(ClientData string, ClientData pattern) +CondStrMatch(const void *string, const void *pattern) { - return(!Str_Match((char *)string,(char *)pattern)); + return(!Str_Match(string, pattern)); } /*- @@ -376,19 +371,9 @@ CondStrMatch(ClientData string, ClientDa *----------------------------------------------------------------------- */ static Boolean -CondDoMake(int argLen, char *arg) +CondDoMake(int argLen, const char *arg) { - char savec = arg[argLen]; - Boolean result; - - arg[argLen] = '\0'; - if (Lst_Find(create, (ClientData)arg, CondStrMatch) == NILLNODE) { - result = FALSE; - } else { - result = TRUE; - } - arg[argLen] = savec; - return (result); + return Lst_Find(create, arg, CondStrMatch) != NULL; } /*- @@ -405,13 +390,11 @@ CondDoMake(int argLen, char *arg) *----------------------------------------------------------------------- */ static Boolean -CondDoExists(int argLen, char *arg) +CondDoExists(int argLen, const char *arg) { - char savec = arg[argLen]; Boolean result; char *path; - arg[argLen] = '\0'; path = Dir_FindFile(arg, dirSearchPath); if (path != NULL) { result = TRUE; @@ -419,7 +402,6 @@ CondDoExists(int argLen, char *arg) } else { result = FALSE; } - arg[argLen] = savec; if (DEBUG(COND)) { fprintf(debug_file, "exists(%s) result is \"%s\"\n", arg, path ? path : ""); @@ -441,21 +423,12 @@ CondDoExists(int argLen, char *arg) *----------------------------------------------------------------------- */ static Boolean -CondDoTarget(int argLen, char *arg) +CondDoTarget(int argLen, const char *arg) { - char savec = arg[argLen]; - Boolean result; GNode *gn; - arg[argLen] = '\0'; gn = Targ_FindNode(arg, TARG_NOCREATE); - if ((gn != NILGNODE) && !OP_NOP(gn->type)) { - result = TRUE; - } else { - result = FALSE; - } - arg[argLen] = savec; - return (result); + return (gn != NULL) && !OP_NOP(gn->type); } /*- @@ -474,67 +447,51 @@ CondDoTarget(int argLen, char *arg) *----------------------------------------------------------------------- */ static Boolean -CondDoCommands(int argLen, char *arg) +CondDoCommands(int argLen, const char *arg) { - char savec = arg[argLen]; - Boolean result; GNode *gn; - arg[argLen] = '\0'; gn = Targ_FindNode(arg, TARG_NOCREATE); - if ((gn != NILGNODE) && !OP_NOP(gn->type) && !Lst_IsEmpty(gn->commands)) { - result = TRUE; - } else { - result = FALSE; - } - arg[argLen] = savec; - return (result); + return (gn != NULL) && !OP_NOP(gn->type) && !Lst_IsEmpty(gn->commands); } /*- *----------------------------------------------------------------------- * CondCvtArg -- - * Convert the given number into a double. If the number begins - * with 0x, it is interpreted as a hexadecimal integer - * and converted to a double from there. All other strings just have - * strtod called on them. + * Convert the given number into a double. + * We try a base 10 or 16 integer conversion first, if that fails + * then we try a floating point conversion instead. * * Results: * Sets 'value' to double value of string. - * Returns NULL if string was fully consumed, - * else returns remaining input. - * - * Side Effects: - * Can change 'value' even if string is not a valid number. - * + * Returns 'true' if the convertion suceeded * *----------------------------------------------------------------------- */ -static char * +static Boolean CondCvtArg(char *str, double *value) { - if ((*str == '0') && (str[1] == 'x')) { - long i; - - for (str += 2, i = 0; *str; str++) { - int x; - if (isdigit((unsigned char) *str)) - x = *str - '0'; - else if (isxdigit((unsigned char) *str)) - x = 10 + *str - isupper((unsigned char) *str) ? 'A' : 'a'; - else - break; - i = (i << 4) + x; - } - *value = (double) i; - return *str ? str : NULL; + char *eptr, ech; + unsigned long l_val; + double d_val; + + errno = 0; + l_val = strtoul(str, &eptr, str[1] == 'x' ? 16 : 10); + ech = *eptr; + if (ech == 0 && errno != ERANGE) { + d_val = str[0] == '-' ? -(double)-l_val : (double)l_val; } else { - char *eptr; - *value = strtod(str, &eptr); - return *eptr ? eptr : NULL; + if (ech != 0 && ech != '.' && ech != 'e' && ech != 'E') + return FALSE; + d_val = strtod(str, &eptr); + if (*eptr) + return FALSE; } + + *value = d_val; + return TRUE; } - + /*- *----------------------------------------------------------------------- * CondGetString -- @@ -564,7 +521,7 @@ CondGetString(Boolean doEval, Boolean *q int qt; char *start; - buf = Buf_Init(0); + Buf_Init(&buf, 0); str = NULL; *freeIt = NULL; *quoted = qt = *condExpr == '"' ? 1 : 0; @@ -575,7 +532,7 @@ CondGetString(Boolean doEval, Boolean *q case '\\': if (condExpr[1] != '\0') { condExpr++; - Buf_AddByte(buf, (Byte)*condExpr); + Buf_AddByte(&buf, *condExpr); } break; case '"': @@ -583,7 +540,7 @@ CondGetString(Boolean doEval, Boolean *q condExpr++; /* we don't want the quotes */ goto got_str; } else - Buf_AddByte(buf, (Byte)*condExpr); /* likely? */ + Buf_AddByte(&buf, *condExpr); /* likely? */ break; case ')': case '!': @@ -595,7 +552,7 @@ CondGetString(Boolean doEval, Boolean *q if (!qt) goto got_str; else - Buf_AddByte(buf, (Byte)*condExpr); + Buf_AddByte(&buf, *condExpr); break; case '$': /* if we are in quotes, then an undefined variable is ok */ @@ -629,7 +586,7 @@ CondGetString(Boolean doEval, Boolean *q * Nope, we better copy str to buf */ for (cp = str; *cp; cp++) { - Buf_AddByte(buf, (Byte)*cp); + Buf_AddByte(&buf, *cp); } if (*freeIt) { free(*freeIt); @@ -639,16 +596,15 @@ CondGetString(Boolean doEval, Boolean *q condExpr--; /* don't skip over next char */ break; default: - Buf_AddByte(buf, (Byte)*condExpr); + Buf_AddByte(&buf, *condExpr); break; } } got_str: - Buf_AddByte(buf, (Byte)'\0'); - str = (char *)Buf_GetAll(buf, NULL); + str = Buf_GetAll(&buf, NULL); *freeIt = str; cleanup: - Buf_Destroy(buf, FALSE); + Buf_Destroy(&buf, FALSE); return str; } @@ -666,348 +622,339 @@ CondGetString(Boolean doEval, Boolean *q *----------------------------------------------------------------------- */ static Token -CondToken(Boolean doEval) +compare_expression(Boolean doEval) { - Token t; - - if (condPushBack == None) { - while (*condExpr == ' ' || *condExpr == '\t') { - condExpr++; - } - switch (*condExpr) { - case '(': - t = LParen; - condExpr++; - break; - case ')': - t = RParen; - condExpr++; - break; - case '|': - if (condExpr[1] == '|') { - condExpr++; - } - condExpr++; - t = Or; - break; - case '&': - if (condExpr[1] == '&') { - condExpr++; - } - condExpr++; - t = And; - break; - case '!': - t = Not; - condExpr++; - break; - case '#': - case '\n': - case '\0': - t = EndOfFile; - break; - case '"': - case '$': { - char *lhs; - char *rhs; - char *op; - void *lhsFree; - void *rhsFree; - Boolean lhsQuoted; - Boolean rhsQuoted; - - rhs = NULL; - lhsFree = rhsFree = FALSE; - lhsQuoted = rhsQuoted = FALSE; - - /* - * Parse the variable spec and skip over it, saving its - * value in lhs. - */ - t = Err; - lhs = CondGetString(doEval, &lhsQuoted, &lhsFree); - if (!lhs) { - if (lhsFree) - free(lhsFree); - return Err; - } - /* - * Skip whitespace to get to the operator - */ - while (isspace((unsigned char) *condExpr)) - condExpr++; + Token t; + char *lhs; + char *rhs; + char *op; + void *lhsFree; + void *rhsFree; + Boolean lhsQuoted; + Boolean rhsQuoted; + + rhs = NULL; + lhsFree = rhsFree = FALSE; + lhsQuoted = rhsQuoted = FALSE; + + /* + * Parse the variable spec and skip over it, saving its + * value in lhs. + */ + t = Err; + lhs = CondGetString(doEval, &lhsQuoted, &lhsFree); + if (!lhs) { + if (lhsFree) + free(lhsFree); + return Err; + } + /* + * Skip whitespace to get to the operator + */ + while (isspace((unsigned char) *condExpr)) + condExpr++; - /* - * Make sure the operator is a valid one. If it isn't a - * known relational operator, pretend we got a - * != 0 comparison. - */ - op = condExpr; - switch (*condExpr) { - case '!': - case '=': - case '<': - case '>': - if (condExpr[1] == '=') { - condExpr += 2; - } else { - condExpr += 1; - } - break; - default: - op = UNCONST("!="); - if (lhsQuoted) - rhs = UNCONST(""); - else - rhs = UNCONST("0"); + /* + * Make sure the operator is a valid one. If it isn't a + * known relational operator, pretend we got a + * != 0 comparison. + */ + op = condExpr; + switch (*condExpr) { + case '!': + case '=': + case '<': + case '>': + if (condExpr[1] == '=') { + condExpr += 2; + } else { + condExpr += 1; + } + break; + default: + op = UNCONST("!="); + if (lhsQuoted) + rhs = UNCONST(""); + else + rhs = UNCONST("0"); - goto do_compare; - } - while (isspace((unsigned char) *condExpr)) { - condExpr++; - } - if (*condExpr == '\0') { - Parse_Error(PARSE_WARNING, - "Missing right-hand-side of operator"); - goto error; - } - rhs = CondGetString(doEval, &rhsQuoted, &rhsFree); - if (!rhs) { - if (lhsFree) - free(lhsFree); - if (rhsFree) - free(rhsFree); - return Err; - } + goto do_compare; + } + while (isspace((unsigned char) *condExpr)) { + condExpr++; + } + if (*condExpr == '\0') { + Parse_Error(PARSE_WARNING, + "Missing right-hand-side of operator"); + goto error; + } + rhs = CondGetString(doEval, &rhsQuoted, &rhsFree); + if (!rhs) { + if (lhsFree) + free(lhsFree); + if (rhsFree) + free(rhsFree); + return Err; + } do_compare: - if (rhsQuoted || lhsQuoted) { + if (rhsQuoted || lhsQuoted) { do_string_compare: - if (((*op != '!') && (*op != '=')) || (op[1] != '=')) { - Parse_Error(PARSE_WARNING, - "String comparison operator should be either == or !="); - goto error; - } - - if (DEBUG(COND)) { - fprintf(debug_file, "lhs = \"%s\", rhs = \"%s\", op = %.2s\n", - lhs, rhs, op); - } - /* - * Null-terminate rhs and perform the comparison. - * t is set to the result. - */ - if (*op == '=') { - t = strcmp(lhs, rhs) ? False : True; - } else { - t = strcmp(lhs, rhs) ? True : False; - } - } else { - /* - * rhs is either a float or an integer. Convert both the - * lhs and the rhs to a double and compare the two. - */ - double left, right; - char *cp; - - if (CondCvtArg(lhs, &left)) - goto do_string_compare; - if ((cp = CondCvtArg(rhs, &right)) && - cp == rhs) - goto do_string_compare; - - if (DEBUG(COND)) { - fprintf(debug_file, "left = %f, right = %f, op = %.2s\n", left, - right, op); - } - switch(op[0]) { - case '!': - if (op[1] != '=') { - Parse_Error(PARSE_WARNING, - "Unknown operator"); - goto error; - } - t = (left != right ? True : False); - break; - case '=': - if (op[1] != '=') { - Parse_Error(PARSE_WARNING, - "Unknown operator"); - goto error; - } - t = (left == right ? True : False); - break; - case '<': - if (op[1] == '=') { - t = (left <= right ? True : False); - } else { - t = (left < right ? True : False); - } - break; - case '>': - if (op[1] == '=') { - t = (left >= right ? True : False); - } else { - t = (left > right ? True : False); - } - break; - } - } -error: - if (lhsFree) - free(lhsFree); - if (rhsFree) - free(rhsFree); - break; - } - default: { - Boolean (*evalProc)(int, char *); - Boolean invert = FALSE; - char *arg = NULL; - int arglen = 0; - - if (istoken(condExpr, "defined", 7)) { - /* - * Use CondDoDefined to evaluate the argument and - * CondGetArg to extract the argument from the 'function - * call'. - */ - evalProc = CondDoDefined; - condExpr += 7; - arglen = CondGetArg(&condExpr, &arg, "defined", TRUE); - if (arglen == 0) { - condExpr -= 7; - goto use_default; - } - } else if (istoken(condExpr, "make", 4)) { - /* - * Use CondDoMake to evaluate the argument and - * CondGetArg to extract the argument from the 'function - * call'. - */ - evalProc = CondDoMake; - condExpr += 4; - arglen = CondGetArg(&condExpr, &arg, "make", TRUE); - if (arglen == 0) { - condExpr -= 4; - goto use_default; - } - } else if (istoken(condExpr, "exists", 6)) { - /* - * Use CondDoExists to evaluate the argument and - * CondGetArg to extract the argument from the - * 'function call'. - */ - evalProc = CondDoExists; - condExpr += 6; - arglen = CondGetArg(&condExpr, &arg, "exists", TRUE); - if (arglen == 0) { - condExpr -= 6; - goto use_default; - } - } else if (istoken(condExpr, "empty", 5)) { - /* - * Use Var_Parse to parse the spec in parens and return - * True if the resulting string is empty. - */ - int length; - void *freeIt; - char *val; - - condExpr += 5; - - for (arglen = 0; - condExpr[arglen] != '(' && condExpr[arglen] != '\0'; - arglen += 1) - continue; - - if (condExpr[arglen] != '\0') { - val = Var_Parse(&condExpr[arglen - 1], VAR_CMD, - FALSE, &length, &freeIt); - if (val == var_Error) { - t = Err; - } else { - /* - * A variable is empty when it just contains - * spaces... 4/15/92, christos - */ - char *p; - for (p = val; *p && isspace((unsigned char)*p); p++) - continue; - t = (*p == '\0') ? True : False; - } - if (freeIt) { - free(freeIt); - } - /* - * Advance condExpr to beyond the closing ). Note that - * we subtract one from arglen + length b/c length - * is calculated from condExpr[arglen - 1]. - */ - condExpr += arglen + length - 1; - } else { - condExpr -= 5; - goto use_default; - } - break; - } else if (istoken(condExpr, "target", 6)) { - /* - * Use CondDoTarget to evaluate the argument and - * CondGetArg to extract the argument from the - * 'function call'. - */ - evalProc = CondDoTarget; - condExpr += 6; - arglen = CondGetArg(&condExpr, &arg, "target", TRUE); - if (arglen == 0) { - condExpr -= 6; - goto use_default; - } - } else if (istoken(condExpr, "commands", 8)) { - /* - * Use CondDoCommands to evaluate the argument and - * CondGetArg to extract the argument from the - * 'function call'. - */ - evalProc = CondDoCommands; - condExpr += 8; - arglen = CondGetArg(&condExpr, &arg, "commands", TRUE); - if (arglen == 0) { - condExpr -= 8; - goto use_default; - } - } else { - /* - * The symbol is itself the argument to the default - * function. We advance condExpr to the end of the symbol - * by hand (the next whitespace, closing paren or - * binary operator) and set to invert the evaluation - * function if condInvert is TRUE. - */ - use_default: - invert = condInvert; - evalProc = condDefProc; - arglen = CondGetArg(&condExpr, &arg, "", FALSE); - } + if (((*op != '!') && (*op != '=')) || (op[1] != '=')) { + Parse_Error(PARSE_WARNING, + "String comparison operator should be either == or !="); + goto error; + } - /* - * Evaluate the argument using the set function. If invert - * is TRUE, we invert the sense of the function. - */ - t = (!doEval || (* evalProc) (arglen, arg) ? - (invert ? False : True) : - (invert ? True : False)); - if (arg) - free(arg); - break; - } + if (DEBUG(COND)) { + fprintf(debug_file, "lhs = \"%s\", rhs = \"%s\", op = %.2s\n", + lhs, rhs, op); + } + /* + * Null-terminate rhs and perform the comparison. + * t is set to the result. + */ + if (*op == '=') { + t = strcmp(lhs, rhs) ? False : True; + } else { + t = strcmp(lhs, rhs) ? True : False; } } else { - t = condPushBack; + /* + * rhs is either a float or an integer. Convert both the + * lhs and the rhs to a double and compare the two. + */ + double left, right; + + if (!CondCvtArg(lhs, &left) || !CondCvtArg(rhs, &right)) + goto do_string_compare; + + if (DEBUG(COND)) { + fprintf(debug_file, "left = %f, right = %f, op = %.2s\n", left, + right, op); + } + switch(op[0]) { + case '!': + if (op[1] != '=') { + Parse_Error(PARSE_WARNING, + "Unknown operator"); + goto error; + } + t = (left != right ? True : False); + break; + case '=': + if (op[1] != '=') { + Parse_Error(PARSE_WARNING, + "Unknown operator"); + goto error; + } + t = (left == right ? True : False); + break; + case '<': + if (op[1] == '=') { + t = (left <= right ? True : False); + } else { + t = (left < right ? True : False); + } + break; + case '>': + if (op[1] == '=') { + t = (left >= right ? True : False); + } else { + t = (left > right ? True : False); + } + break; + } + } +error: + if (lhsFree) + free(lhsFree); + if (rhsFree) + free(rhsFree); + return t; +} + +static int +get_mpt_arg(char **linePtr, char **argPtr, const char *func) +{ + /* + * Use Var_Parse to parse the spec in parens and return + * True if the resulting string is empty. + */ + int length; + void *freeIt; + char *val; + char *cp = *linePtr; + + /* We do all the work here and return the result as the length */ + *argPtr = NULL; + + val = Var_Parse(cp - 1, VAR_CMD, FALSE, &length, &freeIt); + /* + * Advance *linePtr to beyond the closing ). Note that + * we subtract one because 'length' is calculated from 'cp - 1'. + */ + *linePtr = cp - 1 + length; + + if (val == var_Error) { + free(freeIt); + return -1; + } + + /* A variable is empty when it just contains spaces... 4/15/92, christos */ + while (isspace(*(unsigned char *)val)) + val++; + + /* + * For consistency with the other functions we can't generate the + * true/false here. + */ + length = *val ? 2 : 1; + if (freeIt) + free(freeIt); + return length; +} + +static Boolean +CondDoEmpty(int arglen, const char *arg) +{ + return arglen == 1; +} + +static Token +compare_function(Boolean doEval) +{ + static const struct fn_def { + const char *fn_name; + int fn_name_len; + int (*fn_getarg)(char **, char **, const char *); + Boolean (*fn_proc)(int, const char *); + } fn_defs[] = { + { "defined", 7, CondGetArg, CondDoDefined }, + { "make", 4, CondGetArg, CondDoMake }, + { "exists", 6, CondGetArg, CondDoExists }, + { "empty", 5, get_mpt_arg, CondDoEmpty }, + { "target", 6, CondGetArg, CondDoTarget }, + { "commands", 8, CondGetArg, CondDoCommands }, + { NULL, 0, NULL, NULL }, + }; + const struct fn_def *fn_def; + Token t; + char *arg = NULL; + int arglen; + char *cp = condExpr; + 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)) + continue; + cp += fn_def->fn_name_len; + /* There can only be whitespace before the '(' */ + while (isspace(*(unsigned char *)cp)) + cp++; + if (*cp != '(') + break; + + arglen = fn_def->fn_getarg(&cp, &arg, fn_def->fn_name); + if (arglen <= 0) { + condExpr = cp; + return arglen < 0 ? Err : False; + } + /* Evaluate the argument using the required function. */ + t = !doEval || fn_def->fn_proc(arglen, arg) ? True : False; + if (arg) + free(arg); + condExpr = cp; + return t; + } + + /* Push anything numeric through the compare expression */ + cp = condExpr; + if (isdigit((unsigned char)cp[0]) || strchr("+-", cp[0])) + return compare_expression(doEval); + + /* + * Most likely we have a naked token to apply the default function to. + * However ".if a == b" gets here when the "a" is unquoted and doesn't + * start with a '$'. This surprises people - especially given the way + * that for loops get expanded. + * If what follows the function argument is a '=' or '!' then the syntax + * would be invalid if we did "defined(a)" - so instead treat as an + * expression. + */ + arglen = CondGetArg(&cp, &arg, NULL); + for (cp1 = cp; isspace(*(unsigned char *)cp1); cp1++) + continue; + if (*cp1 == '=' || *cp1 == '!') + return compare_expression(doEval); + condExpr = cp; + + /* + * Evaluate the argument using the default function. If invert + * is TRUE, we invert the sense of the result. + */ + t = !doEval || if_info->defProc(arglen, arg) != if_info->doNot ? True : False; + if (arg) + free(arg); + return t; +} + +static Token +CondToken(Boolean doEval) +{ + Token t; + + t = condPushBack; + if (t != None) { condPushBack = None; + return t; + } + + while (*condExpr == ' ' || *condExpr == '\t') { + condExpr++; + } + + switch (*condExpr) { + + case '(': + condExpr++; + return LParen; + + case ')': + condExpr++; + return RParen; + + case '|': + if (condExpr[1] == '|') { + condExpr++; + } + condExpr++; + return Or; + + case '&': + if (condExpr[1] == '&') { + condExpr++; + } + condExpr++; + return And; + + case '!': + condExpr++; + return Not; + + case '#': + case '\n': + case '\0': + return EndOfFile; + + case '"': + case '$': + return compare_expression(doEval); + + default: + return compare_function(doEval); } - return (t); } - + /*- *----------------------------------------------------------------------- * CondT -- @@ -1171,44 +1118,64 @@ CondE(Boolean doEval) *----------------------------------------------------------------------- */ int -Cond_EvalExpression(int dosetup, char *line, Boolean *value, int eprint) +Cond_EvalExpression(const struct If *info, char *line, Boolean *value, int eprint) { - if (dosetup) { - condDefProc = CondDoDefined; - condInvert = 0; - } + static const struct If *dflt_info; + const struct If *sv_if_info = if_info; + char *sv_condExpr = condExpr; + Token sv_condPushBack = condPushBack; + int rval; while (*line == ' ' || *line == '\t') line++; + if (info == NULL && (info = dflt_info) == NULL) { + /* Scan for the entry for .if - it can't be first */ + for (info = ifs; ; info++) + if (info->form[0] == 0) + break; + dflt_info = info; + } + + if_info = info != NULL ? info : ifs + 4; condExpr = line; condPushBack = None; + rval = do_Cond_EvalExpression(value); + + if (rval == COND_INVALID && eprint) + Parse_Error(PARSE_FATAL, "Malformed conditional (%s)", line); + + if_info = sv_if_info; + condExpr = sv_condExpr; + condPushBack = sv_condPushBack; + + return rval; +} + +static int +do_Cond_EvalExpression(Boolean *value) +{ + switch (CondE(TRUE)) { case True: if (CondToken(TRUE) == EndOfFile) { *value = TRUE; - break; + return COND_PARSE; } - goto err; - /*FALLTHRU*/ + break; case False: if (CondToken(TRUE) == EndOfFile) { *value = FALSE; - break; + return COND_PARSE; } - /*FALLTHRU*/ - case Err: -err: - if (eprint) - Parse_Error(PARSE_FATAL, "Malformed conditional (%s)", - line); - return (COND_INVALID); + break; default: + case Err: break; } - return COND_PARSE; + return COND_INVALID; } @@ -1217,7 +1184,7 @@ err: * Cond_Eval -- * Evaluate the conditional in the passed line. The line * looks like this: - * # + * . * where is any of if, ifmake, ifnmake, ifdef, * ifndef, elif, elifmake, elifnmake, elifdef, elifndef * and consists of &&, ||, !, make(target), defined(variable) @@ -1234,156 +1201,157 @@ err: * Side Effects: * None. * + * Note that the states IF_ACTIVE and ELSE_ACTIVE are only different in order + * to detect splurious .else lines (as are SKIP_TO_ELSE and SKIP_TO_ENDIF) + * otherwise .else could be treated as '.elif 1'. + * *----------------------------------------------------------------------- */ int Cond_Eval(char *line) { - struct If *ifp; - Boolean isElse; - Boolean value = FALSE; + #define MAXIF 64 /* maximum depth of .if'ing */ + enum if_states { + IF_ACTIVE, /* .if or .elif part active */ + ELSE_ACTIVE, /* .else part active */ + SEARCH_FOR_ELIF, /* searching for .elif/else to execute */ + SKIP_TO_ELSE, /* has been true, but not seen '.else' */ + SKIP_TO_ENDIF /* nothing else to execute */ + }; + static enum if_states cond_state[MAXIF + 1] = { IF_ACTIVE }; + + const struct If *ifp; + Boolean isElif; + Boolean value; int level; /* Level at which to report errors. */ + enum if_states state; level = PARSE_FATAL; - for (line++; *line == ' ' || *line == '\t'; line++) { + /* skip leading character (the '.') and any whitespace */ + for (line++; *line == ' ' || *line == '\t'; line++) continue; - } - /* - * Find what type of if we're dealing with. The result is left - * in ifp and isElse is set TRUE if it's an elif line. - */ - if (line[0] == 'e' && line[1] == 'l') { - line += 2; - isElse = TRUE; - } else if (istoken(line, "endif", 5)) { - /* - * End of a conditional section. If skipIfLevel is non-zero, that - * conditional was skipped, so lines following it should also be - * skipped. Hence, we return COND_SKIP. Otherwise, the conditional - * was read so succeeding lines should be parsed (think about it...) - * so we return COND_PARSE, unless this endif isn't paired with - * a decent if. - */ - finalElse[condTop][skipIfLevel] = FALSE; - if (skipIfLevel != 0) { - skipIfLevel -= 1; - return (COND_SKIP); - } else { - if (condTop == MAXIF) { + /* Find what type of if we're dealing with. */ + if (line[0] == 'e') { + if (line[1] != 'l') { + if (!istoken(line + 1, "ndif", 4)) + return COND_INVALID; + /* End of conditional section */ + if (cond_depth == cond_min_depth) { Parse_Error(level, "if-less endif"); - return (COND_INVALID); - } else { - skipLine = FALSE; - condTop += 1; - return (COND_PARSE); + return COND_PARSE; } + /* Return state for previous conditional */ + cond_depth--; + if (cond_depth > MAXIF) + return COND_SKIP; + return cond_state[cond_depth] <= ELSE_ACTIVE ? COND_PARSE : COND_SKIP; } - } else { - isElse = FALSE; - } + + /* Quite likely this is 'else' or 'elif' */ + line += 2; + if (istoken(line, "se", 2)) { + /* It is else... */ + if (cond_depth == cond_min_depth) { + Parse_Error(level, "if-less else"); + return COND_PARSE; + } + + if (cond_depth > MAXIF) + return COND_SKIP; + state = cond_state[cond_depth]; + switch (state) { + case SEARCH_FOR_ELIF: + state = ELSE_ACTIVE; + break; + case ELSE_ACTIVE: + case SKIP_TO_ENDIF: + Parse_Error(PARSE_WARNING, "extra else"); + /* FALLTHROUGH */ + default: + case IF_ACTIVE: + case SKIP_TO_ELSE: + state = SKIP_TO_ENDIF; + break; + } + cond_state[cond_depth] = state; + return state <= ELSE_ACTIVE ? COND_PARSE : COND_SKIP; + } + /* Assume for now it is an elif */ + isElif = TRUE; + } else + isElif = FALSE; + + if (line[0] != 'i' || line[1] != 'f') + /* Not an ifxxx or elifxxx line */ + return COND_INVALID; /* * Figure out what sort of conditional it is -- what its default * function is, etc. -- by looking in the table of valid "ifs" */ - for (ifp = ifs; ifp->form != NULL; ifp++) { + line += 2; + for (ifp = ifs; ; ifp++) { + if (ifp->form == NULL) + return COND_INVALID; if (istoken(ifp->form, line, ifp->formlen)) { + line += ifp->formlen; break; } } - if (ifp->form == NULL) { - /* - * Nothing fit. If the first word on the line is actually - * "else", it's a valid conditional whose value is the inverse - * of the previous if we parsed. - */ - if (isElse && istoken(line, "se", 2)) { - if (finalElse[condTop][skipIfLevel]) { - Parse_Error(PARSE_WARNING, "extra else"); - } else { - finalElse[condTop][skipIfLevel] = TRUE; - } - if (condTop == MAXIF) { - Parse_Error(level, "if-less else"); - return (COND_INVALID); - } else if (skipIfLevel == 0) { - value = !condStack[condTop]; - } else { - return (COND_SKIP); - } - } else { - /* - * Not a valid conditional type. No error... - */ - return (COND_INVALID); + /* Now we know what sort of 'if' it is... */ + + if (isElif) { + if (cond_depth == cond_min_depth) { + Parse_Error(level, "if-less elif"); + return COND_PARSE; } - } else { - if (isElse) { - if (condTop == MAXIF) { - Parse_Error(level, "if-less elif"); - return (COND_INVALID); - } else if (skipIfLevel != 0) { - /* - * If skipping this conditional, just ignore the whole thing. - * If we don't, the user might be employing a variable that's - * undefined, for which there's an enclosing ifdef that - * we're skipping... - */ - return(COND_SKIP); - } - } else if (skipLine) { - /* - * Don't even try to evaluate a conditional that's not an else if - * we're skipping things... - */ - skipIfLevel += 1; - if (skipIfLevel >= MAXIF) { - Parse_Error(PARSE_FATAL, "Too many nested if's. %d max.", MAXIF); - return (COND_INVALID); - } - finalElse[condTop][skipIfLevel] = FALSE; - return(COND_SKIP); + if (cond_depth > MAXIF) + /* Error reported when we saw the .if ... */ + return COND_SKIP; + state = cond_state[cond_depth]; + if (state == SKIP_TO_ENDIF || state == ELSE_ACTIVE) { + Parse_Error(PARSE_WARNING, "extra elif"); + cond_state[cond_depth] = SKIP_TO_ENDIF; + return COND_SKIP; } - - /* - * Initialize file-global variables for parsing - */ - condDefProc = ifp->defProc; - condInvert = ifp->doNot; - - line += ifp->formlen; - if (Cond_EvalExpression(0, line, &value, 1) == COND_INVALID) - return COND_INVALID; - } - if (!isElse) { - condTop -= 1; - if (condTop < 0) { - /* - * This is the one case where we can definitely proclaim a fatal - * error. If we don't, we're hosed. - */ + if (state != SEARCH_FOR_ELIF) { + /* Either just finished the 'true' block, or already SKIP_TO_ELSE */ + cond_state[cond_depth] = SKIP_TO_ELSE; + return COND_SKIP; + } + } else { + /* Normal .if */ + if (cond_depth >= MAXIF) { + cond_depth++; Parse_Error(PARSE_FATAL, "Too many nested if's. %d max.", MAXIF); - return (COND_INVALID); + return COND_SKIP; } - finalElse[condTop][skipIfLevel] = FALSE; - } else if ((skipIfLevel != 0) || condStack[condTop]) { - /* - * If this is an else-type conditional, it should only take effect - * if its corresponding if was evaluated and FALSE. If its if was - * TRUE or skipped, we return COND_SKIP (and start skipping in case - * we weren't already), leaving the stack unmolested so later elif's - * don't screw up... - */ - skipLine = TRUE; - return (COND_SKIP); + state = cond_state[cond_depth]; + cond_depth++; + if (state > ELSE_ACTIVE) { + /* If we aren't parsing the data, treat as always false */ + cond_state[cond_depth] = SKIP_TO_ELSE; + return COND_SKIP; + } + } + + /* And evaluate the conditional expresssion */ + if (Cond_EvalExpression(ifp, line, &value, 1) == COND_INVALID) { + /* Syntax error in conditional, error message already output. */ + /* Skip everything to matching .endif */ + cond_state[cond_depth] = SKIP_TO_ELSE; + return COND_SKIP; } - condStack[condTop] = value; - skipLine = !value; - return (value ? COND_PARSE : COND_SKIP); + if (!value) { + cond_state[cond_depth] = SEARCH_FOR_ELIF; + return COND_SKIP; + } + cond_state[cond_depth] = IF_ACTIVE; + return COND_PARSE; } @@ -1402,11 +1370,24 @@ Cond_Eval(char *line) *----------------------------------------------------------------------- */ void -Cond_End(void) +Cond_restore_depth(unsigned int saved_depth) { - if (condTop != MAXIF) { - Parse_Error(PARSE_FATAL, "%d open conditional%s", MAXIF-condTop, - MAXIF-condTop == 1 ? "" : "s"); + int open_conds = cond_depth - cond_min_depth; + + if (open_conds != 0 || saved_depth > cond_depth) { + Parse_Error(PARSE_FATAL, "%d open conditional%s", open_conds, + open_conds == 1 ? "" : "s"); + cond_depth = cond_min_depth; } - condTop = MAXIF; + + cond_min_depth = saved_depth; +} + +unsigned int +Cond_save_depth(void) +{ + int depth = cond_min_depth; + + cond_min_depth = cond_depth; + return depth; }