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