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