contrib/bmake/cond.c

   1 /*      $NetBSD: cond.c,v 1.256 2021/02/05 05:15:12 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 /*
  73  * Handling of conditionals in a makefile.
  74  *
  75  * Interface:
  76  *      Cond_EvalLine   Evaluate the conditional directive, such as
  77  *                      '.if <cond>', '.elifnmake <cond>', '.else', '.endif'.
  78  *
  79  *      Cond_EvalCondition
  80  *                      Evaluate the conditional, which is either the argument
  81  *                      of one of the .if directives or the condition in a
  82  *                      ':?then:else' variable modifier.
  83  *
  84  *      Cond_save_depth
  85  *      Cond_restore_depth
  86  *                      Save and restore the nesting of the conditions, at
  87  *                      the start and end of including another makefile, to
  88  *                      ensure that in each makefile the conditional
  89  *                      directives are well-balanced.
  90  */
  91
  92 #include <errno.h>
  93
  94 #include "make.h"
  95 #include "dir.h"
  96
  97 /*      "@(#)cond.c     8.2 (Berkeley) 1/2/94"  */
  98 MAKE_RCSID("$NetBSD: cond.c,v 1.256 2021/02/05 05:15:12 rillig Exp $");
  99
 100 /*
 101  * The parsing of conditional expressions is based on this grammar:
 102  *      Or -> And '||' Or
 103  *      Or -> And
 104  *      And -> Term '&&' And
 105  *      And -> Term
 106  *      Term -> Function '(' Argument ')'
 107  *      Term -> Leaf Operator Leaf
 108  *      Term -> Leaf
 109  *      Term -> '(' Or ')'
 110  *      Term -> '!' Term
 111  *      Leaf -> "string"
 112  *      Leaf -> Number
 113  *      Leaf -> VariableExpression
 114  *      Leaf -> Symbol
 115  *      Operator -> '==' | '!=' | '>' | '<' | '>=' | '<='
 116  *
 117  * 'Symbol' is an unquoted string literal to which the default function is
 118  * applied.
 119  *
 120  * The tokens are scanned by CondToken, which returns:
 121  *      TOK_AND         for '&&'
 122  *      TOK_OR          for '||'
 123  *      TOK_NOT         for '!'
 124  *      TOK_LPAREN      for '('
 125  *      TOK_RPAREN      for ')'
 126  *
 127  * Other terminal symbols are evaluated using either the default function or
 128  * the function given in the terminal, they return either TOK_TRUE or
 129  * TOK_FALSE.
 130  */
 131 typedef enum Token {
 132         TOK_FALSE, TOK_TRUE, TOK_AND, TOK_OR, TOK_NOT,
 133         TOK_LPAREN, TOK_RPAREN, TOK_EOF, TOK_NONE, TOK_ERROR
 134 } Token;
 135
 136 typedef enum CondResult {
 137         CR_FALSE, CR_TRUE, CR_ERROR
 138 } CondResult;
 139
 140 typedef enum ComparisonOp {
 141         LT, LE, GT, GE, EQ, NE
 142 } ComparisonOp;
 143
 144 typedef struct CondParser {
 145
 146         /*
 147          * The plain '.if ${VAR}' evaluates to true if the value of the
 148          * expression has length > 0.  The other '.if' variants delegate
 149          * to evalBare instead.
 150          */
 151         Boolean plain;
 152
 153         /* The function to apply on unquoted bare words. */
 154         Boolean (*evalBare)(size_t, const char *);
 155         Boolean negateEvalBare;
 156
 157         const char *p;          /* The remaining condition to parse */
 158         Token curr;             /* Single push-back token used in parsing */
 159
 160         /*
 161          * Whether an error message has already been printed for this
 162          * condition. The first available error message is usually the most
 163          * specific one, therefore it makes sense to suppress the standard
 164          * "Malformed conditional" message.
 165          */
 166         Boolean printedError;
 167 } CondParser;
 168
 169 static CondResult CondParser_Or(CondParser *par, Boolean);
 170
 171 static unsigned int cond_depth = 0;     /* current .if nesting level */
 172 static unsigned int cond_min_depth = 0; /* depth at makefile open */
 173
 174 static const char *opname[] = { "<", "<=", ">", ">=", "==", "!=" };
 175
 176 /*
 177  * Indicate when we should be strict about lhs of comparisons.
 178  * In strict mode, the lhs must be a variable expression or a string literal
 179  * in quotes. In non-strict mode it may also be an unquoted string literal.
 180  *
 181  * TRUE when CondEvalExpression is called from Cond_EvalLine (.if etc)
 182  * FALSE when CondEvalExpression is called from ApplyModifier_IfElse
 183  * since lhs is already expanded, and at that point we cannot tell if
 184  * it was a variable reference or not.
 185  */
 186 static Boolean lhsStrict;
 187
 188 static Boolean
 189 is_token(const char *str, const char *tok, size_t len)
 190 {
 191         return strncmp(str, tok, len) == 0 && !ch_isalpha(str[len]);
 192 }
 193
 194 static Token
 195 ToToken(Boolean cond)
 196 {
 197         return cond ? TOK_TRUE : TOK_FALSE;
 198 }
 199
 200 /* Push back the most recent token read. We only need one level of this. */
 201 static void
 202 CondParser_PushBack(CondParser *par, Token t)
 203 {
 204         assert(par->curr == TOK_NONE);
 205         assert(t != TOK_NONE);
 206
 207         par->curr = t;
 208 }
 209
 210 static void
 211 CondParser_SkipWhitespace(CondParser *par)
 212 {
 213         cpp_skip_whitespace(&par->p);
 214 }
 215
 216 /*
 217  * Parse the argument of a built-in function.
 218  *
 219  * Arguments:
 220  *      *pp initially points at the '(',
 221  *      upon successful return it points right after the ')'.
 222  *
 223  *      *out_arg receives the argument as string.
 224  *
 225  *      func says whether the argument belongs to an actual function, or
 226  *      whether the parsed argument is passed to the default function.
 227  *
 228  * Return the length of the argument, or 0 on error.
 229  */
 230 static size_t
 231 ParseFuncArg(CondParser *par, const char **pp, Boolean doEval, const char *func,
 232              char **out_arg)
 233 {
 234         const char *p = *pp;
 235         Buffer argBuf;
 236         int paren_depth;
 237         size_t argLen;
 238
 239         if (func != NULL)
 240                 p++;            /* Skip opening '(' - verified by caller */
 241
 242         if (*p == '\0') {
 243                 *out_arg = NULL; /* Missing closing parenthesis: */
 244                 return 0;       /* .if defined( */
 245         }
 246
 247         cpp_skip_hspace(&p);
 248
 249         Buf_InitSize(&argBuf, 16);
 250
 251         paren_depth = 0;
 252         for (;;) {
 253                 char ch = *p;
 254                 if (ch == '\0' || ch == ' ' || ch == '\t')
 255                         break;
 256                 if ((ch == '&' || ch == '|') && paren_depth == 0)
 257                         break;
 258                 if (*p == '$') {
 259                         /*
 260                          * Parse the variable expression and install it as
 261                          * part of the argument if it's valid. We tell
 262                          * Var_Parse to complain on an undefined variable,
 263                          * (XXX: but Var_Parse ignores that request)
 264                          * so we don't need to do it. Nor do we return an
 265                          * error, though perhaps we should.
 266                          */
 267                         VarEvalFlags eflags = doEval
 268                             ? VARE_WANTRES | VARE_UNDEFERR
 269                             : VARE_NONE;
 270                         FStr nestedVal;
 271                         (void)Var_Parse(&p, SCOPE_CMDLINE, eflags, &nestedVal);
 272                         /* TODO: handle errors */
 273                         Buf_AddStr(&argBuf, nestedVal.str);
 274                         FStr_Done(&nestedVal);
 275                         continue;
 276                 }
 277                 if (ch == '(')
 278                         paren_depth++;
 279                 else if (ch == ')' && --paren_depth < 0)
 280                         break;
 281                 Buf_AddByte(&argBuf, *p);
 282                 p++;
 283         }
 284
 285         argLen = argBuf.len;
 286         *out_arg = Buf_DoneData(&argBuf);
 287
 288         cpp_skip_hspace(&p);
 289
 290         if (func != NULL && *p++ != ')') {
 291                 Parse_Error(PARSE_FATAL,
 292                     "Missing closing parenthesis for %s()", func);
 293                 par->printedError = TRUE;
 294                 return 0;
 295         }
 296
 297         *pp = p;
 298         return argLen;
 299 }
 300
 301 /* Test whether the given variable is defined. */
 302 /*ARGSUSED*/
 303 static Boolean
 304 FuncDefined(size_t argLen MAKE_ATTR_UNUSED, const char *arg)
 305 {
 306         FStr value = Var_Value(SCOPE_CMDLINE, arg);
 307         Boolean result = value.str != NULL;
 308         FStr_Done(&value);
 309         return result;
 310 }
 311
 312 /* See if the given target is being made. */
 313 /*ARGSUSED*/
 314 static Boolean
 315 FuncMake(size_t argLen MAKE_ATTR_UNUSED, const char *arg)
 316 {
 317         StringListNode *ln;
 318
 319         for (ln = opts.create.first; ln != NULL; ln = ln->next)
 320                 if (Str_Match(ln->datum, arg))
 321                         return TRUE;
 322         return FALSE;
 323 }
 324
 325 /* See if the given file exists. */
 326 /*ARGSUSED*/
 327 static Boolean
 328 FuncExists(size_t argLen MAKE_ATTR_UNUSED, const char *arg)
 329 {
 330         Boolean result;
 331         char *path;
 332
 333         path = Dir_FindFile(arg, &dirSearchPath);
 334         DEBUG2(COND, "exists(%s) result is \"%s\"\n",
 335                arg, path != NULL ? path : "");
 336         result = path != NULL;
 337         free(path);
 338         return result;
 339 }
 340
 341 /* See if the given node exists and is an actual target. */
 342 /*ARGSUSED*/
 343 static Boolean
 344 FuncTarget(size_t argLen MAKE_ATTR_UNUSED, const char *arg)
 345 {
 346         GNode *gn = Targ_FindNode(arg);
 347         return gn != NULL && GNode_IsTarget(gn);
 348 }
 349
 350 /*
 351  * See if the given node exists and is an actual target with commands
 352  * associated with it.
 353  */
 354 /*ARGSUSED*/
 355 static Boolean
 356 FuncCommands(size_t argLen MAKE_ATTR_UNUSED, const char *arg)
 357 {
 358         GNode *gn = Targ_FindNode(arg);
 359         return gn != NULL && GNode_IsTarget(gn) && !Lst_IsEmpty(&gn->commands);
 360 }
 361
 362 /*
 363  * Convert the given number into a double.
 364  * We try a base 10 or 16 integer conversion first, if that fails
 365  * then we try a floating point conversion instead.
 366  *
 367  * Results:
 368  *      Returns TRUE if the conversion succeeded.
 369  *      Sets 'out_value' to the converted number.
 370  */
 371 static Boolean
 372 TryParseNumber(const char *str, double *out_value)
 373 {
 374         char *end;
 375         unsigned long ul_val;
 376         double dbl_val;
 377
 378         errno = 0;
 379         if (str[0] == '\0') {   /* XXX: why is an empty string a number? */
 380                 *out_value = 0.0;
 381                 return TRUE;
 382         }
 383
 384         ul_val = strtoul(str, &end, str[1] == 'x' ? 16 : 10);
 385         if (*end == '\0' && errno != ERANGE) {
 386                 *out_value = str[0] == '-' ? -(double)-ul_val : (double)ul_val;
 387                 return TRUE;
 388         }
 389
 390         if (*end != '\0' && *end != '.' && *end != 'e' && *end != 'E')
 391                 return FALSE;   /* skip the expensive strtod call */
 392         dbl_val = strtod(str, &end);
 393         if (*end != '\0')
 394                 return FALSE;
 395
 396         *out_value = dbl_val;
 397         return TRUE;
 398 }
 399
 400 static Boolean
 401 is_separator(char ch)
 402 {
 403         return ch == '\0' || ch_isspace(ch) || strchr("!=><)", ch) != NULL;
 404 }
 405
 406 /*
 407  * In a quoted or unquoted string literal or a number, parse a variable
 408  * expression.
 409  *
 410  * Example: .if x${CENTER}y == "${PREFIX}${SUFFIX}" || 0x${HEX}
 411  */
 412 static Boolean
 413 CondParser_StringExpr(CondParser *par, const char *start,
 414                       Boolean const doEval, Boolean const quoted,
 415                       Buffer *buf, FStr *const inout_str)
 416 {
 417         VarEvalFlags eflags;
 418         const char *nested_p;
 419         Boolean atStart;
 420         VarParseResult parseResult;
 421
 422         /* if we are in quotes, an undefined variable is ok */
 423         eflags = doEval && !quoted ? VARE_WANTRES | VARE_UNDEFERR
 424             : doEval ? VARE_WANTRES
 425             : VARE_NONE;
 426
 427         nested_p = par->p;
 428         atStart = nested_p == start;
 429         parseResult = Var_Parse(&nested_p, SCOPE_CMDLINE, eflags, inout_str);
 430         /* TODO: handle errors */
 431         if (inout_str->str == var_Error) {
 432                 if (parseResult == VPR_ERR) {
 433                         /*
 434                          * FIXME: Even if an error occurs, there is no
 435                          *  guarantee that it is reported.
 436                          *
 437                          * See cond-token-plain.mk $$$$$$$$.
 438                          */
 439                         par->printedError = TRUE;
 440                 }
 441                 /*
 442                  * XXX: Can there be any situation in which a returned
 443                  * var_Error requires freeIt?
 444                  */
 445                 FStr_Done(inout_str);
 446                 /*
 447                  * Even if !doEval, we still report syntax errors, which is
 448                  * what getting var_Error back with !doEval means.
 449                  */
 450                 *inout_str = FStr_InitRefer(NULL);
 451                 return FALSE;
 452         }
 453         par->p = nested_p;
 454
 455         /*
 456          * If the '$' started the string literal (which means no quotes), and
 457          * the variable expression is followed by a space, looks like a
 458          * comparison operator or is the end of the expression, we are done.
 459          */
 460         if (atStart && is_separator(par->p[0]))
 461                 return FALSE;
 462
 463         Buf_AddStr(buf, inout_str->str);
 464         FStr_Done(inout_str);
 465         *inout_str = FStr_InitRefer(NULL); /* not finished yet */
 466         return TRUE;
 467 }
 468
 469 /*
 470  * Parse a string from a variable reference or an optionally quoted
 471  * string.  This is called for the lhs and rhs of string comparisons.
 472  *
 473  * Results:
 474  *      Returns the string, absent any quotes, or NULL on error.
 475  *      Sets out_quoted if the string was quoted.
 476  *      Sets out_freeIt.
 477  */
 478 static void
 479 CondParser_String(CondParser *par, Boolean doEval, Boolean strictLHS,
 480                   FStr *out_str, Boolean *out_quoted)
 481 {
 482         Buffer buf;
 483         FStr str;
 484         Boolean quoted;
 485         const char *start;
 486
 487         Buf_Init(&buf);
 488         str = FStr_InitRefer(NULL);
 489         *out_quoted = quoted = par->p[0] == '"';
 490         start = par->p;
 491         if (quoted)
 492                 par->p++;
 493
 494         while (par->p[0] != '\0' && str.str == NULL) {
 495                 switch (par->p[0]) {
 496                 case '\\':
 497                         par->p++;
 498                         if (par->p[0] != '\0') {
 499                                 Buf_AddByte(&buf, par->p[0]);
 500                                 par->p++;
 501                         }
 502                         continue;
 503                 case '"':
 504                         par->p++;
 505                         if (quoted)
 506                                 goto got_str;   /* skip the closing quote */
 507                         Buf_AddByte(&buf, '"');
 508                         continue;
 509                 case ')':       /* see is_separator */
 510                 case '!':
 511                 case '=':
 512                 case '>':
 513                 case '<':
 514                 case ' ':
 515                 case '\t':
 516                         if (!quoted)
 517                                 goto got_str;
 518                         Buf_AddByte(&buf, par->p[0]);
 519                         par->p++;
 520                         continue;
 521                 case '$':
 522                         if (!CondParser_StringExpr(par,
 523                             start, doEval, quoted, &buf, &str))
 524                                 goto cleanup;
 525                         continue;
 526                 default:
 527                         if (strictLHS && !quoted && *start != '$' &&
 528                             !ch_isdigit(*start)) {
 529                                 /*
 530                                  * The left-hand side must be quoted,
 531                                  * a variable reference or a number.
 532                                  */
 533                                 str = FStr_InitRefer(NULL);
 534                                 goto cleanup;
 535                         }
 536                         Buf_AddByte(&buf, par->p[0]);
 537                         par->p++;
 538                         continue;
 539                 }
 540         }
 541 got_str:
 542         str = FStr_InitOwn(buf.data);
 543 cleanup:
 544         Buf_DoneData(&buf);
 545         *out_str = str;
 546 }
 547
 548 static Boolean
 549 If_Eval(const CondParser *par, const char *arg, size_t arglen)
 550 {
 551         Boolean res = par->evalBare(arglen, arg);
 552         return par->negateEvalBare ? !res : res;
 553 }
 554
 555 /*
 556  * Evaluate a "comparison without operator", such as in ".if ${VAR}" or
 557  * ".if 0".
 558  */
 559 static Boolean
 560 EvalNotEmpty(CondParser *par, const char *value, Boolean quoted)
 561 {
 562         double num;
 563
 564         /* For .ifxxx "...", check for non-empty string. */
 565         if (quoted)
 566                 return value[0] != '\0';
 567
 568         /* For .ifxxx <number>, compare against zero */
 569         if (TryParseNumber(value, &num))
 570                 return num != 0.0;
 571
 572         /* For .if ${...}, check for non-empty string.  This is different from
 573          * the evaluation function from that .if variant, which would test
 574          * whether a variable of the given name were defined. */
 575         /* XXX: Whitespace should count as empty, just as in ParseEmptyArg. */
 576         if (par->plain)
 577                 return value[0] != '\0';
 578
 579         return If_Eval(par, value, strlen(value));
 580 }
 581
 582 /* Evaluate a numerical comparison, such as in ".if ${VAR} >= 9". */
 583 static Boolean
 584 EvalCompareNum(double lhs, ComparisonOp op, double rhs)
 585 {
 586         DEBUG3(COND, "lhs = %f, rhs = %f, op = %.2s\n", lhs, rhs, opname[op]);
 587
 588         switch (op) {
 589         case LT:
 590                 return lhs < rhs;
 591         case LE:
 592                 return lhs <= rhs;
 593         case GT:
 594                 return lhs > rhs;
 595         case GE:
 596                 return lhs >= rhs;
 597         case NE:
 598                 return lhs != rhs;
 599         default:
 600                 return lhs == rhs;
 601         }
 602 }
 603
 604 static Token
 605 EvalCompareStr(CondParser *par, const char *lhs,
 606                ComparisonOp op, const char *rhs)
 607 {
 608         if (op != EQ && op != NE) {
 609                 Parse_Error(PARSE_FATAL,
 610                     "String comparison operator must be either == or !=");
 611                 par->printedError = TRUE;
 612                 return TOK_ERROR;
 613         }
 614
 615         DEBUG3(COND, "lhs = \"%s\", rhs = \"%s\", op = %.2s\n",
 616             lhs, rhs, opname[op]);
 617         return ToToken((op == EQ) == (strcmp(lhs, rhs) == 0));
 618 }
 619
 620 /* Evaluate a comparison, such as "${VAR} == 12345". */
 621 static Token
 622 EvalCompare(CondParser *par, const char *lhs, Boolean lhsQuoted,
 623             ComparisonOp op, const char *rhs, Boolean rhsQuoted)
 624 {
 625         double left, right;
 626
 627         if (!rhsQuoted && !lhsQuoted)
 628                 if (TryParseNumber(lhs, &left) && TryParseNumber(rhs, &right))
 629                         return ToToken(EvalCompareNum(left, op, right));
 630
 631         return EvalCompareStr(par, lhs, op, rhs);
 632 }
 633
 634 static Boolean
 635 CondParser_ComparisonOp(CondParser *par, ComparisonOp *out_op)
 636 {
 637         const char *p = par->p;
 638
 639         if (p[0] == '<' && p[1] == '=') {
 640                 *out_op = LE;
 641                 goto length_2;
 642         } else if (p[0] == '<') {
 643                 *out_op = LT;
 644                 goto length_1;
 645         } else if (p[0] == '>' && p[1] == '=') {
 646                 *out_op = GE;
 647                 goto length_2;
 648         } else if (p[0] == '>') {
 649                 *out_op = GT;
 650                 goto length_1;
 651         } else if (p[0] == '=' && p[1] == '=') {
 652                 *out_op = EQ;
 653                 goto length_2;
 654         } else if (p[0] == '!' && p[1] == '=') {
 655                 *out_op = NE;
 656                 goto length_2;
 657         }
 658         return FALSE;
 659
 660 length_2:
 661         par->p = p + 2;
 662         return TRUE;
 663 length_1:
 664         par->p = p + 1;
 665         return TRUE;
 666 }
 667
 668 /*
 669  * Parse a comparison condition such as:
 670  *
 671  *      0
 672  *      ${VAR:Mpattern}
 673  *      ${VAR} == value
 674  *      ${VAR:U0} < 12345
 675  */
 676 static Token
 677 CondParser_Comparison(CondParser *par, Boolean doEval)
 678 {
 679         Token t = TOK_ERROR;
 680         FStr lhs, rhs;
 681         ComparisonOp op;
 682         Boolean lhsQuoted, rhsQuoted;
 683
 684         /*
 685          * Parse the variable spec and skip over it, saving its
 686          * value in lhs.
 687          */
 688         CondParser_String(par, doEval, lhsStrict, &lhs, &lhsQuoted);
 689         if (lhs.str == NULL)
 690                 goto done_lhs;
 691
 692         CondParser_SkipWhitespace(par);
 693
 694         if (!CondParser_ComparisonOp(par, &op)) {
 695                 /* Unknown operator, compare against an empty string or 0. */
 696                 t = ToToken(doEval && EvalNotEmpty(par, lhs.str, lhsQuoted));
 697                 goto done_lhs;
 698         }
 699
 700         CondParser_SkipWhitespace(par);
 701
 702         if (par->p[0] == '\0') {
 703                 Parse_Error(PARSE_FATAL,
 704                     "Missing right-hand-side of operator '%s'", opname[op]);
 705                 par->printedError = TRUE;
 706                 goto done_lhs;
 707         }
 708
 709         CondParser_String(par, doEval, FALSE, &rhs, &rhsQuoted);
 710         if (rhs.str == NULL)
 711                 goto done_rhs;
 712
 713         if (!doEval) {
 714                 t = TOK_FALSE;
 715                 goto done_rhs;
 716         }
 717
 718         t = EvalCompare(par, lhs.str, lhsQuoted, op, rhs.str, rhsQuoted);
 719
 720 done_rhs:
 721         FStr_Done(&rhs);
 722 done_lhs:
 723         FStr_Done(&lhs);
 724         return t;
 725 }
 726
 727 /*
 728  * The argument to empty() is a variable name, optionally followed by
 729  * variable modifiers.
 730  */
 731 /*ARGSUSED*/
 732 static size_t
 733 ParseEmptyArg(CondParser *par MAKE_ATTR_UNUSED, const char **pp,
 734               Boolean doEval, const char *func MAKE_ATTR_UNUSED,
 735               char **out_arg)
 736 {
 737         FStr val;
 738         size_t magic_res;
 739
 740         /* We do all the work here and return the result as the length */
 741         *out_arg = NULL;
 742
 743         (*pp)--;                /* Make (*pp)[1] point to the '('. */
 744         (void)Var_Parse(pp, SCOPE_CMDLINE, doEval ? VARE_WANTRES : VARE_NONE,
 745             &val);
 746         /* TODO: handle errors */
 747         /* If successful, *pp points beyond the closing ')' now. */
 748
 749         if (val.str == var_Error) {
 750                 FStr_Done(&val);
 751                 return (size_t)-1;
 752         }
 753
 754         /*
 755          * A variable is empty when it just contains spaces...
 756          * 4/15/92, christos
 757          */
 758         cpp_skip_whitespace(&val.str);
 759
 760         /*
 761          * For consistency with the other functions we can't generate the
 762          * true/false here.
 763          */
 764         magic_res = val.str[0] != '\0' ? 2 : 1;
 765         FStr_Done(&val);
 766         return magic_res;
 767 }
 768
 769 /*ARGSUSED*/
 770 static Boolean
 771 FuncEmpty(size_t arglen, const char *arg MAKE_ATTR_UNUSED)
 772 {
 773         /* Magic values ahead, see ParseEmptyArg. */
 774         return arglen == 1;
 775 }
 776
 777 static Boolean
 778 CondParser_Func(CondParser *par, Boolean doEval, Token *out_token)
 779 {
 780         static const struct fn_def {
 781                 const char *fn_name;
 782                 size_t fn_name_len;
 783                 size_t (*fn_parse)(CondParser *, const char **, Boolean,
 784                                    const char *, char **);
 785                 Boolean (*fn_eval)(size_t, const char *);
 786         } fns[] = {
 787                 { "defined",  7, ParseFuncArg,  FuncDefined },
 788                 { "make",     4, ParseFuncArg,  FuncMake },
 789                 { "exists",   6, ParseFuncArg,  FuncExists },
 790                 { "empty",    5, ParseEmptyArg, FuncEmpty },
 791                 { "target",   6, ParseFuncArg,  FuncTarget },
 792                 { "commands", 8, ParseFuncArg,  FuncCommands }
 793         };
 794         const struct fn_def *fn;
 795         char *arg = NULL;
 796         size_t arglen;
 797         const char *cp = par->p;
 798         const struct fn_def *fns_end = fns + sizeof fns / sizeof fns[0];
 799
 800         for (fn = fns; fn != fns_end; fn++) {
 801                 if (!is_token(cp, fn->fn_name, fn->fn_name_len))
 802                         continue;
 803
 804                 cp += fn->fn_name_len;
 805                 cpp_skip_whitespace(&cp);
 806                 if (*cp != '(')
 807                         break;
 808
 809                 arglen = fn->fn_parse(par, &cp, doEval, fn->fn_name, &arg);
 810                 if (arglen == 0 || arglen == (size_t)-1) {
 811                         par->p = cp;
 812                         *out_token = arglen == 0 ? TOK_FALSE : TOK_ERROR;
 813                         return TRUE;
 814                 }
 815
 816                 /* Evaluate the argument using the required function. */
 817                 *out_token = ToToken(!doEval || fn->fn_eval(arglen, arg));
 818                 free(arg);
 819                 par->p = cp;
 820                 return TRUE;
 821         }
 822
 823         return FALSE;
 824 }
 825
 826 /*
 827  * Parse a function call, a number, a variable expression or a string
 828  * literal.
 829  */
 830 static Token
 831 CondParser_LeafToken(CondParser *par, Boolean doEval)
 832 {
 833         Token t;
 834         char *arg = NULL;
 835         size_t arglen;
 836         const char *cp;
 837         const char *cp1;
 838
 839         if (CondParser_Func(par, doEval, &t))
 840                 return t;
 841
 842         /* Push anything numeric through the compare expression */
 843         cp = par->p;
 844         if (ch_isdigit(cp[0]) || cp[0] == '-' || cp[0] == '+')
 845                 return CondParser_Comparison(par, doEval);
 846
 847         /*
 848          * Most likely we have a naked token to apply the default function to.
 849          * However ".if a == b" gets here when the "a" is unquoted and doesn't
 850          * start with a '$'. This surprises people.
 851          * If what follows the function argument is a '=' or '!' then the
 852          * syntax would be invalid if we did "defined(a)" - so instead treat
 853          * as an expression.
 854          */
 855         arglen = ParseFuncArg(par, &cp, doEval, NULL, &arg);
 856         cp1 = cp;
 857         cpp_skip_whitespace(&cp1);
 858         if (*cp1 == '=' || *cp1 == '!')
 859                 return CondParser_Comparison(par, doEval);
 860         par->p = cp;
 861
 862         /*
 863          * Evaluate the argument using the default function.
 864          * This path always treats .if as .ifdef. To get here, the character
 865          * after .if must have been taken literally, so the argument cannot
 866          * be empty - even if it contained a variable expansion.
 867          */
 868         t = ToToken(!doEval || If_Eval(par, arg, arglen));
 869         free(arg);
 870         return t;
 871 }
 872
 873 /* Return the next token or comparison result from the parser. */
 874 static Token
 875 CondParser_Token(CondParser *par, Boolean doEval)
 876 {
 877         Token t;
 878
 879         t = par->curr;
 880         if (t != TOK_NONE) {
 881                 par->curr = TOK_NONE;
 882                 return t;
 883         }
 884
 885         cpp_skip_hspace(&par->p);
 886
 887         switch (par->p[0]) {
 888
 889         case '(':
 890                 par->p++;
 891                 return TOK_LPAREN;
 892
 893         case ')':
 894                 par->p++;
 895                 return TOK_RPAREN;
 896
 897         case '|':
 898                 par->p++;
 899                 if (par->p[0] == '|')
 900                         par->p++;
 901                 else if (opts.strict) {
 902                         Parse_Error(PARSE_FATAL, "Unknown operator '|'");
 903                         par->printedError = TRUE;
 904                         return TOK_ERROR;
 905                 }
 906                 return TOK_OR;
 907
 908         case '&':
 909                 par->p++;
 910                 if (par->p[0] == '&')
 911                         par->p++;
 912                 else if (opts.strict) {
 913                         Parse_Error(PARSE_FATAL, "Unknown operator '&'");
 914                         par->printedError = TRUE;
 915                         return TOK_ERROR;
 916                 }
 917                 return TOK_AND;
 918
 919         case '!':
 920                 par->p++;
 921                 return TOK_NOT;
 922
 923         case '#':               /* XXX: see unit-tests/cond-token-plain.mk */
 924         case '\n':              /* XXX: why should this end the condition? */
 925                 /* Probably obsolete now, from 1993-03-21. */
 926         case '\0':
 927                 return TOK_EOF;
 928
 929         case '"':
 930         case '$':
 931                 return CondParser_Comparison(par, doEval);
 932
 933         default:
 934                 return CondParser_LeafToken(par, doEval);
 935         }
 936 }
 937
 938 /*
 939  * Term -> '(' Or ')'
 940  * Term -> '!' Term
 941  * Term -> Leaf Operator Leaf
 942  * Term -> Leaf
 943  */
 944 static CondResult
 945 CondParser_Term(CondParser *par, Boolean doEval)
 946 {
 947         CondResult res;
 948         Token t;
 949
 950         t = CondParser_Token(par, doEval);
 951         if (t == TOK_TRUE)
 952                 return CR_TRUE;
 953         if (t == TOK_FALSE)
 954                 return CR_FALSE;
 955
 956         if (t == TOK_LPAREN) {
 957                 res = CondParser_Or(par, doEval);
 958                 if (res == CR_ERROR)
 959                         return CR_ERROR;
 960                 if (CondParser_Token(par, doEval) != TOK_RPAREN)
 961                         return CR_ERROR;
 962                 return res;
 963         }
 964
 965         if (t == TOK_NOT) {
 966                 res = CondParser_Term(par, doEval);
 967                 if (res == CR_TRUE)
 968                         res = CR_FALSE;
 969                 else if (res == CR_FALSE)
 970                         res = CR_TRUE;
 971                 return res;
 972         }
 973
 974         return CR_ERROR;
 975 }
 976
 977 /*
 978  * And -> Term '&&' And
 979  * And -> Term
 980  */
 981 static CondResult
 982 CondParser_And(CondParser *par, Boolean doEval)
 983 {
 984         CondResult res;
 985         Token op;
 986
 987         res = CondParser_Term(par, doEval);
 988         if (res == CR_ERROR)
 989                 return CR_ERROR;
 990
 991         op = CondParser_Token(par, doEval);
 992         if (op == TOK_AND) {
 993                 if (res == CR_TRUE)
 994                         return CondParser_And(par, doEval);
 995                 if (CondParser_And(par, FALSE) == CR_ERROR)
 996                         return CR_ERROR;
 997                 return res;
 998         }
 999
1000         CondParser_PushBack(par, op);
1001         return res;
1002 }
1003
1004 /*
1005  * Or -> And '||' Or
1006  * Or -> And
1007  */
1008 static CondResult
1009 CondParser_Or(CondParser *par, Boolean doEval)
1010 {
1011         CondResult res;
1012         Token op;
1013
1014         res = CondParser_And(par, doEval);
1015         if (res == CR_ERROR)
1016                 return CR_ERROR;
1017
1018         op = CondParser_Token(par, doEval);
1019         if (op == TOK_OR) {
1020                 if (res == CR_FALSE)
1021                         return CondParser_Or(par, doEval);
1022                 if (CondParser_Or(par, FALSE) == CR_ERROR)
1023                         return CR_ERROR;
1024                 return res;
1025         }
1026
1027         CondParser_PushBack(par, op);
1028         return res;
1029 }
1030
1031 static CondEvalResult
1032 CondParser_Eval(CondParser *par, Boolean *out_value)
1033 {
1034         CondResult res;
1035
1036         DEBUG1(COND, "CondParser_Eval: %s\n", par->p);
1037
1038         res = CondParser_Or(par, TRUE);
1039         if (res == CR_ERROR)
1040                 return COND_INVALID;
1041
1042         if (CondParser_Token(par, FALSE) != TOK_EOF)
1043                 return COND_INVALID;
1044
1045         *out_value = res == CR_TRUE;
1046         return COND_PARSE;
1047 }
1048
1049 /*
1050  * Evaluate the condition, including any side effects from the variable
1051  * expressions in the condition. The condition consists of &&, ||, !,
1052  * function(arg), comparisons and parenthetical groupings thereof.
1053  *
1054  * Results:
1055  *      COND_PARSE      if the condition was valid grammatically
1056  *      COND_INVALID    if not a valid conditional.
1057  *
1058  *      (*value) is set to the boolean value of the condition
1059  */
1060 static CondEvalResult
1061 CondEvalExpression(const char *cond, Boolean *out_value, Boolean plain,
1062                    Boolean (*evalBare)(size_t, const char *), Boolean negate,
1063                    Boolean eprint, Boolean strictLHS)
1064 {
1065         CondParser par;
1066         CondEvalResult rval;
1067
1068         lhsStrict = strictLHS;
1069
1070         cpp_skip_hspace(&cond);
1071
1072         par.plain = plain;
1073         par.evalBare = evalBare;
1074         par.negateEvalBare = negate;
1075         par.p = cond;
1076         par.curr = TOK_NONE;
1077         par.printedError = FALSE;
1078
1079         rval = CondParser_Eval(&par, out_value);
1080
1081         if (rval == COND_INVALID && eprint && !par.printedError)
1082                 Parse_Error(PARSE_FATAL, "Malformed conditional (%s)", cond);
1083
1084         return rval;
1085 }
1086
1087 /*
1088  * Evaluate a condition in a :? modifier, such as
1089  * ${"${VAR}" == value:?yes:no}.
1090  */
1091 CondEvalResult
1092 Cond_EvalCondition(const char *cond, Boolean *out_value)
1093 {
1094         return CondEvalExpression(cond, out_value, TRUE,
1095             FuncDefined, FALSE, FALSE, FALSE);
1096 }
1097
1098 static Boolean
1099 IsEndif(const char *p)
1100 {
1101         return p[0] == 'e' && p[1] == 'n' && p[2] == 'd' &&
1102                p[3] == 'i' && p[4] == 'f' && !ch_isalpha(p[5]);
1103 }
1104
1105 static Boolean
1106 DetermineKindOfConditional(const char **pp, Boolean *out_plain,
1107                            Boolean (**out_evalBare)(size_t, const char *),
1108                            Boolean *out_negate)
1109 {
1110         const char *p = *pp;
1111
1112         p += 2;
1113         *out_plain = FALSE;
1114         *out_evalBare = FuncDefined;
1115         *out_negate = FALSE;
1116         if (*p == 'n') {
1117                 p++;
1118                 *out_negate = TRUE;
1119         }
1120         if (is_token(p, "def", 3)) {            /* .ifdef and .ifndef */
1121                 p += 3;
1122         } else if (is_token(p, "make", 4)) {    /* .ifmake and .ifnmake */
1123                 p += 4;
1124                 *out_evalBare = FuncMake;
1125         } else if (is_token(p, "", 0) && !*out_negate) { /* plain .if */
1126                 *out_plain = TRUE;
1127         } else {
1128                 /*
1129                  * TODO: Add error message about unknown directive,
1130                  * since there is no other known directive that starts
1131                  * with 'el' or 'if'.
1132                  *
1133                  * Example: .elifx 123
1134                  */
1135                 return FALSE;
1136         }
1137
1138         *pp = p;
1139         return TRUE;
1140 }
1141
1142 /*
1143  * Evaluate the conditional directive in the line, which is one of:
1144  *
1145  *      .if <cond>
1146  *      .ifmake <cond>
1147  *      .ifnmake <cond>
1148  *      .ifdef <cond>
1149  *      .ifndef <cond>
1150  *      .elif <cond>
1151  *      .elifmake <cond>
1152  *      .elifnmake <cond>
1153  *      .elifdef <cond>
1154  *      .elifndef <cond>
1155  *      .else
1156  *      .endif
1157  *
1158  * In these directives, <cond> consists of &&, ||, !, function(arg),
1159  * comparisons, expressions, bare words, numbers and strings, and
1160  * parenthetical groupings thereof.
1161  *
1162  * Results:
1163  *      COND_PARSE      to continue parsing the lines that follow the
1164  *                      conditional (when <cond> evaluates to TRUE)
1165  *      COND_SKIP       to skip the lines after the conditional
1166  *                      (when <cond> evaluates to FALSE, or when a previous
1167  *                      branch has already been taken)
1168  *      COND_INVALID    if the conditional was not valid, either because of
1169  *                      a syntax error or because some variable was undefined
1170  *                      or because the condition could not be evaluated
1171  */
1172 CondEvalResult
1173 Cond_EvalLine(const char *line)
1174 {
1175         typedef enum IfState {
1176
1177                 /* None of the previous <cond> evaluated to TRUE. */
1178                 IFS_INITIAL     = 0,
1179
1180                 /* The previous <cond> evaluated to TRUE.
1181                  * The lines following this condition are interpreted. */
1182                 IFS_ACTIVE      = 1 << 0,
1183
1184                 /* The previous directive was an '.else'. */
1185                 IFS_SEEN_ELSE   = 1 << 1,
1186
1187                 /* One of the previous <cond> evaluated to TRUE. */
1188                 IFS_WAS_ACTIVE  = 1 << 2
1189
1190         } IfState;
1191
1192         static enum IfState *cond_states = NULL;
1193         static unsigned int cond_states_cap = 128;
1194
1195         Boolean plain;
1196         Boolean (*evalBare)(size_t, const char *);
1197         Boolean negate;
1198         Boolean isElif;
1199         Boolean value;
1200         IfState state;
1201         const char *p = line;
1202
1203         if (cond_states == NULL) {
1204                 cond_states = bmake_malloc(
1205                     cond_states_cap * sizeof *cond_states);
1206                 cond_states[0] = IFS_ACTIVE;
1207         }
1208
1209         p++;                    /* skip the leading '.' */
1210         cpp_skip_hspace(&p);
1211
1212         if (IsEndif(p)) {       /* It is an '.endif'. */
1213                 if (p[5] != '\0') {
1214                         Parse_Error(PARSE_FATAL,
1215                             "The .endif directive does not take arguments.");
1216                 }
1217
1218                 if (cond_depth == cond_min_depth) {
1219                         Parse_Error(PARSE_FATAL, "if-less endif");
1220                         return COND_PARSE;
1221                 }
1222
1223                 /* Return state for previous conditional */
1224                 cond_depth--;
1225                 return cond_states[cond_depth] & IFS_ACTIVE
1226                     ? COND_PARSE : COND_SKIP;
1227         }
1228
1229         /* Parse the name of the directive, such as 'if', 'elif', 'endif'. */
1230         if (p[0] == 'e') {
1231                 if (p[1] != 'l') {
1232                         /*
1233                          * Unknown directive.  It might still be a
1234                          * transformation rule like '.elisp.scm',
1235                          * therefore no error message here.
1236                          */
1237                         return COND_INVALID;
1238                 }
1239
1240                 /* Quite likely this is 'else' or 'elif' */
1241                 p += 2;
1242                 if (is_token(p, "se", 2)) {     /* It is an 'else'. */
1243
1244                         if (p[2] != '\0')
1245                                 Parse_Error(PARSE_FATAL,
1246                                             "The .else directive "
1247                                             "does not take arguments.");
1248
1249                         if (cond_depth == cond_min_depth) {
1250                                 Parse_Error(PARSE_FATAL, "if-less else");
1251                                 return COND_PARSE;
1252                         }
1253
1254                         state = cond_states[cond_depth];
1255                         if (state == IFS_INITIAL) {
1256                                 state = IFS_ACTIVE | IFS_SEEN_ELSE;
1257                         } else {
1258                                 if (state & IFS_SEEN_ELSE)
1259                                         Parse_Error(PARSE_WARNING,
1260                                                     "extra else");
1261                                 state = IFS_WAS_ACTIVE | IFS_SEEN_ELSE;
1262                         }
1263                         cond_states[cond_depth] = state;
1264
1265                         return state & IFS_ACTIVE ? COND_PARSE : COND_SKIP;
1266                 }
1267                 /* Assume for now it is an elif */
1268                 isElif = TRUE;
1269         } else
1270                 isElif = FALSE;
1271
1272         if (p[0] != 'i' || p[1] != 'f') {
1273                 /*
1274                  * Unknown directive.  It might still be a transformation rule
1275                  * like '.elisp.scm', therefore no error message here.
1276                  */
1277                 return COND_INVALID;    /* Not an ifxxx or elifxxx line */
1278         }
1279
1280         if (!DetermineKindOfConditional(&p, &plain, &evalBare, &negate))
1281                 return COND_INVALID;
1282
1283         if (isElif) {
1284                 if (cond_depth == cond_min_depth) {
1285                         Parse_Error(PARSE_FATAL, "if-less elif");
1286                         return COND_PARSE;
1287                 }
1288                 state = cond_states[cond_depth];
1289                 if (state & IFS_SEEN_ELSE) {
1290                         Parse_Error(PARSE_WARNING, "extra elif");
1291                         cond_states[cond_depth] =
1292                             IFS_WAS_ACTIVE | IFS_SEEN_ELSE;
1293                         return COND_SKIP;
1294                 }
1295                 if (state != IFS_INITIAL) {
1296                         cond_states[cond_depth] = IFS_WAS_ACTIVE;
1297                         return COND_SKIP;
1298                 }
1299         } else {
1300                 /* Normal .if */
1301                 if (cond_depth + 1 >= cond_states_cap) {
1302                         /*
1303                          * This is rare, but not impossible.
1304                          * In meta mode, dirdeps.mk (only runs at level 0)
1305                          * can need more than the default.
1306                          */
1307                         cond_states_cap += 32;
1308                         cond_states = bmake_realloc(cond_states,
1309                                                     cond_states_cap *
1310                                                     sizeof *cond_states);
1311                 }
1312                 state = cond_states[cond_depth];
1313                 cond_depth++;
1314                 if (!(state & IFS_ACTIVE)) {
1315                         /*
1316                          * If we aren't parsing the data,
1317                          * treat as always false.
1318                          */
1319                         cond_states[cond_depth] = IFS_WAS_ACTIVE;
1320                         return COND_SKIP;
1321                 }
1322         }
1323
1324         /* And evaluate the conditional expression */
1325         if (CondEvalExpression(p, &value, plain, evalBare, negate,
1326             TRUE, TRUE) == COND_INVALID) {
1327                 /* Syntax error in conditional, error message already output. */
1328                 /* Skip everything to matching .endif */
1329                 /* XXX: An extra '.else' is not detected in this case. */
1330                 cond_states[cond_depth] = IFS_WAS_ACTIVE;
1331                 return COND_SKIP;
1332         }
1333
1334         if (!value) {
1335                 cond_states[cond_depth] = IFS_INITIAL;
1336                 return COND_SKIP;
1337         }
1338         cond_states[cond_depth] = IFS_ACTIVE;
1339         return COND_PARSE;
1340 }
1341
1342 void
1343 Cond_restore_depth(unsigned int saved_depth)
1344 {
1345         unsigned int open_conds = cond_depth - cond_min_depth;
1346
1347         if (open_conds != 0 || saved_depth > cond_depth) {
1348                 Parse_Error(PARSE_FATAL, "%u open conditional%s",
1349                             open_conds, open_conds == 1 ? "" : "s");
1350                 cond_depth = cond_min_depth;
1351         }
1352
1353         cond_min_depth = saved_depth;
1354 }
1355
1356 unsigned int
1357 Cond_save_depth(void)
1358 {
1359         unsigned int depth = cond_min_depth;
1360
1361         cond_min_depth = cond_depth;
1362         return depth;
1363 }