contrib/bmake/cond.c

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