1 /* $NetBSD: cond.c,v 1.302 2021/12/12 09:36:00 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.302 2021/12/12 09:36:00 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 or 127 * TOK_FALSE. 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 *nested_p; 403 bool atStart; 404 VarParseResult parseResult; 405 406 emode = doEval && quoted ? VARE_WANTRES 407 : doEval ? VARE_UNDEFERR 408 : VARE_PARSE_ONLY; 409 410 nested_p = par->p; 411 atStart = nested_p == start; 412 parseResult = Var_Parse(&nested_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 = nested_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 454 * string. This is called for the left-hand and right-hand sides of 455 * comparisons. 456 * 457 * Results: 458 * Returns the string, absent any quotes, or NULL on error. 459 * Sets out_quoted if the leaf was a quoted string literal. 460 */ 461 static void 462 CondParser_Leaf(CondParser *par, bool doEval, bool unquotedOK, 463 FStr *out_str, bool *out_quoted) 464 { 465 Buffer buf; 466 FStr str; 467 bool quoted; 468 const char *start; 469 470 Buf_Init(&buf); 471 str = FStr_InitRefer(NULL); 472 *out_quoted = quoted = par->p[0] == '"'; 473 start = par->p; 474 if (quoted) 475 par->p++; 476 477 while (par->p[0] != '\0' && str.str == NULL) { 478 switch (par->p[0]) { 479 case '\\': 480 par->p++; 481 if (par->p[0] != '\0') { 482 Buf_AddByte(&buf, par->p[0]); 483 par->p++; 484 } 485 continue; 486 case '"': 487 par->p++; 488 if (quoted) 489 goto got_str; /* skip the closing quote */ 490 Buf_AddByte(&buf, '"'); 491 continue; 492 case ')': /* see is_separator */ 493 case '!': 494 case '=': 495 case '>': 496 case '<': 497 case ' ': 498 case '\t': 499 if (!quoted) 500 goto got_str; 501 Buf_AddByte(&buf, par->p[0]); 502 par->p++; 503 continue; 504 case '$': 505 if (!CondParser_StringExpr(par, 506 start, doEval, quoted, &buf, &str)) 507 goto cleanup; 508 continue; 509 default: 510 if (!unquotedOK && !quoted && *start != '$' && 511 !ch_isdigit(*start)) { 512 /* 513 * The left-hand side must be quoted, 514 * a variable expression or a number. 515 */ 516 str = FStr_InitRefer(NULL); 517 goto cleanup; 518 } 519 Buf_AddByte(&buf, par->p[0]); 520 par->p++; 521 continue; 522 } 523 } 524 got_str: 525 str = FStr_InitOwn(buf.data); 526 buf.data = NULL; 527 cleanup: 528 Buf_Done(&buf); 529 *out_str = str; 530 } 531 532 static bool 533 EvalBare(const CondParser *par, const char *arg) 534 { 535 bool res = par->evalBare(arg); 536 return par->negateEvalBare ? !res : res; 537 } 538 539 /* 540 * Evaluate a "comparison without operator", such as in ".if ${VAR}" or 541 * ".if 0". 542 */ 543 static bool 544 EvalNotEmpty(CondParser *par, const char *value, bool quoted) 545 { 546 double num; 547 548 /* For .ifxxx "...", check for non-empty string. */ 549 if (quoted) 550 return value[0] != '\0'; 551 552 /* For .ifxxx <number>, compare against zero */ 553 if (TryParseNumber(value, &num)) 554 return num != 0.0; 555 556 /* For .if ${...}, check for non-empty string. This is different from 557 * the evaluation function from that .if variant, which would test 558 * whether a variable of the given name were defined. */ 559 /* 560 * XXX: Whitespace should count as empty, just as in 561 * CondParser_FuncCallEmpty. 562 */ 563 if (par->plain) 564 return value[0] != '\0'; 565 566 return EvalBare(par, value); 567 } 568 569 /* Evaluate a numerical comparison, such as in ".if ${VAR} >= 9". */ 570 static bool 571 EvalCompareNum(double lhs, ComparisonOp op, double rhs) 572 { 573 DEBUG3(COND, "lhs = %f, rhs = %f, op = %.2s\n", lhs, rhs, opname[op]); 574 575 switch (op) { 576 case LT: 577 return lhs < rhs; 578 case LE: 579 return lhs <= rhs; 580 case GT: 581 return lhs > rhs; 582 case GE: 583 return lhs >= rhs; 584 case NE: 585 return lhs != rhs; 586 default: 587 return lhs == rhs; 588 } 589 } 590 591 static Token 592 EvalCompareStr(CondParser *par, const char *lhs, 593 ComparisonOp op, const char *rhs) 594 { 595 if (op != EQ && op != NE) { 596 Parse_Error(PARSE_FATAL, 597 "String comparison operator must be either == or !="); 598 par->printedError = true; 599 return TOK_ERROR; 600 } 601 602 DEBUG3(COND, "lhs = \"%s\", rhs = \"%s\", op = %.2s\n", 603 lhs, rhs, opname[op]); 604 return ToToken((op == EQ) == (strcmp(lhs, rhs) == 0)); 605 } 606 607 /* Evaluate a comparison, such as "${VAR} == 12345". */ 608 static Token 609 EvalCompare(CondParser *par, const char *lhs, bool lhsQuoted, 610 ComparisonOp op, const char *rhs, bool rhsQuoted) 611 { 612 double left, right; 613 614 if (!rhsQuoted && !lhsQuoted) 615 if (TryParseNumber(lhs, &left) && TryParseNumber(rhs, &right)) 616 return ToToken(EvalCompareNum(left, op, right)); 617 618 return EvalCompareStr(par, lhs, op, rhs); 619 } 620 621 static bool 622 CondParser_ComparisonOp(CondParser *par, ComparisonOp *out_op) 623 { 624 const char *p = par->p; 625 626 if (p[0] == '<' && p[1] == '=') { 627 *out_op = LE; 628 goto length_2; 629 } else if (p[0] == '<') { 630 *out_op = LT; 631 goto length_1; 632 } else if (p[0] == '>' && p[1] == '=') { 633 *out_op = GE; 634 goto length_2; 635 } else if (p[0] == '>') { 636 *out_op = GT; 637 goto length_1; 638 } else if (p[0] == '=' && p[1] == '=') { 639 *out_op = EQ; 640 goto length_2; 641 } else if (p[0] == '!' && p[1] == '=') { 642 *out_op = NE; 643 goto length_2; 644 } 645 return false; 646 647 length_2: 648 par->p = p + 2; 649 return true; 650 length_1: 651 par->p = p + 1; 652 return true; 653 } 654 655 /* 656 * Parse a comparison condition such as: 657 * 658 * 0 659 * ${VAR:Mpattern} 660 * ${VAR} == value 661 * ${VAR:U0} < 12345 662 */ 663 static Token 664 CondParser_Comparison(CondParser *par, bool doEval) 665 { 666 Token t = TOK_ERROR; 667 FStr lhs, rhs; 668 ComparisonOp op; 669 bool lhsQuoted, rhsQuoted; 670 671 CondParser_Leaf(par, doEval, par->leftUnquotedOK, &lhs, &lhsQuoted); 672 if (lhs.str == NULL) 673 goto done_lhs; 674 675 CondParser_SkipWhitespace(par); 676 677 if (!CondParser_ComparisonOp(par, &op)) { 678 /* Unknown operator, compare against an empty string or 0. */ 679 t = ToToken(doEval && EvalNotEmpty(par, lhs.str, lhsQuoted)); 680 goto done_lhs; 681 } 682 683 CondParser_SkipWhitespace(par); 684 685 if (par->p[0] == '\0') { 686 Parse_Error(PARSE_FATAL, 687 "Missing right-hand side of operator '%s'", opname[op]); 688 par->printedError = true; 689 goto done_lhs; 690 } 691 692 CondParser_Leaf(par, doEval, true, &rhs, &rhsQuoted); 693 if (rhs.str == NULL) 694 goto done_rhs; 695 696 if (!doEval) { 697 t = TOK_FALSE; 698 goto done_rhs; 699 } 700 701 t = EvalCompare(par, lhs.str, lhsQuoted, op, rhs.str, rhsQuoted); 702 703 done_rhs: 704 FStr_Done(&rhs); 705 done_lhs: 706 FStr_Done(&lhs); 707 return t; 708 } 709 710 /* 711 * The argument to empty() is a variable name, optionally followed by 712 * variable modifiers. 713 */ 714 static bool 715 CondParser_FuncCallEmpty(CondParser *par, bool doEval, Token *out_token) 716 { 717 const char *cp = par->p; 718 Token tok; 719 FStr val; 720 721 if (!is_token(cp, "empty", 5)) 722 return false; 723 cp += 5; 724 725 cpp_skip_whitespace(&cp); 726 if (*cp != '(') 727 return false; 728 729 cp--; /* Make cp[1] point to the '('. */ 730 (void)Var_Parse(&cp, SCOPE_CMDLINE, 731 doEval ? VARE_WANTRES : VARE_PARSE_ONLY, &val); 732 /* TODO: handle errors */ 733 734 if (val.str == var_Error) 735 tok = TOK_ERROR; 736 else { 737 cpp_skip_whitespace(&val.str); 738 tok = val.str[0] != '\0' && doEval ? TOK_FALSE : TOK_TRUE; 739 } 740 741 FStr_Done(&val); 742 *out_token = tok; 743 par->p = cp; 744 return true; 745 } 746 747 /* Parse a function call expression, such as 'defined(${file})'. */ 748 static bool 749 CondParser_FuncCall(CondParser *par, bool doEval, Token *out_token) 750 { 751 static const struct fn_def { 752 const char fn_name[9]; 753 unsigned char fn_name_len; 754 bool (*fn_eval)(const char *); 755 } fns[] = { 756 { "defined", 7, FuncDefined }, 757 { "make", 4, FuncMake }, 758 { "exists", 6, FuncExists }, 759 { "target", 6, FuncTarget }, 760 { "commands", 8, FuncCommands } 761 }; 762 const struct fn_def *fn; 763 char *arg = NULL; 764 size_t arglen; 765 const char *cp = par->p; 766 const struct fn_def *last_fn = fns + sizeof fns / sizeof fns[0] - 1; 767 768 for (fn = fns; !is_token(cp, fn->fn_name, fn->fn_name_len); fn++) 769 if (fn == last_fn) 770 return false; 771 772 cp += fn->fn_name_len; 773 cpp_skip_whitespace(&cp); 774 if (*cp != '(') 775 return false; 776 777 arglen = ParseWord(par, &cp, doEval, fn->fn_name, &arg); 778 *out_token = ToToken(arglen != 0 && (!doEval || fn->fn_eval(arg))); 779 780 free(arg); 781 par->p = cp; 782 return true; 783 } 784 785 /* 786 * Parse a comparison that neither starts with '"' nor '$', such as the 787 * unusual 'bare == right' or '3 == ${VAR}', or a simple leaf without 788 * operator, which is a number, a variable expression or a string literal. 789 * 790 * TODO: Can this be merged into CondParser_Comparison? 791 */ 792 static Token 793 CondParser_ComparisonOrLeaf(CondParser *par, bool doEval) 794 { 795 Token t; 796 char *arg = NULL; 797 const char *cp; 798 const char *cp1; 799 800 /* Push anything numeric through the compare expression */ 801 cp = par->p; 802 if (ch_isdigit(cp[0]) || cp[0] == '-' || cp[0] == '+') 803 return CondParser_Comparison(par, doEval); 804 805 /* 806 * Most likely we have a naked token to apply the default function to. 807 * However ".if a == b" gets here when the "a" is unquoted and doesn't 808 * start with a '$'. This surprises people. 809 * If what follows the function argument is a '=' or '!' then the 810 * syntax would be invalid if we did "defined(a)" - so instead treat 811 * as an expression. 812 */ 813 /* 814 * XXX: Is it possible to have a variable expression evaluated twice 815 * at this point? 816 */ 817 (void)ParseWord(par, &cp, doEval, NULL, &arg); 818 cp1 = cp; 819 cpp_skip_whitespace(&cp1); 820 if (*cp1 == '=' || *cp1 == '!' || *cp1 == '<' || *cp1 == '>') 821 return CondParser_Comparison(par, doEval); 822 par->p = cp; 823 824 /* 825 * Evaluate the argument using the default function. 826 * This path always treats .if as .ifdef. To get here, the character 827 * after .if must have been taken literally, so the argument cannot 828 * be empty - even if it contained a variable expansion. 829 */ 830 t = ToToken(!doEval || EvalBare(par, arg)); 831 free(arg); 832 return t; 833 } 834 835 /* Return the next token or comparison result from the parser. */ 836 static Token 837 CondParser_Token(CondParser *par, bool doEval) 838 { 839 Token t; 840 841 t = par->curr; 842 if (t != TOK_NONE) { 843 par->curr = TOK_NONE; 844 return t; 845 } 846 847 cpp_skip_hspace(&par->p); 848 849 switch (par->p[0]) { 850 851 case '(': 852 par->p++; 853 return TOK_LPAREN; 854 855 case ')': 856 par->p++; 857 return TOK_RPAREN; 858 859 case '|': 860 par->p++; 861 if (par->p[0] == '|') 862 par->p++; 863 else if (opts.strict) { 864 Parse_Error(PARSE_FATAL, "Unknown operator '|'"); 865 par->printedError = true; 866 return TOK_ERROR; 867 } 868 return TOK_OR; 869 870 case '&': 871 par->p++; 872 if (par->p[0] == '&') 873 par->p++; 874 else if (opts.strict) { 875 Parse_Error(PARSE_FATAL, "Unknown operator '&'"); 876 par->printedError = true; 877 return TOK_ERROR; 878 } 879 return TOK_AND; 880 881 case '!': 882 par->p++; 883 return TOK_NOT; 884 885 case '#': /* XXX: see unit-tests/cond-token-plain.mk */ 886 case '\n': /* XXX: why should this end the condition? */ 887 /* Probably obsolete now, from 1993-03-21. */ 888 case '\0': 889 return TOK_EOF; 890 891 case '"': 892 case '$': 893 return CondParser_Comparison(par, doEval); 894 895 default: 896 if (CondParser_FuncCallEmpty(par, doEval, &t)) 897 return t; 898 if (CondParser_FuncCall(par, doEval, &t)) 899 return t; 900 return CondParser_ComparisonOrLeaf(par, doEval); 901 } 902 } 903 904 /* Skip the next token if it equals t. */ 905 static bool 906 CondParser_Skip(CondParser *par, Token t) 907 { 908 Token actual; 909 910 actual = CondParser_Token(par, false); 911 if (actual == t) 912 return true; 913 914 assert(par->curr == TOK_NONE); 915 assert(actual != TOK_NONE); 916 par->curr = actual; 917 return false; 918 } 919 920 /* 921 * Term -> '(' Or ')' 922 * Term -> '!' Term 923 * Term -> Leaf Operator Leaf 924 * Term -> Leaf 925 */ 926 static CondResult 927 CondParser_Term(CondParser *par, bool doEval) 928 { 929 CondResult res; 930 Token t; 931 932 t = CondParser_Token(par, doEval); 933 if (t == TOK_TRUE) 934 return CR_TRUE; 935 if (t == TOK_FALSE) 936 return CR_FALSE; 937 938 if (t == TOK_LPAREN) { 939 res = CondParser_Or(par, doEval); 940 if (res == CR_ERROR) 941 return CR_ERROR; 942 if (CondParser_Token(par, doEval) != TOK_RPAREN) 943 return CR_ERROR; 944 return res; 945 } 946 947 if (t == TOK_NOT) { 948 res = CondParser_Term(par, doEval); 949 if (res == CR_TRUE) 950 res = CR_FALSE; 951 else if (res == CR_FALSE) 952 res = CR_TRUE; 953 return res; 954 } 955 956 return CR_ERROR; 957 } 958 959 /* 960 * And -> Term ('&&' Term)* 961 */ 962 static CondResult 963 CondParser_And(CondParser *par, bool doEval) 964 { 965 CondResult res, rhs; 966 967 res = CR_TRUE; 968 do { 969 if ((rhs = CondParser_Term(par, doEval)) == CR_ERROR) 970 return CR_ERROR; 971 if (rhs == CR_FALSE) { 972 res = CR_FALSE; 973 doEval = false; 974 } 975 } while (CondParser_Skip(par, TOK_AND)); 976 977 return res; 978 } 979 980 /* 981 * Or -> And ('||' And)* 982 */ 983 static CondResult 984 CondParser_Or(CondParser *par, bool doEval) 985 { 986 CondResult res, rhs; 987 988 res = CR_FALSE; 989 do { 990 if ((rhs = CondParser_And(par, doEval)) == CR_ERROR) 991 return CR_ERROR; 992 if (rhs == CR_TRUE) { 993 res = CR_TRUE; 994 doEval = false; 995 } 996 } while (CondParser_Skip(par, TOK_OR)); 997 998 return res; 999 } 1000 1001 static CondEvalResult 1002 CondParser_Eval(CondParser *par, bool *out_value) 1003 { 1004 CondResult res; 1005 1006 DEBUG1(COND, "CondParser_Eval: %s\n", par->p); 1007 1008 res = CondParser_Or(par, true); 1009 if (res == CR_ERROR) 1010 return COND_INVALID; 1011 1012 if (CondParser_Token(par, false) != TOK_EOF) 1013 return COND_INVALID; 1014 1015 *out_value = res == CR_TRUE; 1016 return COND_PARSE; 1017 } 1018 1019 /* 1020 * Evaluate the condition, including any side effects from the variable 1021 * expressions in the condition. The condition consists of &&, ||, !, 1022 * function(arg), comparisons and parenthetical groupings thereof. 1023 * 1024 * Results: 1025 * COND_PARSE if the condition was valid grammatically 1026 * COND_INVALID if not a valid conditional. 1027 * 1028 * *out_value is set to the boolean value of the condition 1029 */ 1030 static CondEvalResult 1031 CondEvalExpression(const char *cond, bool *out_value, bool plain, 1032 bool (*evalBare)(const char *), bool negate, 1033 bool eprint, bool leftUnquotedOK) 1034 { 1035 CondParser par; 1036 CondEvalResult rval; 1037 1038 cpp_skip_hspace(&cond); 1039 1040 par.plain = plain; 1041 par.evalBare = evalBare; 1042 par.negateEvalBare = negate; 1043 par.leftUnquotedOK = leftUnquotedOK; 1044 par.p = cond; 1045 par.curr = TOK_NONE; 1046 par.printedError = false; 1047 1048 rval = CondParser_Eval(&par, out_value); 1049 1050 if (rval == COND_INVALID && eprint && !par.printedError) 1051 Parse_Error(PARSE_FATAL, "Malformed conditional (%s)", cond); 1052 1053 return rval; 1054 } 1055 1056 /* 1057 * Evaluate a condition in a :? modifier, such as 1058 * ${"${VAR}" == value:?yes:no}. 1059 */ 1060 CondEvalResult 1061 Cond_EvalCondition(const char *cond, bool *out_value) 1062 { 1063 return CondEvalExpression(cond, out_value, true, 1064 FuncDefined, false, false, true); 1065 } 1066 1067 static bool 1068 IsEndif(const char *p) 1069 { 1070 return p[0] == 'e' && p[1] == 'n' && p[2] == 'd' && 1071 p[3] == 'i' && p[4] == 'f' && !ch_isalpha(p[5]); 1072 } 1073 1074 static bool 1075 DetermineKindOfConditional(const char **pp, bool *out_plain, 1076 bool (**out_evalBare)(const char *), 1077 bool *out_negate) 1078 { 1079 const char *p = *pp; 1080 1081 p += 2; 1082 *out_plain = false; 1083 *out_evalBare = FuncDefined; 1084 *out_negate = false; 1085 if (*p == 'n') { 1086 p++; 1087 *out_negate = true; 1088 } 1089 if (is_token(p, "def", 3)) { /* .ifdef and .ifndef */ 1090 p += 3; 1091 } else if (is_token(p, "make", 4)) { /* .ifmake and .ifnmake */ 1092 p += 4; 1093 *out_evalBare = FuncMake; 1094 } else if (is_token(p, "", 0) && !*out_negate) { /* plain .if */ 1095 *out_plain = true; 1096 } else { 1097 /* 1098 * TODO: Add error message about unknown directive, 1099 * since there is no other known directive that starts 1100 * with 'el' or 'if'. 1101 * 1102 * Example: .elifx 123 1103 */ 1104 return false; 1105 } 1106 1107 *pp = p; 1108 return true; 1109 } 1110 1111 /* 1112 * Evaluate the conditional directive in the line, which is one of: 1113 * 1114 * .if <cond> 1115 * .ifmake <cond> 1116 * .ifnmake <cond> 1117 * .ifdef <cond> 1118 * .ifndef <cond> 1119 * .elif <cond> 1120 * .elifmake <cond> 1121 * .elifnmake <cond> 1122 * .elifdef <cond> 1123 * .elifndef <cond> 1124 * .else 1125 * .endif 1126 * 1127 * In these directives, <cond> consists of &&, ||, !, function(arg), 1128 * comparisons, expressions, bare words, numbers and strings, and 1129 * parenthetical groupings thereof. 1130 * 1131 * Results: 1132 * COND_PARSE to continue parsing the lines that follow the 1133 * conditional (when <cond> evaluates to true) 1134 * COND_SKIP to skip the lines after the conditional 1135 * (when <cond> evaluates to false, or when a previous 1136 * branch has already been taken) 1137 * COND_INVALID if the conditional was not valid, either because of 1138 * a syntax error or because some variable was undefined 1139 * or because the condition could not be evaluated 1140 */ 1141 CondEvalResult 1142 Cond_EvalLine(const char *line) 1143 { 1144 typedef enum IfState { 1145 1146 /* None of the previous <cond> evaluated to true. */ 1147 IFS_INITIAL = 0, 1148 1149 /* The previous <cond> evaluated to true. 1150 * The lines following this condition are interpreted. */ 1151 IFS_ACTIVE = 1 << 0, 1152 1153 /* The previous directive was an '.else'. */ 1154 IFS_SEEN_ELSE = 1 << 1, 1155 1156 /* One of the previous <cond> evaluated to true. */ 1157 IFS_WAS_ACTIVE = 1 << 2 1158 1159 } IfState; 1160 1161 static enum IfState *cond_states = NULL; 1162 static unsigned int cond_states_cap = 128; 1163 1164 bool plain; 1165 bool (*evalBare)(const char *); 1166 bool negate; 1167 bool isElif; 1168 bool value; 1169 IfState state; 1170 const char *p = line; 1171 1172 if (cond_states == NULL) { 1173 cond_states = bmake_malloc( 1174 cond_states_cap * sizeof *cond_states); 1175 cond_states[0] = IFS_ACTIVE; 1176 } 1177 1178 p++; /* skip the leading '.' */ 1179 cpp_skip_hspace(&p); 1180 1181 if (IsEndif(p)) { /* It is an '.endif'. */ 1182 if (p[5] != '\0') { 1183 Parse_Error(PARSE_FATAL, 1184 "The .endif directive does not take arguments"); 1185 } 1186 1187 if (cond_depth == cond_min_depth) { 1188 Parse_Error(PARSE_FATAL, "if-less endif"); 1189 return COND_PARSE; 1190 } 1191 1192 /* Return state for previous conditional */ 1193 cond_depth--; 1194 return cond_states[cond_depth] & IFS_ACTIVE 1195 ? COND_PARSE : COND_SKIP; 1196 } 1197 1198 /* Parse the name of the directive, such as 'if', 'elif', 'endif'. */ 1199 if (p[0] == 'e') { 1200 if (p[1] != 'l') { 1201 /* 1202 * Unknown directive. It might still be a 1203 * transformation rule like '.err.txt', 1204 * therefore no error message here. 1205 */ 1206 return COND_INVALID; 1207 } 1208 1209 /* Quite likely this is 'else' or 'elif' */ 1210 p += 2; 1211 if (is_token(p, "se", 2)) { /* It is an 'else'. */ 1212 1213 if (p[2] != '\0') 1214 Parse_Error(PARSE_FATAL, 1215 "The .else directive " 1216 "does not take arguments"); 1217 1218 if (cond_depth == cond_min_depth) { 1219 Parse_Error(PARSE_FATAL, "if-less else"); 1220 return COND_PARSE; 1221 } 1222 1223 state = cond_states[cond_depth]; 1224 if (state == IFS_INITIAL) { 1225 state = IFS_ACTIVE | IFS_SEEN_ELSE; 1226 } else { 1227 if (state & IFS_SEEN_ELSE) 1228 Parse_Error(PARSE_WARNING, 1229 "extra else"); 1230 state = IFS_WAS_ACTIVE | IFS_SEEN_ELSE; 1231 } 1232 cond_states[cond_depth] = state; 1233 1234 return state & IFS_ACTIVE ? COND_PARSE : COND_SKIP; 1235 } 1236 /* Assume for now it is an elif */ 1237 isElif = true; 1238 } else 1239 isElif = false; 1240 1241 if (p[0] != 'i' || p[1] != 'f') { 1242 /* 1243 * Unknown directive. It might still be a transformation rule 1244 * like '.elisp.scm', therefore no error message here. 1245 */ 1246 return COND_INVALID; /* Not an ifxxx or elifxxx line */ 1247 } 1248 1249 if (!DetermineKindOfConditional(&p, &plain, &evalBare, &negate)) 1250 return COND_INVALID; 1251 1252 if (isElif) { 1253 if (cond_depth == cond_min_depth) { 1254 Parse_Error(PARSE_FATAL, "if-less elif"); 1255 return COND_PARSE; 1256 } 1257 state = cond_states[cond_depth]; 1258 if (state & IFS_SEEN_ELSE) { 1259 Parse_Error(PARSE_WARNING, "extra elif"); 1260 cond_states[cond_depth] = 1261 IFS_WAS_ACTIVE | IFS_SEEN_ELSE; 1262 return COND_SKIP; 1263 } 1264 if (state != IFS_INITIAL) { 1265 cond_states[cond_depth] = IFS_WAS_ACTIVE; 1266 return COND_SKIP; 1267 } 1268 } else { 1269 /* Normal .if */ 1270 if (cond_depth + 1 >= cond_states_cap) { 1271 /* 1272 * This is rare, but not impossible. 1273 * In meta mode, dirdeps.mk (only runs at level 0) 1274 * can need more than the default. 1275 */ 1276 cond_states_cap += 32; 1277 cond_states = bmake_realloc(cond_states, 1278 cond_states_cap * 1279 sizeof *cond_states); 1280 } 1281 state = cond_states[cond_depth]; 1282 cond_depth++; 1283 if (!(state & IFS_ACTIVE)) { 1284 /* 1285 * If we aren't parsing the data, 1286 * treat as always false. 1287 */ 1288 cond_states[cond_depth] = IFS_WAS_ACTIVE; 1289 return COND_SKIP; 1290 } 1291 } 1292 1293 /* And evaluate the conditional expression */ 1294 if (CondEvalExpression(p, &value, plain, evalBare, negate, 1295 true, false) == COND_INVALID) { 1296 /* Syntax error in conditional, error message already output. */ 1297 /* Skip everything to matching .endif */ 1298 /* XXX: An extra '.else' is not detected in this case. */ 1299 cond_states[cond_depth] = IFS_WAS_ACTIVE; 1300 return COND_SKIP; 1301 } 1302 1303 if (!value) { 1304 cond_states[cond_depth] = IFS_INITIAL; 1305 return COND_SKIP; 1306 } 1307 cond_states[cond_depth] = IFS_ACTIVE; 1308 return COND_PARSE; 1309 } 1310 1311 void 1312 Cond_restore_depth(unsigned int saved_depth) 1313 { 1314 unsigned int open_conds = cond_depth - cond_min_depth; 1315 1316 if (open_conds != 0 || saved_depth > cond_depth) { 1317 Parse_Error(PARSE_FATAL, "%u open conditional%s", 1318 open_conds, open_conds == 1 ? "" : "s"); 1319 cond_depth = cond_min_depth; 1320 } 1321 1322 cond_min_depth = saved_depth; 1323 } 1324 1325 unsigned int 1326 Cond_save_depth(void) 1327 { 1328 unsigned int depth = cond_min_depth; 1329 1330 cond_min_depth = cond_depth; 1331 return depth; 1332 } 1333