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