1 /* $NetBSD: cond.c,v 1.308 2021/12/27 21:21:17 rillig Exp $ */ 2 3 /* 4 * Copyright (c) 1988, 1989, 1990 The Regents of the University of California. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to Berkeley by 8 * Adam de Boor. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. Neither the name of the University nor the names of its contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 */ 34 35 /* 36 * Copyright (c) 1988, 1989 by Adam de Boor 37 * Copyright (c) 1989 by Berkeley Softworks 38 * All rights reserved. 39 * 40 * This code is derived from software contributed to Berkeley by 41 * Adam de Boor. 42 * 43 * Redistribution and use in source and binary forms, with or without 44 * modification, are permitted provided that the following conditions 45 * are met: 46 * 1. Redistributions of source code must retain the above copyright 47 * notice, this list of conditions and the following disclaimer. 48 * 2. Redistributions in binary form must reproduce the above copyright 49 * notice, this list of conditions and the following disclaimer in the 50 * documentation and/or other materials provided with the distribution. 51 * 3. All advertising materials mentioning features or use of this software 52 * must display the following acknowledgement: 53 * This product includes software developed by the University of 54 * California, Berkeley and its contributors. 55 * 4. Neither the name of the University nor the names of its contributors 56 * may be used to endorse or promote products derived from this software 57 * without specific prior written permission. 58 * 59 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 60 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 61 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 62 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 63 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 64 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 65 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 66 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 67 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 68 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 69 * SUCH DAMAGE. 70 */ 71 72 /* 73 * Handling of conditionals in a makefile. 74 * 75 * Interface: 76 * Cond_EvalLine Evaluate the conditional directive, such as 77 * '.if <cond>', '.elifnmake <cond>', '.else', '.endif'. 78 * 79 * Cond_EvalCondition 80 * Evaluate the conditional, which is either the argument 81 * of one of the .if directives or the condition in a 82 * ':?then:else' variable modifier. 83 * 84 * Cond_save_depth 85 * Cond_restore_depth 86 * Save and restore the nesting of the conditions, at 87 * the start and end of including another makefile, to 88 * ensure that in each makefile the conditional 89 * directives are well-balanced. 90 */ 91 92 #include <errno.h> 93 94 #include "make.h" 95 #include "dir.h" 96 97 /* "@(#)cond.c 8.2 (Berkeley) 1/2/94" */ 98 MAKE_RCSID("$NetBSD: cond.c,v 1.308 2021/12/27 21:21:17 rillig Exp $"); 99 100 /* 101 * The parsing of conditional expressions is based on this grammar: 102 * Or -> And ('||' And)* 103 * And -> Term ('&&' Term)* 104 * Term -> Function '(' Argument ')' 105 * Term -> Leaf Operator Leaf 106 * Term -> Leaf 107 * Term -> '(' Or ')' 108 * Term -> '!' Term 109 * Leaf -> "string" 110 * Leaf -> Number 111 * Leaf -> VariableExpression 112 * Leaf -> Symbol 113 * Operator -> '==' | '!=' | '>' | '<' | '>=' | '<=' 114 * 115 * 'Symbol' is an unquoted string literal to which the default function is 116 * applied. 117 * 118 * The tokens are scanned by CondToken, which returns: 119 * TOK_AND for '&&' 120 * TOK_OR for '||' 121 * TOK_NOT for '!' 122 * TOK_LPAREN for '(' 123 * TOK_RPAREN for ')' 124 * 125 * Other terminal symbols are evaluated using either the default function or 126 * the function given in the terminal, they return either TOK_TRUE, TOK_FALSE 127 * or TOK_ERROR. 128 */ 129 typedef enum Token { 130 TOK_FALSE, TOK_TRUE, TOK_AND, TOK_OR, TOK_NOT, 131 TOK_LPAREN, TOK_RPAREN, TOK_EOF, TOK_NONE, TOK_ERROR 132 } Token; 133 134 typedef enum CondResult { 135 CR_FALSE, CR_TRUE, CR_ERROR 136 } CondResult; 137 138 typedef enum ComparisonOp { 139 LT, LE, GT, GE, EQ, NE 140 } ComparisonOp; 141 142 typedef struct CondParser { 143 144 /* 145 * The plain '.if ${VAR}' evaluates to true if the value of the 146 * expression has length > 0. The other '.if' variants delegate 147 * to evalBare instead. 148 */ 149 bool plain; 150 151 /* The function to apply on unquoted bare words. */ 152 bool (*evalBare)(const char *); 153 bool negateEvalBare; 154 155 /* 156 * Whether the left-hand side of a comparison may be an unquoted 157 * string. This is allowed for expressions of the form 158 * ${condition:?:}, see ApplyModifier_IfElse. Such a condition is 159 * expanded before it is evaluated, due to ease of implementation. 160 * This means that at the point where the condition is evaluated, 161 * make cannot know anymore whether the left-hand side had originally 162 * been a variable expression or a plain word. 163 * 164 * In all other contexts, the left-hand side must either be a 165 * variable expression, a quoted string or a number. 166 */ 167 bool leftUnquotedOK; 168 169 const char *p; /* The remaining condition to parse */ 170 Token curr; /* Single push-back token used in parsing */ 171 172 /* 173 * Whether an error message has already been printed for this 174 * condition. The first available error message is usually the most 175 * specific one, therefore it makes sense to suppress the standard 176 * "Malformed conditional" message. 177 */ 178 bool printedError; 179 } CondParser; 180 181 static CondResult CondParser_Or(CondParser *par, bool); 182 183 static unsigned int cond_depth = 0; /* current .if nesting level */ 184 static unsigned int cond_min_depth = 0; /* depth at makefile open */ 185 186 /* Names for ComparisonOp. */ 187 static const char opname[][3] = { "<", "<=", ">", ">=", "==", "!=" }; 188 189 static bool 190 is_token(const char *str, const char *tok, unsigned char len) 191 { 192 return strncmp(str, tok, (size_t)len) == 0 && !ch_isalpha(str[len]); 193 } 194 195 static Token 196 ToToken(bool cond) 197 { 198 return cond ? TOK_TRUE : TOK_FALSE; 199 } 200 201 static void 202 CondParser_SkipWhitespace(CondParser *par) 203 { 204 cpp_skip_whitespace(&par->p); 205 } 206 207 /* 208 * Parse a single word, taking into account balanced parentheses as well as 209 * embedded expressions. Used for the argument of a built-in function as 210 * well as for bare words, which are then passed to the default function. 211 * 212 * Arguments: 213 * *pp initially points at the '(', 214 * upon successful return it points right after the ')'. 215 * 216 * *out_arg receives the argument as string. 217 * 218 * func says whether the argument belongs to an actual function, or 219 * NULL when parsing a bare word. 220 * 221 * Return the length of the argument, or an ambiguous 0 on error. 222 */ 223 static size_t 224 ParseWord(CondParser *par, const char **pp, bool doEval, const char *func, 225 char **out_arg) 226 { 227 const char *p = *pp; 228 Buffer argBuf; 229 int paren_depth; 230 size_t argLen; 231 232 if (func != NULL) 233 p++; /* Skip opening '(' - verified by caller */ 234 235 cpp_skip_hspace(&p); 236 237 Buf_InitSize(&argBuf, 16); 238 239 paren_depth = 0; 240 for (;;) { 241 char ch = *p; 242 if (ch == '\0' || ch == ' ' || ch == '\t') 243 break; 244 if ((ch == '&' || ch == '|') && paren_depth == 0) 245 break; 246 if (*p == '$') { 247 /* 248 * Parse the variable expression and install it as 249 * part of the argument if it's valid. We tell 250 * Var_Parse to complain on an undefined variable, 251 * (XXX: but Var_Parse ignores that request) 252 * so we don't need to do it. Nor do we return an 253 * error, though perhaps we should. 254 */ 255 VarEvalMode emode = doEval 256 ? VARE_UNDEFERR 257 : VARE_PARSE_ONLY; 258 FStr nestedVal; 259 (void)Var_Parse(&p, SCOPE_CMDLINE, emode, &nestedVal); 260 /* TODO: handle errors */ 261 Buf_AddStr(&argBuf, nestedVal.str); 262 FStr_Done(&nestedVal); 263 continue; 264 } 265 if (ch == '(') 266 paren_depth++; 267 else if (ch == ')' && --paren_depth < 0) 268 break; 269 Buf_AddByte(&argBuf, *p); 270 p++; 271 } 272 273 argLen = argBuf.len; 274 *out_arg = Buf_DoneData(&argBuf); 275 276 cpp_skip_hspace(&p); 277 278 if (func != NULL && *p++ != ')') { 279 Parse_Error(PARSE_FATAL, 280 "Missing closing parenthesis for %s()", func); 281 par->printedError = true; 282 return 0; 283 } 284 285 *pp = p; 286 return argLen; 287 } 288 289 /* Test whether the given variable is defined. */ 290 static bool 291 FuncDefined(const char *arg) 292 { 293 FStr value = Var_Value(SCOPE_CMDLINE, arg); 294 bool result = value.str != NULL; 295 FStr_Done(&value); 296 return result; 297 } 298 299 /* See if the given target is requested to be made. */ 300 static bool 301 FuncMake(const char *arg) 302 { 303 StringListNode *ln; 304 305 for (ln = opts.create.first; ln != NULL; ln = ln->next) 306 if (Str_Match(ln->datum, arg)) 307 return true; 308 return false; 309 } 310 311 /* See if the given file exists. */ 312 static bool 313 FuncExists(const char *arg) 314 { 315 bool result; 316 char *path; 317 318 path = Dir_FindFile(arg, &dirSearchPath); 319 DEBUG2(COND, "exists(%s) result is \"%s\"\n", 320 arg, path != NULL ? path : ""); 321 result = path != NULL; 322 free(path); 323 return result; 324 } 325 326 /* See if the given node exists and is an actual target. */ 327 static bool 328 FuncTarget(const char *arg) 329 { 330 GNode *gn = Targ_FindNode(arg); 331 return gn != NULL && GNode_IsTarget(gn); 332 } 333 334 /* 335 * See if the given node exists and is an actual target with commands 336 * associated with it. 337 */ 338 static bool 339 FuncCommands(const char *arg) 340 { 341 GNode *gn = Targ_FindNode(arg); 342 return gn != NULL && GNode_IsTarget(gn) && !Lst_IsEmpty(&gn->commands); 343 } 344 345 /* 346 * Convert the given number into a double. 347 * We try a base 10 or 16 integer conversion first, if that fails 348 * then we try a floating point conversion instead. 349 * 350 * Results: 351 * Returns true if the conversion succeeded. 352 * Sets 'out_value' to the converted number. 353 */ 354 static bool 355 TryParseNumber(const char *str, double *out_value) 356 { 357 char *end; 358 unsigned long ul_val; 359 double dbl_val; 360 361 if (str[0] == '\0') { /* XXX: why is an empty string a number? */ 362 *out_value = 0.0; 363 return true; 364 } 365 366 errno = 0; 367 ul_val = strtoul(str, &end, str[1] == 'x' ? 16 : 10); 368 if (*end == '\0' && errno != ERANGE) { 369 *out_value = str[0] == '-' ? -(double)-ul_val : (double)ul_val; 370 return true; 371 } 372 373 if (*end != '\0' && *end != '.' && *end != 'e' && *end != 'E') 374 return false; /* skip the expensive strtod call */ 375 dbl_val = strtod(str, &end); 376 if (*end != '\0') 377 return false; 378 379 *out_value = dbl_val; 380 return true; 381 } 382 383 static bool 384 is_separator(char ch) 385 { 386 return ch == '\0' || ch_isspace(ch) || ch == '!' || ch == '=' || 387 ch == '>' || ch == '<' || ch == ')' /* but not '(' */; 388 } 389 390 /* 391 * In a quoted or unquoted string literal or a number, parse a variable 392 * expression. 393 * 394 * Example: .if x${CENTER}y == "${PREFIX}${SUFFIX}" || 0x${HEX} 395 */ 396 static bool 397 CondParser_StringExpr(CondParser *par, const char *start, 398 bool doEval, bool quoted, 399 Buffer *buf, FStr *inout_str) 400 { 401 VarEvalMode emode; 402 const char *p; 403 bool atStart; 404 VarParseResult parseResult; 405 406 emode = doEval && quoted ? VARE_WANTRES 407 : doEval ? VARE_UNDEFERR 408 : VARE_PARSE_ONLY; 409 410 p = par->p; 411 atStart = p == start; 412 parseResult = Var_Parse(&p, SCOPE_CMDLINE, emode, inout_str); 413 /* TODO: handle errors */ 414 if (inout_str->str == var_Error) { 415 if (parseResult == VPR_ERR) { 416 /* 417 * FIXME: Even if an error occurs, there is no 418 * guarantee that it is reported. 419 * 420 * See cond-token-plain.mk $$$$$$$$. 421 */ 422 par->printedError = true; 423 } 424 /* 425 * XXX: Can there be any situation in which a returned 426 * var_Error needs to be freed? 427 */ 428 FStr_Done(inout_str); 429 /* 430 * Even if !doEval, we still report syntax errors, which is 431 * what getting var_Error back with !doEval means. 432 */ 433 *inout_str = FStr_InitRefer(NULL); 434 return false; 435 } 436 par->p = p; 437 438 /* 439 * If the '$' started the string literal (which means no quotes), and 440 * the variable expression is followed by a space, looks like a 441 * comparison operator or is the end of the expression, we are done. 442 */ 443 if (atStart && is_separator(par->p[0])) 444 return false; 445 446 Buf_AddStr(buf, inout_str->str); 447 FStr_Done(inout_str); 448 *inout_str = FStr_InitRefer(NULL); /* not finished yet */ 449 return true; 450 } 451 452 /* 453 * Parse a string from a variable expression or an optionally quoted string, 454 * on the left-hand and right-hand sides of comparisons. 455 * 456 * Results: 457 * Returns the string without any enclosing quotes, or NULL on error. 458 * Sets out_quoted if the leaf was a quoted string literal. 459 */ 460 static void 461 CondParser_Leaf(CondParser *par, bool doEval, bool unquotedOK, 462 FStr *out_str, bool *out_quoted) 463 { 464 Buffer buf; 465 FStr str; 466 bool quoted; 467 const char *start; 468 469 Buf_Init(&buf); 470 str = FStr_InitRefer(NULL); 471 *out_quoted = quoted = par->p[0] == '"'; 472 start = par->p; 473 if (quoted) 474 par->p++; 475 476 while (par->p[0] != '\0' && str.str == NULL) { 477 switch (par->p[0]) { 478 case '\\': 479 par->p++; 480 if (par->p[0] != '\0') { 481 Buf_AddByte(&buf, par->p[0]); 482 par->p++; 483 } 484 continue; 485 case '"': 486 par->p++; 487 if (quoted) 488 goto got_str; /* skip the closing quote */ 489 Buf_AddByte(&buf, '"'); 490 continue; 491 case ')': /* see is_separator */ 492 case '!': 493 case '=': 494 case '>': 495 case '<': 496 case ' ': 497 case '\t': 498 if (!quoted) 499 goto got_str; 500 Buf_AddByte(&buf, par->p[0]); 501 par->p++; 502 continue; 503 case '$': 504 if (!CondParser_StringExpr(par, 505 start, doEval, quoted, &buf, &str)) 506 goto cleanup; 507 continue; 508 default: 509 if (!unquotedOK && !quoted && *start != '$' && 510 !ch_isdigit(*start)) { 511 /* 512 * The left-hand side must be quoted, 513 * a variable expression or a number. 514 */ 515 str = FStr_InitRefer(NULL); 516 goto cleanup; 517 } 518 Buf_AddByte(&buf, par->p[0]); 519 par->p++; 520 continue; 521 } 522 } 523 got_str: 524 str = FStr_InitOwn(buf.data); 525 buf.data = NULL; 526 cleanup: 527 Buf_Done(&buf); 528 *out_str = str; 529 } 530 531 static bool 532 EvalBare(const CondParser *par, const char *arg) 533 { 534 bool res = par->evalBare(arg); 535 return par->negateEvalBare ? !res : res; 536 } 537 538 /* 539 * Evaluate a "comparison without operator", such as in ".if ${VAR}" or 540 * ".if 0". 541 */ 542 static bool 543 EvalNotEmpty(CondParser *par, const char *value, bool quoted) 544 { 545 double num; 546 547 /* For .ifxxx "...", check for non-empty string. */ 548 if (quoted) 549 return value[0] != '\0'; 550 551 /* For .ifxxx <number>, compare against zero */ 552 if (TryParseNumber(value, &num)) 553 return num != 0.0; 554 555 /* 556 * For .if ${...}, check for non-empty string. This is different 557 * from the evaluation function from that .if variant, which would 558 * test whether a variable of the given name were defined. 559 */ 560 /* 561 * XXX: Whitespace should count as empty, just as in 562 * CondParser_FuncCallEmpty. 563 */ 564 if (par->plain) 565 return value[0] != '\0'; 566 567 return EvalBare(par, value); 568 } 569 570 /* Evaluate a numerical comparison, such as in ".if ${VAR} >= 9". */ 571 static bool 572 EvalCompareNum(double lhs, ComparisonOp op, double rhs) 573 { 574 DEBUG3(COND, "lhs = %f, rhs = %f, op = %.2s\n", lhs, rhs, opname[op]); 575 576 switch (op) { 577 case LT: 578 return lhs < rhs; 579 case LE: 580 return lhs <= rhs; 581 case GT: 582 return lhs > rhs; 583 case GE: 584 return lhs >= rhs; 585 case NE: 586 return lhs != rhs; 587 default: 588 return lhs == rhs; 589 } 590 } 591 592 static Token 593 EvalCompareStr(CondParser *par, const char *lhs, 594 ComparisonOp op, const char *rhs) 595 { 596 if (op != EQ && op != NE) { 597 Parse_Error(PARSE_FATAL, 598 "String comparison operator must be either == or !="); 599 par->printedError = true; 600 return TOK_ERROR; 601 } 602 603 DEBUG3(COND, "lhs = \"%s\", rhs = \"%s\", op = %.2s\n", 604 lhs, rhs, opname[op]); 605 return ToToken((op == EQ) == (strcmp(lhs, rhs) == 0)); 606 } 607 608 /* Evaluate a comparison, such as "${VAR} == 12345". */ 609 static Token 610 EvalCompare(CondParser *par, const char *lhs, bool lhsQuoted, 611 ComparisonOp op, const char *rhs, bool rhsQuoted) 612 { 613 double left, right; 614 615 if (!rhsQuoted && !lhsQuoted) 616 if (TryParseNumber(lhs, &left) && TryParseNumber(rhs, &right)) 617 return ToToken(EvalCompareNum(left, op, right)); 618 619 return EvalCompareStr(par, lhs, op, rhs); 620 } 621 622 static bool 623 CondParser_ComparisonOp(CondParser *par, ComparisonOp *out_op) 624 { 625 const char *p = par->p; 626 627 if (p[0] == '<' && p[1] == '=') 628 return par->p += 2, *out_op = LE, true; 629 if (p[0] == '<') 630 return par->p += 1, *out_op = LT, true; 631 if (p[0] == '>' && p[1] == '=') 632 return par->p += 2, *out_op = GE, true; 633 if (p[0] == '>') 634 return par->p += 1, *out_op = GT, true; 635 if (p[0] == '=' && p[1] == '=') 636 return par->p += 2, *out_op = EQ, true; 637 if (p[0] == '!' && p[1] == '=') 638 return par->p += 2, *out_op = NE, true; 639 return false; 640 } 641 642 /* 643 * Parse a comparison condition such as: 644 * 645 * 0 646 * ${VAR:Mpattern} 647 * ${VAR} == value 648 * ${VAR:U0} < 12345 649 */ 650 static Token 651 CondParser_Comparison(CondParser *par, bool doEval) 652 { 653 Token t = TOK_ERROR; 654 FStr lhs, rhs; 655 ComparisonOp op; 656 bool lhsQuoted, rhsQuoted; 657 658 CondParser_Leaf(par, doEval, par->leftUnquotedOK, &lhs, &lhsQuoted); 659 if (lhs.str == NULL) 660 goto done_lhs; 661 662 CondParser_SkipWhitespace(par); 663 664 if (!CondParser_ComparisonOp(par, &op)) { 665 /* Unknown operator, compare against an empty string or 0. */ 666 t = ToToken(doEval && EvalNotEmpty(par, lhs.str, lhsQuoted)); 667 goto done_lhs; 668 } 669 670 CondParser_SkipWhitespace(par); 671 672 if (par->p[0] == '\0') { 673 Parse_Error(PARSE_FATAL, 674 "Missing right-hand side of operator '%s'", opname[op]); 675 par->printedError = true; 676 goto done_lhs; 677 } 678 679 CondParser_Leaf(par, doEval, true, &rhs, &rhsQuoted); 680 if (rhs.str == NULL) 681 goto done_rhs; 682 683 if (!doEval) { 684 t = TOK_FALSE; 685 goto done_rhs; 686 } 687 688 t = EvalCompare(par, lhs.str, lhsQuoted, op, rhs.str, rhsQuoted); 689 690 done_rhs: 691 FStr_Done(&rhs); 692 done_lhs: 693 FStr_Done(&lhs); 694 return t; 695 } 696 697 /* 698 * The argument to empty() is a variable name, optionally followed by 699 * variable modifiers. 700 */ 701 static bool 702 CondParser_FuncCallEmpty(CondParser *par, bool doEval, Token *out_token) 703 { 704 const char *cp = par->p; 705 Token tok; 706 FStr val; 707 708 if (!is_token(cp, "empty", 5)) 709 return false; 710 cp += 5; 711 712 cpp_skip_whitespace(&cp); 713 if (*cp != '(') 714 return false; 715 716 cp--; /* Make cp[1] point to the '('. */ 717 (void)Var_Parse(&cp, SCOPE_CMDLINE, 718 doEval ? VARE_WANTRES : VARE_PARSE_ONLY, &val); 719 /* TODO: handle errors */ 720 721 if (val.str == var_Error) 722 tok = TOK_ERROR; 723 else { 724 cpp_skip_whitespace(&val.str); 725 tok = val.str[0] != '\0' && doEval ? TOK_FALSE : TOK_TRUE; 726 } 727 728 FStr_Done(&val); 729 *out_token = tok; 730 par->p = cp; 731 return true; 732 } 733 734 /* Parse a function call expression, such as 'defined(${file})'. */ 735 static bool 736 CondParser_FuncCall(CondParser *par, bool doEval, Token *out_token) 737 { 738 static const struct fn_def { 739 const char fn_name[9]; 740 unsigned char fn_name_len; 741 bool (*fn_eval)(const char *); 742 } fns[] = { 743 { "defined", 7, FuncDefined }, 744 { "make", 4, FuncMake }, 745 { "exists", 6, FuncExists }, 746 { "target", 6, FuncTarget }, 747 { "commands", 8, FuncCommands } 748 }; 749 const struct fn_def *fn; 750 char *arg = NULL; 751 size_t arglen; 752 const char *cp = par->p; 753 const struct fn_def *last_fn = fns + sizeof fns / sizeof fns[0] - 1; 754 755 for (fn = fns; !is_token(cp, fn->fn_name, fn->fn_name_len); fn++) 756 if (fn == last_fn) 757 return false; 758 759 cp += fn->fn_name_len; 760 cpp_skip_whitespace(&cp); 761 if (*cp != '(') 762 return false; 763 764 arglen = ParseWord(par, &cp, doEval, fn->fn_name, &arg); 765 *out_token = ToToken(arglen != 0 && (!doEval || fn->fn_eval(arg))); 766 767 free(arg); 768 par->p = cp; 769 return true; 770 } 771 772 /* 773 * Parse a comparison that neither starts with '"' nor '$', such as the 774 * unusual 'bare == right' or '3 == ${VAR}', or a simple leaf without 775 * operator, which is a number, a variable expression or a string literal. 776 * 777 * TODO: Can this be merged into CondParser_Comparison? 778 */ 779 static Token 780 CondParser_ComparisonOrLeaf(CondParser *par, bool doEval) 781 { 782 Token t; 783 char *arg = NULL; 784 const char *cp; 785 const char *cp1; 786 787 /* Push anything numeric through the compare expression */ 788 cp = par->p; 789 if (ch_isdigit(cp[0]) || cp[0] == '-' || cp[0] == '+') 790 return CondParser_Comparison(par, doEval); 791 792 /* 793 * Most likely we have a naked token to apply the default function to. 794 * However ".if a == b" gets here when the "a" is unquoted and doesn't 795 * start with a '$'. This surprises people. 796 * If what follows the function argument is a '=' or '!' then the 797 * syntax would be invalid if we did "defined(a)" - so instead treat 798 * as an expression. 799 */ 800 /* 801 * XXX: Is it possible to have a variable expression evaluated twice 802 * at this point? 803 */ 804 (void)ParseWord(par, &cp, doEval, NULL, &arg); 805 cp1 = cp; 806 cpp_skip_whitespace(&cp1); 807 if (*cp1 == '=' || *cp1 == '!' || *cp1 == '<' || *cp1 == '>') 808 return CondParser_Comparison(par, doEval); 809 par->p = cp; 810 811 /* 812 * Evaluate the argument using the default function. 813 * This path always treats .if as .ifdef. To get here, the character 814 * after .if must have been taken literally, so the argument cannot 815 * be empty - even if it contained a variable expansion. 816 */ 817 t = ToToken(!doEval || EvalBare(par, arg)); 818 free(arg); 819 return t; 820 } 821 822 /* Return the next token or comparison result from the parser. */ 823 static Token 824 CondParser_Token(CondParser *par, bool doEval) 825 { 826 Token t; 827 828 t = par->curr; 829 if (t != TOK_NONE) { 830 par->curr = TOK_NONE; 831 return t; 832 } 833 834 cpp_skip_hspace(&par->p); 835 836 switch (par->p[0]) { 837 838 case '(': 839 par->p++; 840 return TOK_LPAREN; 841 842 case ')': 843 par->p++; 844 return TOK_RPAREN; 845 846 case '|': 847 par->p++; 848 if (par->p[0] == '|') 849 par->p++; 850 else if (opts.strict) { 851 Parse_Error(PARSE_FATAL, "Unknown operator '|'"); 852 par->printedError = true; 853 return TOK_ERROR; 854 } 855 return TOK_OR; 856 857 case '&': 858 par->p++; 859 if (par->p[0] == '&') 860 par->p++; 861 else if (opts.strict) { 862 Parse_Error(PARSE_FATAL, "Unknown operator '&'"); 863 par->printedError = true; 864 return TOK_ERROR; 865 } 866 return TOK_AND; 867 868 case '!': 869 par->p++; 870 return TOK_NOT; 871 872 case '#': /* XXX: see unit-tests/cond-token-plain.mk */ 873 case '\n': /* XXX: why should this end the condition? */ 874 /* Probably obsolete now, from 1993-03-21. */ 875 case '\0': 876 return TOK_EOF; 877 878 case '"': 879 case '$': 880 return CondParser_Comparison(par, doEval); 881 882 default: 883 if (CondParser_FuncCallEmpty(par, doEval, &t)) 884 return t; 885 if (CondParser_FuncCall(par, doEval, &t)) 886 return t; 887 return CondParser_ComparisonOrLeaf(par, doEval); 888 } 889 } 890 891 /* Skip the next token if it equals t. */ 892 static bool 893 CondParser_Skip(CondParser *par, Token t) 894 { 895 Token actual; 896 897 actual = CondParser_Token(par, false); 898 if (actual == t) 899 return true; 900 901 assert(par->curr == TOK_NONE); 902 assert(actual != TOK_NONE); 903 par->curr = actual; 904 return false; 905 } 906 907 /* 908 * Term -> '(' Or ')' 909 * Term -> '!' Term 910 * Term -> Leaf Operator Leaf 911 * Term -> Leaf 912 */ 913 static CondResult 914 CondParser_Term(CondParser *par, bool doEval) 915 { 916 CondResult res; 917 Token t; 918 919 t = CondParser_Token(par, doEval); 920 if (t == TOK_TRUE) 921 return CR_TRUE; 922 if (t == TOK_FALSE) 923 return CR_FALSE; 924 925 if (t == TOK_LPAREN) { 926 res = CondParser_Or(par, doEval); 927 if (res == CR_ERROR) 928 return CR_ERROR; 929 if (CondParser_Token(par, doEval) != TOK_RPAREN) 930 return CR_ERROR; 931 return res; 932 } 933 934 if (t == TOK_NOT) { 935 res = CondParser_Term(par, doEval); 936 if (res == CR_TRUE) 937 res = CR_FALSE; 938 else if (res == CR_FALSE) 939 res = CR_TRUE; 940 return res; 941 } 942 943 return CR_ERROR; 944 } 945 946 /* 947 * And -> Term ('&&' Term)* 948 */ 949 static CondResult 950 CondParser_And(CondParser *par, bool doEval) 951 { 952 CondResult res, rhs; 953 954 res = CR_TRUE; 955 do { 956 if ((rhs = CondParser_Term(par, doEval)) == CR_ERROR) 957 return CR_ERROR; 958 if (rhs == CR_FALSE) { 959 res = CR_FALSE; 960 doEval = false; 961 } 962 } while (CondParser_Skip(par, TOK_AND)); 963 964 return res; 965 } 966 967 /* 968 * Or -> And ('||' And)* 969 */ 970 static CondResult 971 CondParser_Or(CondParser *par, bool doEval) 972 { 973 CondResult res, rhs; 974 975 res = CR_FALSE; 976 do { 977 if ((rhs = CondParser_And(par, doEval)) == CR_ERROR) 978 return CR_ERROR; 979 if (rhs == CR_TRUE) { 980 res = CR_TRUE; 981 doEval = false; 982 } 983 } while (CondParser_Skip(par, TOK_OR)); 984 985 return res; 986 } 987 988 static CondEvalResult 989 CondParser_Eval(CondParser *par, bool *out_value) 990 { 991 CondResult res; 992 993 DEBUG1(COND, "CondParser_Eval: %s\n", par->p); 994 995 res = CondParser_Or(par, true); 996 if (res == CR_ERROR) 997 return COND_INVALID; 998 999 if (CondParser_Token(par, false) != TOK_EOF) 1000 return COND_INVALID; 1001 1002 *out_value = res == CR_TRUE; 1003 return COND_PARSE; 1004 } 1005 1006 /* 1007 * Evaluate the condition, including any side effects from the variable 1008 * expressions in the condition. The condition consists of &&, ||, !, 1009 * function(arg), comparisons and parenthetical groupings thereof. 1010 * 1011 * Results: 1012 * COND_PARSE if the condition was valid grammatically 1013 * COND_INVALID if not a valid conditional. 1014 * 1015 * *out_value is set to the boolean value of the condition 1016 */ 1017 static CondEvalResult 1018 CondEvalExpression(const char *cond, bool *out_value, bool plain, 1019 bool (*evalBare)(const char *), bool negate, 1020 bool eprint, bool leftUnquotedOK) 1021 { 1022 CondParser par; 1023 CondEvalResult rval; 1024 1025 cpp_skip_hspace(&cond); 1026 1027 par.plain = plain; 1028 par.evalBare = evalBare; 1029 par.negateEvalBare = negate; 1030 par.leftUnquotedOK = leftUnquotedOK; 1031 par.p = cond; 1032 par.curr = TOK_NONE; 1033 par.printedError = false; 1034 1035 rval = CondParser_Eval(&par, out_value); 1036 1037 if (rval == COND_INVALID && eprint && !par.printedError) 1038 Parse_Error(PARSE_FATAL, "Malformed conditional (%s)", cond); 1039 1040 return rval; 1041 } 1042 1043 /* 1044 * Evaluate a condition in a :? modifier, such as 1045 * ${"${VAR}" == value:?yes:no}. 1046 */ 1047 CondEvalResult 1048 Cond_EvalCondition(const char *cond, bool *out_value) 1049 { 1050 return CondEvalExpression(cond, out_value, true, 1051 FuncDefined, false, false, true); 1052 } 1053 1054 static bool 1055 IsEndif(const char *p) 1056 { 1057 return p[0] == 'e' && p[1] == 'n' && p[2] == 'd' && 1058 p[3] == 'i' && p[4] == 'f' && !ch_isalpha(p[5]); 1059 } 1060 1061 static bool 1062 DetermineKindOfConditional(const char **pp, bool *out_plain, 1063 bool (**out_evalBare)(const char *), 1064 bool *out_negate) 1065 { 1066 const char *p = *pp; 1067 1068 p += 2; 1069 *out_plain = false; 1070 *out_evalBare = FuncDefined; 1071 *out_negate = false; 1072 if (*p == 'n') { 1073 p++; 1074 *out_negate = true; 1075 } 1076 if (is_token(p, "def", 3)) { /* .ifdef and .ifndef */ 1077 p += 3; 1078 } else if (is_token(p, "make", 4)) { /* .ifmake and .ifnmake */ 1079 p += 4; 1080 *out_evalBare = FuncMake; 1081 } else if (is_token(p, "", 0) && !*out_negate) { /* plain .if */ 1082 *out_plain = true; 1083 } else { 1084 /* 1085 * TODO: Add error message about unknown directive, 1086 * since there is no other known directive that starts 1087 * with 'el' or 'if'. 1088 * 1089 * Example: .elifx 123 1090 */ 1091 return false; 1092 } 1093 1094 *pp = p; 1095 return true; 1096 } 1097 1098 /* 1099 * Evaluate the conditional directive in the line, which is one of: 1100 * 1101 * .if <cond> 1102 * .ifmake <cond> 1103 * .ifnmake <cond> 1104 * .ifdef <cond> 1105 * .ifndef <cond> 1106 * .elif <cond> 1107 * .elifmake <cond> 1108 * .elifnmake <cond> 1109 * .elifdef <cond> 1110 * .elifndef <cond> 1111 * .else 1112 * .endif 1113 * 1114 * In these directives, <cond> consists of &&, ||, !, function(arg), 1115 * comparisons, expressions, bare words, numbers and strings, and 1116 * parenthetical groupings thereof. 1117 * 1118 * Results: 1119 * COND_PARSE to continue parsing the lines that follow the 1120 * conditional (when <cond> evaluates to true) 1121 * COND_SKIP to skip the lines after the conditional 1122 * (when <cond> evaluates to false, or when a previous 1123 * branch has already been taken) 1124 * COND_INVALID if the conditional was not valid, either because of 1125 * a syntax error or because some variable was undefined 1126 * or because the condition could not be evaluated 1127 */ 1128 CondEvalResult 1129 Cond_EvalLine(const char *line) 1130 { 1131 typedef enum IfState { 1132 1133 /* None of the previous <cond> evaluated to true. */ 1134 IFS_INITIAL = 0, 1135 1136 /* 1137 * The previous <cond> evaluated to true. The lines following 1138 * this condition are interpreted. 1139 */ 1140 IFS_ACTIVE = 1 << 0, 1141 1142 /* The previous directive was an '.else'. */ 1143 IFS_SEEN_ELSE = 1 << 1, 1144 1145 /* One of the previous <cond> evaluated to true. */ 1146 IFS_WAS_ACTIVE = 1 << 2 1147 1148 } IfState; 1149 1150 static enum IfState *cond_states = NULL; 1151 static unsigned int cond_states_cap = 128; 1152 1153 bool plain; 1154 bool (*evalBare)(const char *); 1155 bool negate; 1156 bool isElif; 1157 bool value; 1158 IfState state; 1159 const char *p = line; 1160 1161 if (cond_states == NULL) { 1162 cond_states = bmake_malloc( 1163 cond_states_cap * sizeof *cond_states); 1164 cond_states[0] = IFS_ACTIVE; 1165 } 1166 1167 p++; /* skip the leading '.' */ 1168 cpp_skip_hspace(&p); 1169 1170 if (IsEndif(p)) { /* It is an '.endif'. */ 1171 if (p[5] != '\0') { 1172 Parse_Error(PARSE_FATAL, 1173 "The .endif directive does not take arguments"); 1174 } 1175 1176 if (cond_depth == cond_min_depth) { 1177 Parse_Error(PARSE_FATAL, "if-less endif"); 1178 return COND_PARSE; 1179 } 1180 1181 /* Return state for previous conditional */ 1182 cond_depth--; 1183 return cond_states[cond_depth] & IFS_ACTIVE 1184 ? COND_PARSE : COND_SKIP; 1185 } 1186 1187 /* Parse the name of the directive, such as 'if', 'elif', 'endif'. */ 1188 if (p[0] == 'e') { 1189 if (p[1] != 'l') { 1190 /* 1191 * Unknown directive. It might still be a 1192 * transformation rule like '.err.txt', 1193 * therefore no error message here. 1194 */ 1195 return COND_INVALID; 1196 } 1197 1198 /* Quite likely this is 'else' or 'elif' */ 1199 p += 2; 1200 if (is_token(p, "se", 2)) { /* It is an 'else'. */ 1201 1202 if (p[2] != '\0') 1203 Parse_Error(PARSE_FATAL, 1204 "The .else directive " 1205 "does not take arguments"); 1206 1207 if (cond_depth == cond_min_depth) { 1208 Parse_Error(PARSE_FATAL, "if-less else"); 1209 return COND_PARSE; 1210 } 1211 1212 state = cond_states[cond_depth]; 1213 if (state == IFS_INITIAL) { 1214 state = IFS_ACTIVE | IFS_SEEN_ELSE; 1215 } else { 1216 if (state & IFS_SEEN_ELSE) 1217 Parse_Error(PARSE_WARNING, 1218 "extra else"); 1219 state = IFS_WAS_ACTIVE | IFS_SEEN_ELSE; 1220 } 1221 cond_states[cond_depth] = state; 1222 1223 return state & IFS_ACTIVE ? COND_PARSE : COND_SKIP; 1224 } 1225 /* Assume for now it is an elif */ 1226 isElif = true; 1227 } else 1228 isElif = false; 1229 1230 if (p[0] != 'i' || p[1] != 'f') { 1231 /* 1232 * Unknown directive. It might still be a transformation rule 1233 * like '.elisp.scm', therefore no error message here. 1234 */ 1235 return COND_INVALID; /* Not an ifxxx or elifxxx line */ 1236 } 1237 1238 if (!DetermineKindOfConditional(&p, &plain, &evalBare, &negate)) 1239 return COND_INVALID; 1240 1241 if (isElif) { 1242 if (cond_depth == cond_min_depth) { 1243 Parse_Error(PARSE_FATAL, "if-less elif"); 1244 return COND_PARSE; 1245 } 1246 state = cond_states[cond_depth]; 1247 if (state & IFS_SEEN_ELSE) { 1248 Parse_Error(PARSE_WARNING, "extra elif"); 1249 cond_states[cond_depth] = 1250 IFS_WAS_ACTIVE | IFS_SEEN_ELSE; 1251 return COND_SKIP; 1252 } 1253 if (state != IFS_INITIAL) { 1254 cond_states[cond_depth] = IFS_WAS_ACTIVE; 1255 return COND_SKIP; 1256 } 1257 } else { 1258 /* Normal .if */ 1259 if (cond_depth + 1 >= cond_states_cap) { 1260 /* 1261 * This is rare, but not impossible. 1262 * In meta mode, dirdeps.mk (only runs at level 0) 1263 * can need more than the default. 1264 */ 1265 cond_states_cap += 32; 1266 cond_states = bmake_realloc(cond_states, 1267 cond_states_cap * sizeof *cond_states); 1268 } 1269 state = cond_states[cond_depth]; 1270 cond_depth++; 1271 if (!(state & IFS_ACTIVE)) { 1272 /* 1273 * If we aren't parsing the data, 1274 * treat as always false. 1275 */ 1276 cond_states[cond_depth] = IFS_WAS_ACTIVE; 1277 return COND_SKIP; 1278 } 1279 } 1280 1281 /* And evaluate the conditional expression */ 1282 if (CondEvalExpression(p, &value, plain, evalBare, negate, 1283 true, false) == COND_INVALID) { 1284 /* 1285 * Syntax error in conditional, error message already output. 1286 */ 1287 /* Skip everything to matching .endif */ 1288 /* XXX: An extra '.else' is not detected in this case. */ 1289 cond_states[cond_depth] = IFS_WAS_ACTIVE; 1290 return COND_SKIP; 1291 } 1292 1293 if (!value) { 1294 cond_states[cond_depth] = IFS_INITIAL; 1295 return COND_SKIP; 1296 } 1297 cond_states[cond_depth] = IFS_ACTIVE; 1298 return COND_PARSE; 1299 } 1300 1301 void 1302 Cond_restore_depth(unsigned int saved_depth) 1303 { 1304 unsigned int open_conds = cond_depth - cond_min_depth; 1305 1306 if (open_conds != 0 || saved_depth > cond_depth) { 1307 Parse_Error(PARSE_FATAL, "%u open conditional%s", 1308 open_conds, open_conds == 1 ? "" : "s"); 1309 cond_depth = cond_min_depth; 1310 } 1311 1312 cond_min_depth = saved_depth; 1313 } 1314 1315 unsigned int 1316 Cond_save_depth(void) 1317 { 1318 unsigned int depth = cond_min_depth; 1319 1320 cond_min_depth = cond_depth; 1321 return depth; 1322 } 1323