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