1/*	$NetBSD: cond.c,v 1.74 2016/02/18 18:29:14 christos 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
73static char rcsid[] = "$NetBSD: cond.c,v 1.74 2016/02/18 18:29:14 christos Exp $";
74#else
75#include <sys/cdefs.h>
76#ifndef lint
77#if 0
78static char sccsid[] = "@(#)cond.c	8.2 (Berkeley) 1/2/94";
79#else
80__RCSID("$NetBSD: cond.c,v 1.74 2016/02/18 18:29:14 christos 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 */
138typedef 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 */
147static void CondPushBack(Token);
148static int CondGetArg(char **, char **, const char *);
149static Boolean CondDoDefined(int, const char *);
150static int CondStrMatch(const void *, const void *);
151static Boolean CondDoMake(int, const char *);
152static Boolean CondDoExists(int, const char *);
153static Boolean CondDoTarget(int, const char *);
154static Boolean CondDoCommands(int, const char *);
155static Boolean CondCvtArg(char *, double *);
156static Token CondToken(Boolean);
157static Token CondT(Boolean);
158static Token CondF(Boolean);
159static Token CondE(Boolean);
160static int do_Cond_EvalExpression(Boolean *);
161
162static 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
176static const struct If *if_info;        /* Info for current statement */
177static char 	  *condExpr;	    	/* The expression to parse */
178static Token	  condPushBack=TOK_NONE;	/* Single push-back token used in
179					 * parsing */
180
181static unsigned int	cond_depth = 0;  	/* current .if nesting level */
182static 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 */
191static Boolean lhsStrict;
192
193static int
194istoken(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 */
216static void
217CondPushBack(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 */
239static int
240CondGetArg(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, VARF_UNDEFERR|VARF_WANTRES,
293			    &len, &freeIt);
294	    Buf_AddBytes(&buf, strlen(cp2), cp2);
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 */
338static Boolean
339CondDoDefined(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
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 */
368static int
369CondStrMatch(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 */
387static Boolean
388CondDoMake(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 */
406static Boolean
407CondDoExists(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 */
439static Boolean
440CondDoTarget(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 */
463static Boolean
464CondDoCommands(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 */
485static Boolean
486CondCvtArg(char *str, double *value)
487{
488    char *eptr, ech;
489    unsigned long l_val;
490    double d_val;
491
492    errno = 0;
493    if (!*str) {
494	*value = (double)0;
495	return TRUE;
496    }
497    l_val = strtoul(str, &eptr, str[1] == 'x' ? 16 : 10);
498    ech = *eptr;
499    if (ech == 0 && errno != ERANGE) {
500	d_val = str[0] == '-' ? -(double)-l_val : (double)l_val;
501    } else {
502	if (ech != 0 && ech != '.' && ech != 'e' && ech != 'E')
503	    return FALSE;
504	d_val = strtod(str, &eptr);
505	if (*eptr)
506	    return FALSE;
507    }
508
509    *value = d_val;
510    return TRUE;
511}
512
513/*-
514 *-----------------------------------------------------------------------
515 * CondGetString --
516 *	Get a string from a variable reference or an optionally quoted
517 *	string.  This is called for the lhs and rhs of string compares.
518 *
519 * Results:
520 *	Sets freeIt if needed,
521 *	Sets quoted if string was quoted,
522 *	Returns NULL on error,
523 *	else returns string - absent any quotes.
524 *
525 * Side Effects:
526 *	Moves condExpr to end of this token.
527 *
528 *
529 *-----------------------------------------------------------------------
530 */
531/* coverity:[+alloc : arg-*2] */
532static char *
533CondGetString(Boolean doEval, Boolean *quoted, void **freeIt, Boolean strictLHS)
534{
535    Buffer buf;
536    char *cp;
537    char *str;
538    int	len;
539    int qt;
540    char *start;
541
542    Buf_Init(&buf, 0);
543    str = NULL;
544    *freeIt = NULL;
545    *quoted = qt = *condExpr == '"' ? 1 : 0;
546    if (qt)
547	condExpr++;
548    for (start = condExpr; *condExpr && str == NULL; condExpr++) {
549	switch (*condExpr) {
550	case '\\':
551	    if (condExpr[1] != '\0') {
552		condExpr++;
553		Buf_AddByte(&buf, *condExpr);
554	    }
555	    break;
556	case '"':
557	    if (qt) {
558		condExpr++;		/* we don't want the quotes */
559		goto got_str;
560	    } else
561		Buf_AddByte(&buf, *condExpr); /* likely? */
562	    break;
563	case ')':
564	case '!':
565	case '=':
566	case '>':
567	case '<':
568	case ' ':
569	case '\t':
570	    if (!qt)
571		goto got_str;
572	    else
573		Buf_AddByte(&buf, *condExpr);
574	    break;
575	case '$':
576	    /* if we are in quotes, then an undefined variable is ok */
577	    str = Var_Parse(condExpr, VAR_CMD,
578			    ((!qt && doEval) ? VARF_UNDEFERR : 0) |
579			    VARF_WANTRES, &len, freeIt);
580	    if (str == var_Error) {
581		if (*freeIt) {
582		    free(*freeIt);
583		    *freeIt = NULL;
584		}
585		/*
586		 * Even if !doEval, we still report syntax errors, which
587		 * is what getting var_Error back with !doEval means.
588		 */
589		str = NULL;
590		goto cleanup;
591	    }
592	    condExpr += len;
593	    /*
594	     * If the '$' was first char (no quotes), and we are
595	     * followed by space, the operator or end of expression,
596	     * we are done.
597	     */
598	    if ((condExpr == start + len) &&
599		(*condExpr == '\0' ||
600		 isspace((unsigned char) *condExpr) ||
601		 strchr("!=><)", *condExpr))) {
602		goto cleanup;
603	    }
604	    /*
605	     * Nope, we better copy str to buf
606	     */
607	    for (cp = str; *cp; cp++) {
608		Buf_AddByte(&buf, *cp);
609	    }
610	    if (*freeIt) {
611		free(*freeIt);
612		*freeIt = NULL;
613	    }
614	    str = NULL;			/* not finished yet */
615	    condExpr--;			/* don't skip over next char */
616	    break;
617	default:
618	    if (strictLHS && !qt && *start != '$' &&
619		!isdigit((unsigned char) *start)) {
620		/* lhs must be quoted, a variable reference or number */
621		if (*freeIt) {
622		    free(*freeIt);
623		    *freeIt = NULL;
624		}
625		str = NULL;
626		goto cleanup;
627	    }
628	    Buf_AddByte(&buf, *condExpr);
629	    break;
630	}
631    }
632 got_str:
633    str = Buf_GetAll(&buf, NULL);
634    *freeIt = str;
635 cleanup:
636    Buf_Destroy(&buf, FALSE);
637    return str;
638}
639
640/*-
641 *-----------------------------------------------------------------------
642 * CondToken --
643 *	Return the next token from the input.
644 *
645 * Results:
646 *	A Token for the next lexical token in the stream.
647 *
648 * Side Effects:
649 *	condPushback will be set back to TOK_NONE if it is used.
650 *
651 *-----------------------------------------------------------------------
652 */
653static Token
654compare_expression(Boolean doEval)
655{
656    Token	t;
657    char	*lhs;
658    char	*rhs;
659    char	*op;
660    void	*lhsFree;
661    void	*rhsFree;
662    Boolean lhsQuoted;
663    Boolean rhsQuoted;
664    double  	left, right;
665
666    t = TOK_ERROR;
667    rhs = NULL;
668    lhsFree = rhsFree = FALSE;
669    lhsQuoted = rhsQuoted = FALSE;
670
671    /*
672     * Parse the variable spec and skip over it, saving its
673     * value in lhs.
674     */
675    lhs = CondGetString(doEval, &lhsQuoted, &lhsFree, lhsStrict);
676    if (!lhs)
677	goto done;
678
679    /*
680     * Skip whitespace to get to the operator
681     */
682    while (isspace((unsigned char) *condExpr))
683	condExpr++;
684
685    /*
686     * Make sure the operator is a valid one. If it isn't a
687     * known relational operator, pretend we got a
688     * != 0 comparison.
689     */
690    op = condExpr;
691    switch (*condExpr) {
692	case '!':
693	case '=':
694	case '<':
695	case '>':
696	    if (condExpr[1] == '=') {
697		condExpr += 2;
698	    } else {
699		condExpr += 1;
700	    }
701	    break;
702	default:
703	    if (!doEval) {
704		t = TOK_FALSE;
705		goto done;
706	    }
707	    /* For .ifxxx "..." check for non-empty string. */
708	    if (lhsQuoted) {
709		t = lhs[0] != 0;
710		goto done;
711	    }
712	    /* For .ifxxx <number> compare against zero */
713	    if (CondCvtArg(lhs, &left)) {
714		t = left != 0.0;
715		goto done;
716	    }
717	    /* For .if ${...} check for non-empty string (defProc is ifdef). */
718	    if (if_info->form[0] == 0) {
719		t = lhs[0] != 0;
720		goto done;
721	    }
722	    /* Otherwise action default test ... */
723	    t = if_info->defProc(strlen(lhs), lhs) != if_info->doNot;
724	    goto done;
725    }
726
727    while (isspace((unsigned char)*condExpr))
728	condExpr++;
729
730    if (*condExpr == '\0') {
731	Parse_Error(PARSE_WARNING,
732		    "Missing right-hand-side of operator");
733	goto done;
734    }
735
736    rhs = CondGetString(doEval, &rhsQuoted, &rhsFree, FALSE);
737    if (!rhs)
738	goto done;
739
740    if (rhsQuoted || lhsQuoted) {
741do_string_compare:
742	if (((*op != '!') && (*op != '=')) || (op[1] != '=')) {
743	    Parse_Error(PARSE_WARNING,
744    "String comparison operator should be either == or !=");
745	    goto done;
746	}
747
748	if (DEBUG(COND)) {
749	    fprintf(debug_file, "lhs = \"%s\", rhs = \"%s\", op = %.2s\n",
750		   lhs, rhs, op);
751	}
752	/*
753	 * Null-terminate rhs and perform the comparison.
754	 * t is set to the result.
755	 */
756	if (*op == '=') {
757	    t = strcmp(lhs, rhs) == 0;
758	} else {
759	    t = strcmp(lhs, rhs) != 0;
760	}
761    } else {
762	/*
763	 * rhs is either a float or an integer. Convert both the
764	 * lhs and the rhs to a double and compare the two.
765	 */
766
767	if (!CondCvtArg(lhs, &left) || !CondCvtArg(rhs, &right))
768	    goto do_string_compare;
769
770	if (DEBUG(COND)) {
771	    fprintf(debug_file, "left = %f, right = %f, op = %.2s\n", left,
772		   right, op);
773	}
774	switch(op[0]) {
775	case '!':
776	    if (op[1] != '=') {
777		Parse_Error(PARSE_WARNING,
778			    "Unknown operator");
779		goto done;
780	    }
781	    t = (left != right);
782	    break;
783	case '=':
784	    if (op[1] != '=') {
785		Parse_Error(PARSE_WARNING,
786			    "Unknown operator");
787		goto done;
788	    }
789	    t = (left == right);
790	    break;
791	case '<':
792	    if (op[1] == '=') {
793		t = (left <= right);
794	    } else {
795		t = (left < right);
796	    }
797	    break;
798	case '>':
799	    if (op[1] == '=') {
800		t = (left >= right);
801	    } else {
802		t = (left > right);
803	    }
804	    break;
805	}
806    }
807
808done:
809    free(lhsFree);
810    free(rhsFree);
811    return t;
812}
813
814static int
815get_mpt_arg(char **linePtr, char **argPtr, const char *func MAKE_ATTR_UNUSED)
816{
817    /*
818     * Use Var_Parse to parse the spec in parens and return
819     * TOK_TRUE if the resulting string is empty.
820     */
821    int	    length;
822    void    *freeIt;
823    char    *val;
824    char    *cp = *linePtr;
825
826    /* We do all the work here and return the result as the length */
827    *argPtr = NULL;
828
829    val = Var_Parse(cp - 1, VAR_CMD, VARF_WANTRES, &length, &freeIt);
830    /*
831     * Advance *linePtr to beyond the closing ). Note that
832     * we subtract one because 'length' is calculated from 'cp - 1'.
833     */
834    *linePtr = cp - 1 + length;
835
836    if (val == var_Error) {
837	free(freeIt);
838	return -1;
839    }
840
841    /* A variable is empty when it just contains spaces... 4/15/92, christos */
842    while (isspace(*(unsigned char *)val))
843	val++;
844
845    /*
846     * For consistency with the other functions we can't generate the
847     * true/false here.
848     */
849    length = *val ? 2 : 1;
850    free(freeIt);
851    return length;
852}
853
854static Boolean
855CondDoEmpty(int arglen, const char *arg MAKE_ATTR_UNUSED)
856{
857    return arglen == 1;
858}
859
860static Token
861compare_function(Boolean doEval)
862{
863    static const struct fn_def {
864	const char  *fn_name;
865	int         fn_name_len;
866        int         (*fn_getarg)(char **, char **, const char *);
867	Boolean     (*fn_proc)(int, const char *);
868    } fn_defs[] = {
869	{ "defined",   7, CondGetArg, CondDoDefined },
870	{ "make",      4, CondGetArg, CondDoMake },
871	{ "exists",    6, CondGetArg, CondDoExists },
872	{ "empty",     5, get_mpt_arg, CondDoEmpty },
873	{ "target",    6, CondGetArg, CondDoTarget },
874	{ "commands",  8, CondGetArg, CondDoCommands },
875	{ NULL,        0, NULL, NULL },
876    };
877    const struct fn_def *fn_def;
878    Token	t;
879    char	*arg = NULL;
880    int	arglen;
881    char *cp = condExpr;
882    char *cp1;
883
884    for (fn_def = fn_defs; fn_def->fn_name != NULL; fn_def++) {
885	if (!istoken(cp, fn_def->fn_name, fn_def->fn_name_len))
886	    continue;
887	cp += fn_def->fn_name_len;
888	/* There can only be whitespace before the '(' */
889	while (isspace(*(unsigned char *)cp))
890	    cp++;
891	if (*cp != '(')
892	    break;
893
894	arglen = fn_def->fn_getarg(&cp, &arg, fn_def->fn_name);
895	if (arglen <= 0) {
896	    condExpr = cp;
897	    return arglen < 0 ? TOK_ERROR : TOK_FALSE;
898	}
899	/* Evaluate the argument using the required function. */
900	t = !doEval || fn_def->fn_proc(arglen, arg);
901	free(arg);
902	condExpr = cp;
903	return t;
904    }
905
906    /* Push anything numeric through the compare expression */
907    cp = condExpr;
908    if (isdigit((unsigned char)cp[0]) || strchr("+-", cp[0]))
909	return compare_expression(doEval);
910
911    /*
912     * Most likely we have a naked token to apply the default function to.
913     * However ".if a == b" gets here when the "a" is unquoted and doesn't
914     * start with a '$'. This surprises people.
915     * If what follows the function argument is a '=' or '!' then the syntax
916     * would be invalid if we did "defined(a)" - so instead treat as an
917     * expression.
918     */
919    arglen = CondGetArg(&cp, &arg, NULL);
920    for (cp1 = cp; isspace(*(unsigned char *)cp1); cp1++)
921	continue;
922    if (*cp1 == '=' || *cp1 == '!')
923	return compare_expression(doEval);
924    condExpr = cp;
925
926    /*
927     * Evaluate the argument using the default function.
928     * This path always treats .if as .ifdef. To get here the character
929     * after .if must have been taken literally, so the argument cannot
930     * be empty - even if it contained a variable expansion.
931     */
932    t = !doEval || if_info->defProc(arglen, arg) != if_info->doNot;
933    free(arg);
934    return t;
935}
936
937static Token
938CondToken(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 */
1011static Token
1012CondT(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 */
1059static Token
1060CondF(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 */
1105static Token
1106CondE(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 */
1156int
1157Cond_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
1194static int
1195do_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 */
1248int
1249Cond_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 */
1413void
1414Cond_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
1427unsigned int
1428Cond_save_depth(void)
1429{
1430    int depth = cond_min_depth;
1431
1432    cond_min_depth = cond_depth;
1433    return depth;
1434}
1435