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