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