1 /* $NetBSD: cond.c,v 1.68 2015/05/05 21:51:09 sjg 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 #ifndef MAKE_NATIVE
73 static char rcsid[] = "$NetBSD: cond.c,v 1.68 2015/05/05 21:51:09 sjg Exp $";
74 #else
75 #include <sys/cdefs.h>
76 #ifndef lint
77 #if 0
78 static char sccsid[] = "@(#)cond.c 8.2 (Berkeley) 1/2/94";
79 #else
80 __RCSID("$NetBSD: cond.c,v 1.68 2015/05/05 21:51:09 sjg Exp $");
81 #endif
82 #endif /* not lint */
83 #endif
84
85 /*-
86 * cond.c --
87 * Functions to handle conditionals in a makefile.
88 *
89 * Interface:
90 * Cond_Eval Evaluate the conditional in the passed line.
91 *
92 */
93
94 #include <ctype.h>
95 #include <errno.h> /* For strtoul() error checking */
96
97 #include "make.h"
98 #include "hash.h"
99 #include "dir.h"
100 #include "buf.h"
101
102 /*
103 * The parsing of conditional expressions is based on this grammar:
104 * E -> F || E
105 * E -> F
106 * F -> T && F
107 * F -> T
108 * T -> defined(variable)
109 * T -> make(target)
110 * T -> exists(file)
111 * T -> empty(varspec)
112 * T -> target(name)
113 * T -> commands(name)
114 * T -> symbol
115 * T -> $(varspec) op value
116 * T -> $(varspec) == "string"
117 * T -> $(varspec) != "string"
118 * T -> "string"
119 * T -> ( E )
120 * T -> ! T
121 * op -> == | != | > | < | >= | <=
122 *
123 * 'symbol' is some other symbol to which the default function (condDefProc)
124 * is applied.
125 *
126 * Tokens are scanned from the 'condExpr' string. The scanner (CondToken)
127 * will return TOK_AND for '&' and '&&', TOK_OR for '|' and '||',
128 * TOK_NOT for '!', TOK_LPAREN for '(', TOK_RPAREN for ')' and will evaluate
129 * the other terminal symbols, using either the default function or the
130 * function given in the terminal, and return the result as either TOK_TRUE
131 * or TOK_FALSE.
132 *
133 * TOK_FALSE is 0 and TOK_TRUE 1 so we can directly assign C comparisons.
134 *
135 * All Non-Terminal functions (CondE, CondF and CondT) return TOK_ERROR on
136 * error.
137 */
138 typedef enum {
139 TOK_FALSE = 0, TOK_TRUE = 1, TOK_AND, TOK_OR, TOK_NOT,
140 TOK_LPAREN, TOK_RPAREN, TOK_EOF, TOK_NONE, TOK_ERROR
141 } Token;
142
143 /*-
144 * Structures to handle elegantly the different forms of #if's. The
145 * last two fields are stored in condInvert and condDefProc, respectively.
146 */
147 static void CondPushBack(Token);
148 static int CondGetArg(char **, char **, const char *);
149 static Boolean CondDoDefined(int, const char *);
150 static int CondStrMatch(const void *, const void *);
151 static Boolean CondDoMake(int, const char *);
152 static Boolean CondDoExists(int, const char *);
153 static Boolean CondDoTarget(int, const char *);
154 static Boolean CondDoCommands(int, const char *);
155 static Boolean CondCvtArg(char *, double *);
156 static Token CondToken(Boolean);
157 static Token CondT(Boolean);
158 static Token CondF(Boolean);
159 static Token CondE(Boolean);
160 static int do_Cond_EvalExpression(Boolean *);
161
162 static const struct If {
163 const char *form; /* Form of if */
164 int formlen; /* Length of form */
165 Boolean doNot; /* TRUE if default function should be negated */
166 Boolean (*defProc)(int, const char *); /* Default function to apply */
167 } ifs[] = {
168 { "def", 3, FALSE, CondDoDefined },
169 { "ndef", 4, TRUE, CondDoDefined },
170 { "make", 4, FALSE, CondDoMake },
171 { "nmake", 5, TRUE, CondDoMake },
172 { "", 0, FALSE, CondDoDefined },
173 { NULL, 0, FALSE, NULL }
174 };
175
176 static const struct If *if_info; /* Info for current statement */
177 static char *condExpr; /* The expression to parse */
178 static Token condPushBack=TOK_NONE; /* Single push-back token used in
179 * parsing */
180
181 static unsigned int cond_depth = 0; /* current .if nesting level */
182 static unsigned int cond_min_depth = 0; /* depth at makefile open */
183
184 /*
185 * Indicate when we should be strict about lhs of comparisons.
186 * TRUE when Cond_EvalExpression is called from Cond_Eval (.if etc)
187 * FALSE when Cond_EvalExpression is called from var.c:ApplyModifiers
188 * since lhs is already expanded and we cannot tell if
189 * it was a variable reference or not.
190 */
191 static Boolean lhsStrict;
192
193 static int
istoken(const char * str,const char * tok,size_t len)194 istoken(const char *str, const char *tok, size_t len)
195 {
196 return strncmp(str, tok, len) == 0 && !isalpha((unsigned char)str[len]);
197 }
198
199 /*-
200 *-----------------------------------------------------------------------
201 * CondPushBack --
202 * Push back the most recent token read. We only need one level of
203 * this, so the thing is just stored in 'condPushback'.
204 *
205 * Input:
206 * t Token to push back into the "stream"
207 *
208 * Results:
209 * None.
210 *
211 * Side Effects:
212 * condPushback is overwritten.
213 *
214 *-----------------------------------------------------------------------
215 */
216 static void
CondPushBack(Token t)217 CondPushBack(Token t)
218 {
219 condPushBack = t;
220 }
221
222 /*-
223 *-----------------------------------------------------------------------
224 * CondGetArg --
225 * Find the argument of a built-in function.
226 *
227 * Input:
228 * parens TRUE if arg should be bounded by parens
229 *
230 * Results:
231 * The length of the argument and the address of the argument.
232 *
233 * Side Effects:
234 * The pointer is set to point to the closing parenthesis of the
235 * function call.
236 *
237 *-----------------------------------------------------------------------
238 */
239 static int
CondGetArg(char ** linePtr,char ** argPtr,const char * func)240 CondGetArg(char **linePtr, char **argPtr, const char *func)
241 {
242 char *cp;
243 int argLen;
244 Buffer buf;
245 int paren_depth;
246 char ch;
247
248 cp = *linePtr;
249 if (func != NULL)
250 /* Skip opening '(' - verfied by caller */
251 cp++;
252
253 if (*cp == '\0') {
254 /*
255 * No arguments whatsoever. Because 'make' and 'defined' aren't really
256 * "reserved words", we don't print a message. I think this is better
257 * than hitting the user with a warning message every time s/he uses
258 * the word 'make' or 'defined' at the beginning of a symbol...
259 */
260 *argPtr = NULL;
261 return (0);
262 }
263
264 while (*cp == ' ' || *cp == '\t') {
265 cp++;
266 }
267
268 /*
269 * Create a buffer for the argument and start it out at 16 characters
270 * long. Why 16? Why not?
271 */
272 Buf_Init(&buf, 16);
273
274 paren_depth = 0;
275 for (;;) {
276 ch = *cp;
277 if (ch == 0 || ch == ' ' || ch == '\t')
278 break;
279 if ((ch == '&' || ch == '|') && paren_depth == 0)
280 break;
281 if (*cp == '$') {
282 /*
283 * Parse the variable spec and install it as part of the argument
284 * if it's valid. We tell Var_Parse to complain on an undefined
285 * variable, so we don't do it too. Nor do we return an error,
286 * though perhaps we should...
287 */
288 char *cp2;
289 int len;
290 void *freeIt;
291
292 cp2 = Var_Parse(cp, VAR_CMD, TRUE, &len, &freeIt);
293 Buf_AddBytes(&buf, strlen(cp2), cp2);
294 if (freeIt)
295 free(freeIt);
296 cp += len;
297 continue;
298 }
299 if (ch == '(')
300 paren_depth++;
301 else
302 if (ch == ')' && --paren_depth < 0)
303 break;
304 Buf_AddByte(&buf, *cp);
305 cp++;
306 }
307
308 *argPtr = Buf_GetAll(&buf, &argLen);
309 Buf_Destroy(&buf, FALSE);
310
311 while (*cp == ' ' || *cp == '\t') {
312 cp++;
313 }
314
315 if (func != NULL && *cp++ != ')') {
316 Parse_Error(PARSE_WARNING, "Missing closing parenthesis for %s()",
317 func);
318 return (0);
319 }
320
321 *linePtr = cp;
322 return (argLen);
323 }
324
325 /*-
326 *-----------------------------------------------------------------------
327 * CondDoDefined --
328 * Handle the 'defined' function for conditionals.
329 *
330 * Results:
331 * TRUE if the given variable is defined.
332 *
333 * Side Effects:
334 * None.
335 *
336 *-----------------------------------------------------------------------
337 */
338 static Boolean
CondDoDefined(int argLen MAKE_ATTR_UNUSED,const char * arg)339 CondDoDefined(int argLen MAKE_ATTR_UNUSED, const char *arg)
340 {
341 char *p1;
342 Boolean result;
343
344 if (Var_Value(arg, VAR_CMD, &p1) != NULL) {
345 result = TRUE;
346 } else {
347 result = FALSE;
348 }
349 if (p1)
350 free(p1);
351 return (result);
352 }
353
354 /*-
355 *-----------------------------------------------------------------------
356 * CondStrMatch --
357 * Front-end for Str_Match so it returns 0 on match and non-zero
358 * on mismatch. Callback function for CondDoMake via Lst_Find
359 *
360 * Results:
361 * 0 if string matches pattern
362 *
363 * Side Effects:
364 * None
365 *
366 *-----------------------------------------------------------------------
367 */
368 static int
CondStrMatch(const void * string,const void * pattern)369 CondStrMatch(const void *string, const void *pattern)
370 {
371 return(!Str_Match(string, pattern));
372 }
373
374 /*-
375 *-----------------------------------------------------------------------
376 * CondDoMake --
377 * Handle the 'make' function for conditionals.
378 *
379 * Results:
380 * TRUE if the given target is being made.
381 *
382 * Side Effects:
383 * None.
384 *
385 *-----------------------------------------------------------------------
386 */
387 static Boolean
CondDoMake(int argLen MAKE_ATTR_UNUSED,const char * arg)388 CondDoMake(int argLen MAKE_ATTR_UNUSED, const char *arg)
389 {
390 return Lst_Find(create, arg, CondStrMatch) != NULL;
391 }
392
393 /*-
394 *-----------------------------------------------------------------------
395 * CondDoExists --
396 * See if the given file exists.
397 *
398 * Results:
399 * TRUE if the file exists and FALSE if it does not.
400 *
401 * Side Effects:
402 * None.
403 *
404 *-----------------------------------------------------------------------
405 */
406 static Boolean
CondDoExists(int argLen MAKE_ATTR_UNUSED,const char * arg)407 CondDoExists(int argLen MAKE_ATTR_UNUSED, const char *arg)
408 {
409 Boolean result;
410 char *path;
411
412 path = Dir_FindFile(arg, dirSearchPath);
413 if (DEBUG(COND)) {
414 fprintf(debug_file, "exists(%s) result is \"%s\"\n",
415 arg, path ? path : "");
416 }
417 if (path != NULL) {
418 result = TRUE;
419 free(path);
420 } else {
421 result = FALSE;
422 }
423 return (result);
424 }
425
426 /*-
427 *-----------------------------------------------------------------------
428 * CondDoTarget --
429 * See if the given node exists and is an actual target.
430 *
431 * Results:
432 * TRUE if the node exists as a target and FALSE if it does not.
433 *
434 * Side Effects:
435 * None.
436 *
437 *-----------------------------------------------------------------------
438 */
439 static Boolean
CondDoTarget(int argLen MAKE_ATTR_UNUSED,const char * arg)440 CondDoTarget(int argLen MAKE_ATTR_UNUSED, const char *arg)
441 {
442 GNode *gn;
443
444 gn = Targ_FindNode(arg, TARG_NOCREATE);
445 return (gn != NULL) && !OP_NOP(gn->type);
446 }
447
448 /*-
449 *-----------------------------------------------------------------------
450 * CondDoCommands --
451 * See if the given node exists and is an actual target with commands
452 * associated with it.
453 *
454 * Results:
455 * TRUE if the node exists as a target and has commands associated with
456 * it and FALSE if it does not.
457 *
458 * Side Effects:
459 * None.
460 *
461 *-----------------------------------------------------------------------
462 */
463 static Boolean
CondDoCommands(int argLen MAKE_ATTR_UNUSED,const char * arg)464 CondDoCommands(int argLen MAKE_ATTR_UNUSED, const char *arg)
465 {
466 GNode *gn;
467
468 gn = Targ_FindNode(arg, TARG_NOCREATE);
469 return (gn != NULL) && !OP_NOP(gn->type) && !Lst_IsEmpty(gn->commands);
470 }
471
472 /*-
473 *-----------------------------------------------------------------------
474 * CondCvtArg --
475 * Convert the given number into a double.
476 * We try a base 10 or 16 integer conversion first, if that fails
477 * then we try a floating point conversion instead.
478 *
479 * Results:
480 * Sets 'value' to double value of string.
481 * Returns 'true' if the convertion suceeded
482 *
483 *-----------------------------------------------------------------------
484 */
485 static Boolean
CondCvtArg(char * str,double * value)486 CondCvtArg(char *str, double *value)
487 {
488 char *eptr, ech;
489 unsigned long l_val;
490 double d_val;
491
492 errno = 0;
493 l_val = strtoul(str, &eptr, str[1] == 'x' ? 16 : 10);
494 ech = *eptr;
495 if (ech == 0 && errno != ERANGE) {
496 d_val = str[0] == '-' ? -(double)-l_val : (double)l_val;
497 } else {
498 if (ech != 0 && ech != '.' && ech != 'e' && ech != 'E')
499 return FALSE;
500 d_val = strtod(str, &eptr);
501 if (*eptr)
502 return FALSE;
503 }
504
505 *value = d_val;
506 return TRUE;
507 }
508
509 /*-
510 *-----------------------------------------------------------------------
511 * CondGetString --
512 * Get a string from a variable reference or an optionally quoted
513 * string. This is called for the lhs and rhs of string compares.
514 *
515 * Results:
516 * Sets freeIt if needed,
517 * Sets quoted if string was quoted,
518 * Returns NULL on error,
519 * else returns string - absent any quotes.
520 *
521 * Side Effects:
522 * Moves condExpr to end of this token.
523 *
524 *
525 *-----------------------------------------------------------------------
526 */
527 /* coverity:[+alloc : arg-*2] */
528 static char *
CondGetString(Boolean doEval,Boolean * quoted,void ** freeIt,Boolean strictLHS)529 CondGetString(Boolean doEval, Boolean *quoted, void **freeIt, Boolean strictLHS)
530 {
531 Buffer buf;
532 char *cp;
533 char *str;
534 int len;
535 int qt;
536 char *start;
537
538 Buf_Init(&buf, 0);
539 str = NULL;
540 *freeIt = NULL;
541 *quoted = qt = *condExpr == '"' ? 1 : 0;
542 if (qt)
543 condExpr++;
544 for (start = condExpr; *condExpr && str == NULL; condExpr++) {
545 switch (*condExpr) {
546 case '\\':
547 if (condExpr[1] != '\0') {
548 condExpr++;
549 Buf_AddByte(&buf, *condExpr);
550 }
551 break;
552 case '"':
553 if (qt) {
554 condExpr++; /* we don't want the quotes */
555 goto got_str;
556 } else
557 Buf_AddByte(&buf, *condExpr); /* likely? */
558 break;
559 case ')':
560 case '!':
561 case '=':
562 case '>':
563 case '<':
564 case ' ':
565 case '\t':
566 if (!qt)
567 goto got_str;
568 else
569 Buf_AddByte(&buf, *condExpr);
570 break;
571 case '$':
572 /* if we are in quotes, then an undefined variable is ok */
573 str = Var_Parse(condExpr, VAR_CMD, (qt ? 0 : doEval),
574 &len, freeIt);
575 if (str == var_Error) {
576 if (*freeIt) {
577 free(*freeIt);
578 *freeIt = NULL;
579 }
580 /*
581 * Even if !doEval, we still report syntax errors, which
582 * is what getting var_Error back with !doEval means.
583 */
584 str = NULL;
585 goto cleanup;
586 }
587 condExpr += len;
588 /*
589 * If the '$' was first char (no quotes), and we are
590 * followed by space, the operator or end of expression,
591 * we are done.
592 */
593 if ((condExpr == start + len) &&
594 (*condExpr == '\0' ||
595 isspace((unsigned char) *condExpr) ||
596 strchr("!=><)", *condExpr))) {
597 goto cleanup;
598 }
599 /*
600 * Nope, we better copy str to buf
601 */
602 for (cp = str; *cp; cp++) {
603 Buf_AddByte(&buf, *cp);
604 }
605 if (*freeIt) {
606 free(*freeIt);
607 *freeIt = NULL;
608 }
609 str = NULL; /* not finished yet */
610 condExpr--; /* don't skip over next char */
611 break;
612 default:
613 if (strictLHS && !qt && *start != '$' &&
614 !isdigit((unsigned char) *start)) {
615 /* lhs must be quoted, a variable reference or number */
616 if (*freeIt) {
617 free(*freeIt);
618 *freeIt = NULL;
619 }
620 str = NULL;
621 goto cleanup;
622 }
623 Buf_AddByte(&buf, *condExpr);
624 break;
625 }
626 }
627 got_str:
628 str = Buf_GetAll(&buf, NULL);
629 *freeIt = str;
630 cleanup:
631 Buf_Destroy(&buf, FALSE);
632 return str;
633 }
634
635 /*-
636 *-----------------------------------------------------------------------
637 * CondToken --
638 * Return the next token from the input.
639 *
640 * Results:
641 * A Token for the next lexical token in the stream.
642 *
643 * Side Effects:
644 * condPushback will be set back to TOK_NONE if it is used.
645 *
646 *-----------------------------------------------------------------------
647 */
648 static Token
compare_expression(Boolean doEval)649 compare_expression(Boolean doEval)
650 {
651 Token t;
652 char *lhs;
653 char *rhs;
654 char *op;
655 void *lhsFree;
656 void *rhsFree;
657 Boolean lhsQuoted;
658 Boolean rhsQuoted;
659 double left, right;
660
661 t = TOK_ERROR;
662 rhs = NULL;
663 lhsFree = rhsFree = FALSE;
664 lhsQuoted = rhsQuoted = FALSE;
665
666 /*
667 * Parse the variable spec and skip over it, saving its
668 * value in lhs.
669 */
670 lhs = CondGetString(doEval, &lhsQuoted, &lhsFree, lhsStrict);
671 if (!lhs)
672 goto done;
673
674 /*
675 * Skip whitespace to get to the operator
676 */
677 while (isspace((unsigned char) *condExpr))
678 condExpr++;
679
680 /*
681 * Make sure the operator is a valid one. If it isn't a
682 * known relational operator, pretend we got a
683 * != 0 comparison.
684 */
685 op = condExpr;
686 switch (*condExpr) {
687 case '!':
688 case '=':
689 case '<':
690 case '>':
691 if (condExpr[1] == '=') {
692 condExpr += 2;
693 } else {
694 condExpr += 1;
695 }
696 break;
697 default:
698 if (!doEval) {
699 t = TOK_FALSE;
700 goto done;
701 }
702 /* For .ifxxx "..." check for non-empty string. */
703 if (lhsQuoted) {
704 t = lhs[0] != 0;
705 goto done;
706 }
707 /* For .ifxxx <number> compare against zero */
708 if (CondCvtArg(lhs, &left)) {
709 t = left != 0.0;
710 goto done;
711 }
712 /* For .if ${...} check for non-empty string (defProc is ifdef). */
713 if (if_info->form[0] == 0) {
714 t = lhs[0] != 0;
715 goto done;
716 }
717 /* Otherwise action default test ... */
718 t = if_info->defProc(strlen(lhs), lhs) != if_info->doNot;
719 goto done;
720 }
721
722 while (isspace((unsigned char)*condExpr))
723 condExpr++;
724
725 if (*condExpr == '\0') {
726 Parse_Error(PARSE_WARNING,
727 "Missing right-hand-side of operator");
728 goto done;
729 }
730
731 rhs = CondGetString(doEval, &rhsQuoted, &rhsFree, FALSE);
732 if (!rhs)
733 goto done;
734
735 if (rhsQuoted || lhsQuoted) {
736 do_string_compare:
737 if (((*op != '!') && (*op != '=')) || (op[1] != '=')) {
738 Parse_Error(PARSE_WARNING,
739 "String comparison operator should be either == or !=");
740 goto done;
741 }
742
743 if (DEBUG(COND)) {
744 fprintf(debug_file, "lhs = \"%s\", rhs = \"%s\", op = %.2s\n",
745 lhs, rhs, op);
746 }
747 /*
748 * Null-terminate rhs and perform the comparison.
749 * t is set to the result.
750 */
751 if (*op == '=') {
752 t = strcmp(lhs, rhs) == 0;
753 } else {
754 t = strcmp(lhs, rhs) != 0;
755 }
756 } else {
757 /*
758 * rhs is either a float or an integer. Convert both the
759 * lhs and the rhs to a double and compare the two.
760 */
761
762 if (!CondCvtArg(lhs, &left) || !CondCvtArg(rhs, &right))
763 goto do_string_compare;
764
765 if (DEBUG(COND)) {
766 fprintf(debug_file, "left = %f, right = %f, op = %.2s\n", left,
767 right, op);
768 }
769 switch(op[0]) {
770 case '!':
771 if (op[1] != '=') {
772 Parse_Error(PARSE_WARNING,
773 "Unknown operator");
774 goto done;
775 }
776 t = (left != right);
777 break;
778 case '=':
779 if (op[1] != '=') {
780 Parse_Error(PARSE_WARNING,
781 "Unknown operator");
782 goto done;
783 }
784 t = (left == right);
785 break;
786 case '<':
787 if (op[1] == '=') {
788 t = (left <= right);
789 } else {
790 t = (left < right);
791 }
792 break;
793 case '>':
794 if (op[1] == '=') {
795 t = (left >= right);
796 } else {
797 t = (left > right);
798 }
799 break;
800 }
801 }
802
803 done:
804 if (lhsFree)
805 free(lhsFree);
806 if (rhsFree)
807 free(rhsFree);
808 return t;
809 }
810
811 static int
get_mpt_arg(char ** linePtr,char ** argPtr,const char * func MAKE_ATTR_UNUSED)812 get_mpt_arg(char **linePtr, char **argPtr, const char *func MAKE_ATTR_UNUSED)
813 {
814 /*
815 * Use Var_Parse to parse the spec in parens and return
816 * TOK_TRUE if the resulting string is empty.
817 */
818 int length;
819 void *freeIt;
820 char *val;
821 char *cp = *linePtr;
822
823 /* We do all the work here and return the result as the length */
824 *argPtr = NULL;
825
826 val = Var_Parse(cp - 1, VAR_CMD, FALSE, &length, &freeIt);
827 /*
828 * Advance *linePtr to beyond the closing ). Note that
829 * we subtract one because 'length' is calculated from 'cp - 1'.
830 */
831 *linePtr = cp - 1 + length;
832
833 if (val == var_Error) {
834 free(freeIt);
835 return -1;
836 }
837
838 /* A variable is empty when it just contains spaces... 4/15/92, christos */
839 while (isspace(*(unsigned char *)val))
840 val++;
841
842 /*
843 * For consistency with the other functions we can't generate the
844 * true/false here.
845 */
846 length = *val ? 2 : 1;
847 if (freeIt)
848 free(freeIt);
849 return length;
850 }
851
852 static Boolean
CondDoEmpty(int arglen,const char * arg MAKE_ATTR_UNUSED)853 CondDoEmpty(int arglen, const char *arg MAKE_ATTR_UNUSED)
854 {
855 return arglen == 1;
856 }
857
858 static Token
compare_function(Boolean doEval)859 compare_function(Boolean doEval)
860 {
861 static const struct fn_def {
862 const char *fn_name;
863 int fn_name_len;
864 int (*fn_getarg)(char **, char **, const char *);
865 Boolean (*fn_proc)(int, const char *);
866 } fn_defs[] = {
867 { "defined", 7, CondGetArg, CondDoDefined },
868 { "make", 4, CondGetArg, CondDoMake },
869 { "exists", 6, CondGetArg, CondDoExists },
870 { "empty", 5, get_mpt_arg, CondDoEmpty },
871 { "target", 6, CondGetArg, CondDoTarget },
872 { "commands", 8, CondGetArg, CondDoCommands },
873 { NULL, 0, NULL, NULL },
874 };
875 const struct fn_def *fn_def;
876 Token t;
877 char *arg = NULL;
878 int arglen;
879 char *cp = condExpr;
880 char *cp1;
881
882 for (fn_def = fn_defs; fn_def->fn_name != NULL; fn_def++) {
883 if (!istoken(cp, fn_def->fn_name, fn_def->fn_name_len))
884 continue;
885 cp += fn_def->fn_name_len;
886 /* There can only be whitespace before the '(' */
887 while (isspace(*(unsigned char *)cp))
888 cp++;
889 if (*cp != '(')
890 break;
891
892 arglen = fn_def->fn_getarg(&cp, &arg, fn_def->fn_name);
893 if (arglen <= 0) {
894 condExpr = cp;
895 return arglen < 0 ? TOK_ERROR : TOK_FALSE;
896 }
897 /* Evaluate the argument using the required function. */
898 t = !doEval || fn_def->fn_proc(arglen, arg);
899 if (arg)
900 free(arg);
901 condExpr = cp;
902 return t;
903 }
904
905 /* Push anything numeric through the compare expression */
906 cp = condExpr;
907 if (isdigit((unsigned char)cp[0]) || strchr("+-", cp[0]))
908 return compare_expression(doEval);
909
910 /*
911 * Most likely we have a naked token to apply the default function to.
912 * However ".if a == b" gets here when the "a" is unquoted and doesn't
913 * start with a '$'. This surprises people.
914 * If what follows the function argument is a '=' or '!' then the syntax
915 * would be invalid if we did "defined(a)" - so instead treat as an
916 * expression.
917 */
918 arglen = CondGetArg(&cp, &arg, NULL);
919 for (cp1 = cp; isspace(*(unsigned char *)cp1); cp1++)
920 continue;
921 if (*cp1 == '=' || *cp1 == '!')
922 return compare_expression(doEval);
923 condExpr = cp;
924
925 /*
926 * Evaluate the argument using the default function.
927 * This path always treats .if as .ifdef. To get here the character
928 * after .if must have been taken literally, so the argument cannot
929 * be empty - even if it contained a variable expansion.
930 */
931 t = !doEval || if_info->defProc(arglen, arg) != if_info->doNot;
932 if (arg)
933 free(arg);
934 return t;
935 }
936
937 static Token
CondToken(Boolean doEval)938 CondToken(Boolean doEval)
939 {
940 Token t;
941
942 t = condPushBack;
943 if (t != TOK_NONE) {
944 condPushBack = TOK_NONE;
945 return t;
946 }
947
948 while (*condExpr == ' ' || *condExpr == '\t') {
949 condExpr++;
950 }
951
952 switch (*condExpr) {
953
954 case '(':
955 condExpr++;
956 return TOK_LPAREN;
957
958 case ')':
959 condExpr++;
960 return TOK_RPAREN;
961
962 case '|':
963 if (condExpr[1] == '|') {
964 condExpr++;
965 }
966 condExpr++;
967 return TOK_OR;
968
969 case '&':
970 if (condExpr[1] == '&') {
971 condExpr++;
972 }
973 condExpr++;
974 return TOK_AND;
975
976 case '!':
977 condExpr++;
978 return TOK_NOT;
979
980 case '#':
981 case '\n':
982 case '\0':
983 return TOK_EOF;
984
985 case '"':
986 case '$':
987 return compare_expression(doEval);
988
989 default:
990 return compare_function(doEval);
991 }
992 }
993
994 /*-
995 *-----------------------------------------------------------------------
996 * CondT --
997 * Parse a single term in the expression. This consists of a terminal
998 * symbol or TOK_NOT and a terminal symbol (not including the binary
999 * operators):
1000 * T -> defined(variable) | make(target) | exists(file) | symbol
1001 * T -> ! T | ( E )
1002 *
1003 * Results:
1004 * TOK_TRUE, TOK_FALSE or TOK_ERROR.
1005 *
1006 * Side Effects:
1007 * Tokens are consumed.
1008 *
1009 *-----------------------------------------------------------------------
1010 */
1011 static Token
CondT(Boolean doEval)1012 CondT(Boolean doEval)
1013 {
1014 Token t;
1015
1016 t = CondToken(doEval);
1017
1018 if (t == TOK_EOF) {
1019 /*
1020 * If we reached the end of the expression, the expression
1021 * is malformed...
1022 */
1023 t = TOK_ERROR;
1024 } else if (t == TOK_LPAREN) {
1025 /*
1026 * T -> ( E )
1027 */
1028 t = CondE(doEval);
1029 if (t != TOK_ERROR) {
1030 if (CondToken(doEval) != TOK_RPAREN) {
1031 t = TOK_ERROR;
1032 }
1033 }
1034 } else if (t == TOK_NOT) {
1035 t = CondT(doEval);
1036 if (t == TOK_TRUE) {
1037 t = TOK_FALSE;
1038 } else if (t == TOK_FALSE) {
1039 t = TOK_TRUE;
1040 }
1041 }
1042 return (t);
1043 }
1044
1045 /*-
1046 *-----------------------------------------------------------------------
1047 * CondF --
1048 * Parse a conjunctive factor (nice name, wot?)
1049 * F -> T && F | T
1050 *
1051 * Results:
1052 * TOK_TRUE, TOK_FALSE or TOK_ERROR
1053 *
1054 * Side Effects:
1055 * Tokens are consumed.
1056 *
1057 *-----------------------------------------------------------------------
1058 */
1059 static Token
CondF(Boolean doEval)1060 CondF(Boolean doEval)
1061 {
1062 Token l, o;
1063
1064 l = CondT(doEval);
1065 if (l != TOK_ERROR) {
1066 o = CondToken(doEval);
1067
1068 if (o == TOK_AND) {
1069 /*
1070 * F -> T && F
1071 *
1072 * If T is TOK_FALSE, the whole thing will be TOK_FALSE, but we have to
1073 * parse the r.h.s. anyway (to throw it away).
1074 * If T is TOK_TRUE, the result is the r.h.s., be it an TOK_ERROR or no.
1075 */
1076 if (l == TOK_TRUE) {
1077 l = CondF(doEval);
1078 } else {
1079 (void)CondF(FALSE);
1080 }
1081 } else {
1082 /*
1083 * F -> T
1084 */
1085 CondPushBack(o);
1086 }
1087 }
1088 return (l);
1089 }
1090
1091 /*-
1092 *-----------------------------------------------------------------------
1093 * CondE --
1094 * Main expression production.
1095 * E -> F || E | F
1096 *
1097 * Results:
1098 * TOK_TRUE, TOK_FALSE or TOK_ERROR.
1099 *
1100 * Side Effects:
1101 * Tokens are, of course, consumed.
1102 *
1103 *-----------------------------------------------------------------------
1104 */
1105 static Token
CondE(Boolean doEval)1106 CondE(Boolean doEval)
1107 {
1108 Token l, o;
1109
1110 l = CondF(doEval);
1111 if (l != TOK_ERROR) {
1112 o = CondToken(doEval);
1113
1114 if (o == TOK_OR) {
1115 /*
1116 * E -> F || E
1117 *
1118 * A similar thing occurs for ||, except that here we make sure
1119 * the l.h.s. is TOK_FALSE before we bother to evaluate the r.h.s.
1120 * Once again, if l is TOK_FALSE, the result is the r.h.s. and once
1121 * again if l is TOK_TRUE, we parse the r.h.s. to throw it away.
1122 */
1123 if (l == TOK_FALSE) {
1124 l = CondE(doEval);
1125 } else {
1126 (void)CondE(FALSE);
1127 }
1128 } else {
1129 /*
1130 * E -> F
1131 */
1132 CondPushBack(o);
1133 }
1134 }
1135 return (l);
1136 }
1137
1138 /*-
1139 *-----------------------------------------------------------------------
1140 * Cond_EvalExpression --
1141 * Evaluate an expression in the passed line. The expression
1142 * consists of &&, ||, !, make(target), defined(variable)
1143 * and parenthetical groupings thereof.
1144 *
1145 * Results:
1146 * COND_PARSE if the condition was valid grammatically
1147 * COND_INVALID if not a valid conditional.
1148 *
1149 * (*value) is set to the boolean value of the condition
1150 *
1151 * Side Effects:
1152 * None.
1153 *
1154 *-----------------------------------------------------------------------
1155 */
1156 int
Cond_EvalExpression(const struct If * info,char * line,Boolean * value,int eprint,Boolean strictLHS)1157 Cond_EvalExpression(const struct If *info, char *line, Boolean *value, int eprint, Boolean strictLHS)
1158 {
1159 static const struct If *dflt_info;
1160 const struct If *sv_if_info = if_info;
1161 char *sv_condExpr = condExpr;
1162 Token sv_condPushBack = condPushBack;
1163 int rval;
1164
1165 lhsStrict = strictLHS;
1166
1167 while (*line == ' ' || *line == '\t')
1168 line++;
1169
1170 if (info == NULL && (info = dflt_info) == NULL) {
1171 /* Scan for the entry for .if - it can't be first */
1172 for (info = ifs; ; info++)
1173 if (info->form[0] == 0)
1174 break;
1175 dflt_info = info;
1176 }
1177
1178 if_info = info != NULL ? info : ifs + 4;
1179 condExpr = line;
1180 condPushBack = TOK_NONE;
1181
1182 rval = do_Cond_EvalExpression(value);
1183
1184 if (rval == COND_INVALID && eprint)
1185 Parse_Error(PARSE_FATAL, "Malformed conditional (%s)", line);
1186
1187 if_info = sv_if_info;
1188 condExpr = sv_condExpr;
1189 condPushBack = sv_condPushBack;
1190
1191 return rval;
1192 }
1193
1194 static int
do_Cond_EvalExpression(Boolean * value)1195 do_Cond_EvalExpression(Boolean *value)
1196 {
1197
1198 switch (CondE(TRUE)) {
1199 case TOK_TRUE:
1200 if (CondToken(TRUE) == TOK_EOF) {
1201 *value = TRUE;
1202 return COND_PARSE;
1203 }
1204 break;
1205 case TOK_FALSE:
1206 if (CondToken(TRUE) == TOK_EOF) {
1207 *value = FALSE;
1208 return COND_PARSE;
1209 }
1210 break;
1211 default:
1212 case TOK_ERROR:
1213 break;
1214 }
1215
1216 return COND_INVALID;
1217 }
1218
1219
1220 /*-
1221 *-----------------------------------------------------------------------
1222 * Cond_Eval --
1223 * Evaluate the conditional in the passed line. The line
1224 * looks like this:
1225 * .<cond-type> <expr>
1226 * where <cond-type> is any of if, ifmake, ifnmake, ifdef,
1227 * ifndef, elif, elifmake, elifnmake, elifdef, elifndef
1228 * and <expr> consists of &&, ||, !, make(target), defined(variable)
1229 * and parenthetical groupings thereof.
1230 *
1231 * Input:
1232 * line Line to parse
1233 *
1234 * Results:
1235 * COND_PARSE if should parse lines after the conditional
1236 * COND_SKIP if should skip lines after the conditional
1237 * COND_INVALID if not a valid conditional.
1238 *
1239 * Side Effects:
1240 * None.
1241 *
1242 * Note that the states IF_ACTIVE and ELSE_ACTIVE are only different in order
1243 * to detect splurious .else lines (as are SKIP_TO_ELSE and SKIP_TO_ENDIF)
1244 * otherwise .else could be treated as '.elif 1'.
1245 *
1246 *-----------------------------------------------------------------------
1247 */
1248 int
Cond_Eval(char * line)1249 Cond_Eval(char *line)
1250 {
1251 #define MAXIF 128 /* maximum depth of .if'ing */
1252 #define MAXIF_BUMP 32 /* how much to grow by */
1253 enum if_states {
1254 IF_ACTIVE, /* .if or .elif part active */
1255 ELSE_ACTIVE, /* .else part active */
1256 SEARCH_FOR_ELIF, /* searching for .elif/else to execute */
1257 SKIP_TO_ELSE, /* has been true, but not seen '.else' */
1258 SKIP_TO_ENDIF /* nothing else to execute */
1259 };
1260 static enum if_states *cond_state = NULL;
1261 static unsigned int max_if_depth = MAXIF;
1262
1263 const struct If *ifp;
1264 Boolean isElif;
1265 Boolean value;
1266 int level; /* Level at which to report errors. */
1267 enum if_states state;
1268
1269 level = PARSE_FATAL;
1270 if (!cond_state) {
1271 cond_state = bmake_malloc(max_if_depth * sizeof(*cond_state));
1272 cond_state[0] = IF_ACTIVE;
1273 }
1274 /* skip leading character (the '.') and any whitespace */
1275 for (line++; *line == ' ' || *line == '\t'; line++)
1276 continue;
1277
1278 /* Find what type of if we're dealing with. */
1279 if (line[0] == 'e') {
1280 if (line[1] != 'l') {
1281 if (!istoken(line + 1, "ndif", 4))
1282 return COND_INVALID;
1283 /* End of conditional section */
1284 if (cond_depth == cond_min_depth) {
1285 Parse_Error(level, "if-less endif");
1286 return COND_PARSE;
1287 }
1288 /* Return state for previous conditional */
1289 cond_depth--;
1290 return cond_state[cond_depth] <= ELSE_ACTIVE ? COND_PARSE : COND_SKIP;
1291 }
1292
1293 /* Quite likely this is 'else' or 'elif' */
1294 line += 2;
1295 if (istoken(line, "se", 2)) {
1296 /* It is else... */
1297 if (cond_depth == cond_min_depth) {
1298 Parse_Error(level, "if-less else");
1299 return COND_PARSE;
1300 }
1301
1302 state = cond_state[cond_depth];
1303 switch (state) {
1304 case SEARCH_FOR_ELIF:
1305 state = ELSE_ACTIVE;
1306 break;
1307 case ELSE_ACTIVE:
1308 case SKIP_TO_ENDIF:
1309 Parse_Error(PARSE_WARNING, "extra else");
1310 /* FALLTHROUGH */
1311 default:
1312 case IF_ACTIVE:
1313 case SKIP_TO_ELSE:
1314 state = SKIP_TO_ENDIF;
1315 break;
1316 }
1317 cond_state[cond_depth] = state;
1318 return state <= ELSE_ACTIVE ? COND_PARSE : COND_SKIP;
1319 }
1320 /* Assume for now it is an elif */
1321 isElif = TRUE;
1322 } else
1323 isElif = FALSE;
1324
1325 if (line[0] != 'i' || line[1] != 'f')
1326 /* Not an ifxxx or elifxxx line */
1327 return COND_INVALID;
1328
1329 /*
1330 * Figure out what sort of conditional it is -- what its default
1331 * function is, etc. -- by looking in the table of valid "ifs"
1332 */
1333 line += 2;
1334 for (ifp = ifs; ; ifp++) {
1335 if (ifp->form == NULL)
1336 return COND_INVALID;
1337 if (istoken(ifp->form, line, ifp->formlen)) {
1338 line += ifp->formlen;
1339 break;
1340 }
1341 }
1342
1343 /* Now we know what sort of 'if' it is... */
1344
1345 if (isElif) {
1346 if (cond_depth == cond_min_depth) {
1347 Parse_Error(level, "if-less elif");
1348 return COND_PARSE;
1349 }
1350 state = cond_state[cond_depth];
1351 if (state == SKIP_TO_ENDIF || state == ELSE_ACTIVE) {
1352 Parse_Error(PARSE_WARNING, "extra elif");
1353 cond_state[cond_depth] = SKIP_TO_ENDIF;
1354 return COND_SKIP;
1355 }
1356 if (state != SEARCH_FOR_ELIF) {
1357 /* Either just finished the 'true' block, or already SKIP_TO_ELSE */
1358 cond_state[cond_depth] = SKIP_TO_ELSE;
1359 return COND_SKIP;
1360 }
1361 } else {
1362 /* Normal .if */
1363 if (cond_depth + 1 >= max_if_depth) {
1364 /*
1365 * This is rare, but not impossible.
1366 * In meta mode, dirdeps.mk (only runs at level 0)
1367 * can need more than the default.
1368 */
1369 max_if_depth += MAXIF_BUMP;
1370 cond_state = bmake_realloc(cond_state, max_if_depth *
1371 sizeof(*cond_state));
1372 }
1373 state = cond_state[cond_depth];
1374 cond_depth++;
1375 if (state > ELSE_ACTIVE) {
1376 /* If we aren't parsing the data, treat as always false */
1377 cond_state[cond_depth] = SKIP_TO_ELSE;
1378 return COND_SKIP;
1379 }
1380 }
1381
1382 /* And evaluate the conditional expresssion */
1383 if (Cond_EvalExpression(ifp, line, &value, 1, TRUE) == COND_INVALID) {
1384 /* Syntax error in conditional, error message already output. */
1385 /* Skip everything to matching .endif */
1386 cond_state[cond_depth] = SKIP_TO_ELSE;
1387 return COND_SKIP;
1388 }
1389
1390 if (!value) {
1391 cond_state[cond_depth] = SEARCH_FOR_ELIF;
1392 return COND_SKIP;
1393 }
1394 cond_state[cond_depth] = IF_ACTIVE;
1395 return COND_PARSE;
1396 }
1397
1398
1399
1400 /*-
1401 *-----------------------------------------------------------------------
1402 * Cond_End --
1403 * Make sure everything's clean at the end of a makefile.
1404 *
1405 * Results:
1406 * None.
1407 *
1408 * Side Effects:
1409 * Parse_Error will be called if open conditionals are around.
1410 *
1411 *-----------------------------------------------------------------------
1412 */
1413 void
Cond_restore_depth(unsigned int saved_depth)1414 Cond_restore_depth(unsigned int saved_depth)
1415 {
1416 int open_conds = cond_depth - cond_min_depth;
1417
1418 if (open_conds != 0 || saved_depth > cond_depth) {
1419 Parse_Error(PARSE_FATAL, "%d open conditional%s", open_conds,
1420 open_conds == 1 ? "" : "s");
1421 cond_depth = cond_min_depth;
1422 }
1423
1424 cond_min_depth = saved_depth;
1425 }
1426
1427 unsigned int
Cond_save_depth(void)1428 Cond_save_depth(void)
1429 {
1430 int depth = cond_min_depth;
1431
1432 cond_min_depth = cond_depth;
1433 return depth;
1434 }
1435