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