/* $OpenPackages$ */ /* $OpenBSD: cond.c,v 1.32 2007/01/04 18:01:32 espie Exp $ */ /* $NetBSD: cond.c,v 1.7 1996/11/06 17:59:02 christos Exp $ */ /* * Copyright (c) 1988, 1989, 1990 The Regents of the University of California. * Copyright (c) 1988, 1989 by Adam de Boor * Copyright (c) 1989 by Berkeley Softworks * 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. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include #include "config.h" #include "defines.h" #include "dir.h" #include "buf.h" #include "cond.h" #include "cond_int.h" #include "condhashconsts.h" #include "error.h" #include "var.h" #include "varname.h" #include "targ.h" #include "lowparse.h" #include "str.h" #include "main.h" #include "gnode.h" #include "lst.h" #include "ohash.h" /* The parsing of conditional expressions is based on this grammar: * E -> F || E * E -> F * F -> T && F * F -> T * T -> defined(variable) * T -> make(target) * T -> exists(file) * T -> empty(varspec) * T -> target(name) * T -> symbol * T -> $(varspec) op value * T -> $(varspec) == "string" * T -> $(varspec) != "string" * T -> "string" == "string" * T -> "string" != "string" * T -> ( E ) * T -> ! T * op -> == | != | > | < | >= | <= * * 'symbol' is some other symbol to which the default function (condDefProc) * is applied. * * Tokens are scanned from the 'condExpr' string. The scanner (CondToken) * will return And for '&' and '&&', Or for '|' and '||', Not for '!', * LParen for '(', RParen for ')' and will evaluate the other terminal * symbols, using either the default function or the function given in the * terminal, and return the result as either true or False. * * All Non-Terminal functions (CondE, CondF and CondT) return Err on error. */ typedef enum { False = 0, True = 1, And, Or, Not, LParen, RParen, EndOfFile, None, Err } Token; /*- * Structures to handle elegantly the different forms of #if's. The * last two fields are stored in condInvert and condDefProc, respectively. */ static bool CondGetArg(const char **, struct Name *, const char *, bool); static bool CondDoDefined(struct Name *); static bool CondDoMake(struct Name *); static bool CondDoExists(struct Name *); static bool CondDoTarget(struct Name *); static bool CondCvtArg(const char *, double *); static Token CondToken(bool); static Token CondT(bool); static Token CondF(bool); static Token CondE(bool); static Token CondHandleVarSpec(bool); static Token CondHandleDefault(bool); static Token CondHandleComparison(char *, bool, bool); static Token CondHandleString(bool); static const char *find_cond(const char *); struct If { bool isElse; /* true for else forms */ bool doNot; /* true for embedded negation */ bool (*defProc)(struct Name *); /* function to apply */ }; static struct If ifs[] = { { false, false, CondDoDefined }, /* if, ifdef */ { false, true, CondDoDefined }, /* ifndef */ { false, false, CondDoMake }, /* ifmake */ { false, true, CondDoMake }, /* ifnmake */ { true, false, CondDoDefined }, /* elif, elifdef */ { true, true, CondDoDefined }, /* elifndef */ { true, false, CondDoMake }, /* elifmake */ { true, true, CondDoMake }, /* elifnmake */ { true, false, NULL } }; #define COND_IF_INDEX 0 #define COND_IFDEF_INDEX 0 #define COND_IFNDEF_INDEX 1 #define COND_IFMAKE_INDEX 2 #define COND_IFNMAKE_INDEX 3 #define COND_ELIF_INDEX 4 #define COND_ELIFDEF_INDEX 4 #define COND_ELIFNDEF_INDEX 5 #define COND_ELIFMAKE_INDEX 6 #define COND_ELIFNMAKE_INDEX 7 #define COND_ELSE_INDEX 8 static bool condInvert; /* Invert the default function */ static bool (*condDefProc) /* Default function to apply */ (struct Name *); static const char *condExpr; /* The expression to parse */ static Token condPushBack=None; /* Single push-back token used in * parsing */ #define MAXIF 30 /* greatest depth of #if'ing */ static struct { bool value; unsigned long lineno; const char *filename; } condStack[MAXIF]; /* Stack of conditionals */ static int condTop = MAXIF; /* Top-most conditional */ static int skipIfLevel=0; /* Depth of skipped conditionals */ static bool skipLine = false; /* Whether the parse module is skipping * lines */ static const char * find_cond(const char *p) { for (;;p++) { if (strchr(" \t)&|$", *p) != NULL) return p; } } /*- *----------------------------------------------------------------------- * CondGetArg -- * Find the argument of a built-in function. * * Results: * true if evaluation went okay * * Side Effects: * The line pointer is set to point to the closing parenthesis of the * function call. The argument is filled. *----------------------------------------------------------------------- */ static bool CondGetArg(const char **linePtr, struct Name *arg, const char *func, bool parens) /* true if arg should be bounded by parens */ { const char *cp; cp = *linePtr; if (parens) { while (*cp != '(' && *cp != '\0') cp++; if (*cp == '(') cp++; } if (*cp == '\0') { /* No arguments whatsoever. Because 'make' and 'defined' aren't really * "reserved words", we don't print a message. I think this is better * than hitting the user with a warning message every time s/he uses * the word 'make' or 'defined' at the beginning of a symbol... */ arg->s = cp; arg->e = cp; arg->tofree = false; return false; } while (*cp == ' ' || *cp == '\t') cp++; cp = VarName_Get(cp, arg, NULL, true, find_cond); while (*cp == ' ' || *cp == '\t') cp++; if (parens && *cp != ')') { Parse_Error(PARSE_WARNING, "Missing closing parenthesis for %s()", func); return false; } else if (parens) /* Advance pointer past close parenthesis. */ cp++; *linePtr = cp; return true; } /*- *----------------------------------------------------------------------- * CondDoDefined -- * Handle the 'defined' function for conditionals. * * Results: * true if the given variable is defined. *----------------------------------------------------------------------- */ static bool CondDoDefined(struct Name *arg) { if (Var_Valuei(arg->s, arg->e) != NULL) return true; else return false; } /*- *----------------------------------------------------------------------- * CondDoMake -- * Handle the 'make' function for conditionals. * * Results: * true if the given target is being made. *----------------------------------------------------------------------- */ static bool CondDoMake(struct Name *arg) { LstNode ln; for (ln = Lst_First(create); ln != NULL; ln = Lst_Adv(ln)) { char *s = (char *)Lst_Datum(ln); if (Str_Matchi(s, strchr(s, '\0'), arg->s, arg->e)) return true; } return false; } /*- *----------------------------------------------------------------------- * CondDoExists -- * See if the given file exists. * * Results: * true if the file exists and false if it does not. *----------------------------------------------------------------------- */ static bool CondDoExists(struct Name *arg) { bool result; char *path; path = Dir_FindFilei(arg->s, arg->e, dirSearchPath); if (path != NULL) { result = true; free(path); } else { result = false; } return result; } /*- *----------------------------------------------------------------------- * CondDoTarget -- * See if the given node exists and is an actual target. * * Results: * true if the node exists as a target and false if it does not. *----------------------------------------------------------------------- */ static bool CondDoTarget(struct Name *arg) { GNode *gn; gn = Targ_FindNodei(arg->s, arg->e, TARG_NOCREATE); if (gn != NULL && !OP_NOP(gn->type)) return true; else return false; } /*- *----------------------------------------------------------------------- * 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. * * Results: * Sets 'value' to double value of string. * Returns true if the string was a valid number, false o.w. * * Side Effects: * Can change 'value' even if string is not a valid number. *----------------------------------------------------------------------- */ static bool CondCvtArg(const char *str, double *value) { if (*str == '0' && str[1] == 'x') { long i; for (str += 2, i = 0; *str; str++) { int x; if (isdigit(*str)) x = *str - '0'; else if (isxdigit(*str)) x = 10 + *str - isupper(*str) ? 'A' : 'a'; else return false; i = (i << 4) + x; } *value = (double) i; return true; } else { char *eptr; *value = strtod(str, &eptr); return *eptr == '\0'; } } static Token CondHandleVarSpec(bool doEval) { char *lhs; size_t varSpecLen; bool doFree; /* Parse the variable spec and skip over it, saving its * value in lhs. */ lhs = Var_Parse(condExpr, NULL, doEval,&varSpecLen,&doFree); if (lhs == var_Error) /* Even if !doEval, we still report syntax errors, which * is what getting var_Error back with !doEval means. */ return Err; condExpr += varSpecLen; if (!isspace(*condExpr) && strchr("!=><", *condExpr) == NULL) { BUFFER buf; Buf_Init(&buf, 0); Buf_AddString(&buf, lhs); if (doFree) free(lhs); for (;*condExpr && !isspace(*condExpr); condExpr++) Buf_AddChar(&buf, *condExpr); lhs = Var_Subst(Buf_Retrieve(&buf), NULL, doEval); Buf_Destroy(&buf); doFree = true; } return CondHandleComparison(lhs, doFree, doEval); } static Token CondHandleString(bool doEval) { char *lhs; const char *begin; BUFFER buf; /* find the extent of the string */ begin = ++condExpr; while (*condExpr && *condExpr != '"') { condExpr++; } Buf_Init(&buf, 0); Buf_Addi(&buf, begin, condExpr); if (*condExpr == '"') condExpr++; lhs = Var_Subst(Buf_Retrieve(&buf), NULL, doEval); Buf_Destroy(&buf); return CondHandleComparison(lhs, true, doEval); } static Token CondHandleComparison(char *lhs, bool doFree, bool doEval) { Token t; const char *rhs; const char *op; t = Err; /* Skip whitespace to get to the operator. */ while (isspace(*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 = "!="; rhs = "0"; goto do_compare; } while (isspace(*condExpr)) condExpr++; if (*condExpr == '\0') { Parse_Error(PARSE_WARNING, "Missing right-hand-side of operator"); goto error; } rhs = condExpr; do_compare: if (*rhs == '"') { /* Doing a string comparison. Only allow == and != for * operators. */ char *string; const char *cp; int qt; BUFFER buf; do_string_compare: if ((*op != '!' && *op != '=') || op[1] != '=') { Parse_Error(PARSE_WARNING, "String comparison operator should be either == or !="); goto error; } Buf_Init(&buf, 0); qt = *rhs == '"' ? 1 : 0; for (cp = &rhs[qt]; ((qt && *cp != '"') || (!qt && strchr(" \t)", *cp) == NULL)) && *cp != '\0';) { if (*cp == '$') { size_t len; if (Var_ParseBuffer(&buf, cp, NULL, doEval, &len)) { cp += len; continue; } } else if (*cp == '\\' && cp[1] != '\0') /* Backslash escapes things -- skip over next * character, if it exists. */ cp++; Buf_AddChar(&buf, *cp++); } string = Buf_Retrieve(&buf); if (DEBUG(COND)) printf("lhs = \"%s\", rhs = \"%s\", op = %.2s\n", lhs, string, op); /* Null-terminate rhs and perform the comparison. * t is set to the result. */ if (*op == '=') t = strcmp(lhs, string) ? False : True; else t = strcmp(lhs, string) ? True : False; free(string); if (rhs == condExpr) { if (!qt && *cp == ')') condExpr = cp; else if (*cp == '\0') condExpr = cp; else condExpr = cp + 1; } } 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 *string; if (!CondCvtArg(lhs, &left)) goto do_string_compare; if (*rhs == '$') { size_t len; bool freeIt; string = Var_Parse(rhs, NULL, doEval,&len,&freeIt); if (string == var_Error) right = 0.0; else { if (!CondCvtArg(string, &right)) { if (freeIt) free(string); goto do_string_compare; } if (freeIt) free(string); if (rhs == condExpr) condExpr += len; } } else { if (!CondCvtArg(rhs, &right)) goto do_string_compare; if (rhs == condExpr) { /* Skip over the right-hand side. */ while (!isspace(*condExpr) && *condExpr != '\0') condExpr++; } } if (DEBUG(COND)) printf("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 (doFree) free(lhs); return t; } #define S(s) s, sizeof(s)-1 static struct operator { const char *s; size_t len; bool (*proc)(struct Name *); } ops[] = { {S("defined"), CondDoDefined}, {S("make"), CondDoMake}, {S("exists"), CondDoExists}, {S("target"), CondDoTarget}, {NULL, 0, NULL} }; static Token CondHandleDefault(bool doEval) { bool t; bool (*evalProc)(struct Name *); bool invert = false; struct Name arg; size_t arglen; evalProc = NULL; if (strncmp(condExpr, "empty", 5) == 0) { /* Use Var_Parse to parse the spec in parens and return * True if the resulting string is empty. */ size_t length; bool doFree; char *val; condExpr += 5; for (arglen = 0; condExpr[arglen] != '(' && condExpr[arglen] != '\0';) arglen++; if (condExpr[arglen] != '\0') { val = Var_Parse(&condExpr[arglen - 1], NULL, doEval, &length, &doFree); 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(*p); p++) continue; t = *p == '\0' ? True : False; } if (doFree) free(val); /* 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; return t; } else condExpr -= 5; } else { struct operator *op; for (op = ops; op != NULL; op++) if (strncmp(condExpr, op->s, op->len) == 0) { condExpr += op->len; if (CondGetArg(&condExpr, &arg, op->s, true)) evalProc = op->proc; else condExpr -= op->len; break; } } if (evalProc == NULL) { /* 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. */ invert = condInvert; evalProc = condDefProc; /* XXX should we ignore problems now ? */ CondGetArg(&condExpr, &arg, "", false); } /* Evaluate the argument using the set function. If invert * is true, we invert the sense of the function. */ t = (!doEval || (*evalProc)(&arg) ? (invert ? False : True) : (invert ? True : False)); VarName_Free(&arg); return t; } /*- *----------------------------------------------------------------------- * CondToken -- * Return the next token from the input. * * Results: * A Token for the next lexical token in the stream. * * Side Effects: * condPushback will be set back to None if it is used. *----------------------------------------------------------------------- */ static Token CondToken(bool doEval) { if (condPushBack != None) { Token t; t = condPushBack; 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 '\n': case '\0': return EndOfFile; case '"': return CondHandleString(doEval); case '$': return CondHandleVarSpec(doEval); default: return CondHandleDefault(doEval); } } /*- *----------------------------------------------------------------------- * CondT -- * Parse a single term in the expression. This consists of a terminal * symbol or Not and a terminal symbol (not including the binary * operators): * T -> defined(variable) | make(target) | exists(file) | symbol * T -> ! T | ( E ) * * Results: * True, False or Err. * * Side Effects: * Tokens are consumed. *----------------------------------------------------------------------- */ static Token CondT(bool doEval) { Token t; t = CondToken(doEval); if (t == EndOfFile) /* If we reached the end of the expression, the expression * is malformed... */ t = Err; else if (t == LParen) { /* T -> ( E ). */ t = CondE(doEval); if (t != Err) if (CondToken(doEval) != RParen) t = Err; } else if (t == Not) { t = CondT(doEval); if (t == True) t = False; else if (t == False) t = True; } return t; } /*- *----------------------------------------------------------------------- * CondF -- * Parse a conjunctive factor (nice name, wot?) * F -> T && F | T * * Results: * True, False or Err * * Side Effects: * Tokens are consumed. *----------------------------------------------------------------------- */ static Token CondF(bool doEval) { Token l, o; l = CondT(doEval); if (l != Err) { o = CondToken(doEval); if (o == And) { /* F -> T && F * * If T is False, the whole thing will be False, but we have to * parse the r.h.s. anyway (to throw it away). * If T is True, the result is the r.h.s., be it an Err or no. */ if (l == True) l = CondF(doEval); else (void)CondF(false); } else /* F -> T. */ condPushBack = o; } return l; } /*- *----------------------------------------------------------------------- * CondE -- * Main expression production. * E -> F || E | F * * Results: * True, False or Err. * * Side Effects: * Tokens are, of course, consumed. *----------------------------------------------------------------------- */ static Token CondE(bool doEval) { Token l, o; l = CondF(doEval); if (l != Err) { o = CondToken(doEval); if (o == Or) { /* E -> F || E * * A similar thing occurs for ||, except that here we make sure * the l.h.s. is False before we bother to evaluate the r.h.s. * Once again, if l is False, the result is the r.h.s. and once * again if l is True, we parse the r.h.s. to throw it away. */ if (l == False) l = CondE(doEval); else (void)CondE(false); } else /* E -> F. */ condPushBack = o; } return l; } /* Evaluate conditional in line. * returns COND_SKIP, COND_PARSE, COND_INVALID, COND_ISFOR, COND_ISINCLUDE, * COND_ISUNDEF. * A conditional 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) * and parenthetical groupings thereof. */ int Cond_Eval(const char *line) { /* find end of keyword */ const char *end; uint32_t k; size_t len; struct If *ifp; bool value = false; int level; /* Level at which to report errors. */ level = PARSE_FATAL; for (end = line; islower(*end); end++) ; /* quick path: recognize special targets early on */ if (*end == '.' || *end == ':') return COND_INVALID; len = end - line; k = ohash_interval(line, &end); switch(k % MAGICSLOTS2) { case K_COND_IF % MAGICSLOTS2: if (k == K_COND_IF && len == strlen(COND_IF) && strncmp(line, COND_IF, len) == 0) { ifp = ifs + COND_IF_INDEX; } else return COND_INVALID; break; case K_COND_IFDEF % MAGICSLOTS2: if (k == K_COND_IFDEF && len == strlen(COND_IFDEF) && strncmp(line, COND_IFDEF, len) == 0) { ifp = ifs + COND_IFDEF_INDEX; } else return COND_INVALID; break; case K_COND_IFNDEF % MAGICSLOTS2: if (k == K_COND_IFNDEF && len == strlen(COND_IFNDEF) && strncmp(line, COND_IFNDEF, len) == 0) { ifp = ifs + COND_IFNDEF_INDEX; } else return COND_INVALID; break; case K_COND_IFMAKE % MAGICSLOTS2: if (k == K_COND_IFMAKE && len == strlen(COND_IFMAKE) && strncmp(line, COND_IFMAKE, len) == 0) { ifp = ifs + COND_IFMAKE_INDEX; } else return COND_INVALID; break; case K_COND_IFNMAKE % MAGICSLOTS2: if (k == K_COND_IFNMAKE && len == strlen(COND_IFNMAKE) && strncmp(line, COND_IFNMAKE, len) == 0) { ifp = ifs + COND_IFNMAKE_INDEX; } else return COND_INVALID; break; case K_COND_ELIF % MAGICSLOTS2: if (k == K_COND_ELIF && len == strlen(COND_ELIF) && strncmp(line, COND_ELIF, len) == 0) { ifp = ifs + COND_ELIF_INDEX; } else return COND_INVALID; break; case K_COND_ELIFDEF % MAGICSLOTS2: if (k == K_COND_ELIFDEF && len == strlen(COND_ELIFDEF) && strncmp(line, COND_ELIFDEF, len) == 0) { ifp = ifs + COND_ELIFDEF_INDEX; } else return COND_INVALID; break; case K_COND_ELIFNDEF % MAGICSLOTS2: if (k == K_COND_ELIFNDEF && len == strlen(COND_ELIFNDEF) && strncmp(line, COND_ELIFNDEF, len) == 0) { ifp = ifs + COND_ELIFNDEF_INDEX; } else return COND_INVALID; break; case K_COND_ELIFMAKE % MAGICSLOTS2: if (k == K_COND_ELIFMAKE && len == strlen(COND_ELIFMAKE) && strncmp(line, COND_ELIFMAKE, len) == 0) { ifp = ifs + COND_ELIFMAKE_INDEX; } else return COND_INVALID; break; case K_COND_ELIFNMAKE % MAGICSLOTS2: if (k == K_COND_ELIFNMAKE && len == strlen(COND_ELIFNMAKE) && strncmp(line, COND_ELIFNMAKE, len) == 0) { ifp = ifs + COND_ELIFNMAKE_INDEX; } else return COND_INVALID; break; case K_COND_ELSE % MAGICSLOTS2: /* valid conditional whose value is the inverse * of the previous if we parsed. */ if (k == K_COND_ELSE && len == strlen(COND_ELSE) && strncmp(line, COND_ELSE, len) == 0) { if (condTop == MAXIF) { Parse_Error(level, "if-less else"); return COND_INVALID; } else if (skipIfLevel == 0) { value = !condStack[condTop].value; ifp = ifs + COND_ELSE_INDEX; } else return COND_SKIP; } else return COND_INVALID; break; case K_COND_ENDIF % MAGICSLOTS2: if (k == K_COND_ENDIF && len == strlen(COND_ENDIF) && strncmp(line, COND_ENDIF, len) == 0) { /* 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. */ if (skipIfLevel != 0) { skipIfLevel -= 1; return COND_SKIP; } else { if (condTop == MAXIF) { Parse_Error(level, "if-less endif"); return COND_INVALID; } else { skipLine = false; condTop += 1; return COND_PARSE; } } } else return COND_INVALID; break; /* Recognize other keywords there, to simplify parser's task */ case K_COND_FOR % MAGICSLOTS2: if (k == K_COND_FOR && len == strlen(COND_FOR) && strncmp(line, COND_FOR, len) == 0) return COND_ISFOR; else return COND_INVALID; case K_COND_UNDEF % MAGICSLOTS2: if (k == K_COND_UNDEF && len == strlen(COND_UNDEF) && strncmp(line, COND_UNDEF, len) == 0) return COND_ISUNDEF; else return COND_INVALID; case K_COND_INCLUDE % MAGICSLOTS2: if (k == K_COND_INCLUDE && len == strlen(COND_INCLUDE) && strncmp(line, COND_INCLUDE, len) == 0) return COND_ISINCLUDE; else return COND_INVALID; default: /* Not a valid conditional type. No error... */ return COND_INVALID; } if (ifp->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; return COND_SKIP; } if (ifp->defProc) { /* Initialize file-global variables for parsing. */ condDefProc = ifp->defProc; condInvert = ifp->doNot; line += len; while (*line == ' ' || *line == '\t') line++; condExpr = line; condPushBack = None; switch (CondE(true)) { case True: if (CondToken(true) == EndOfFile) { value = true; break; } goto err; /* FALLTHROUGH */ case False: if (CondToken(true) == EndOfFile) { value = false; break; } /* FALLTHROUGH */ case Err: err: Parse_Error(level, "Malformed conditional (%s)", line); return COND_INVALID; default: break; } } if (!ifp->isElse) condTop -= 1; else if (skipIfLevel != 0 || condStack[condTop].value) { /* 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; } if (condTop < 0) { /* This is the one case where we can definitely proclaim a fatal * error. If we don't, we're hosed. */ Parse_Error(PARSE_FATAL, "Too many nested if's. %d max.", MAXIF); condTop = 0; return COND_INVALID; } else { condStack[condTop].value = value; condStack[condTop].lineno = Parse_Getlineno(); condStack[condTop].filename = Parse_Getfilename(); skipLine = !value; return value ? COND_PARSE : COND_SKIP; } } void Cond_End(void) { int i; if (condTop != MAXIF) { Parse_Error(PARSE_FATAL, "%s%d open conditional%s", condTop == 0 ? "at least ": "", MAXIF-condTop, MAXIF-condTop == 1 ? "" : "s"); for (i = MAXIF-1; i >= condTop; i--) { fprintf(stderr, "\t at line %lu of %s\n", condStack[i].lineno, condStack[i].filename); } } condTop = MAXIF; }