content: package btools.expressions;
  
  import java.util.StringTokenizer;
  
  final class BExpression {
    private static final int OR_EXP = 10;
    private static final int AND_EXP = 11;
    private static final int NOT_EXP = 12;
  
    private static final int ADD_EXP = 20;
    private static final int MULTIPLY_EXP = 21;
    private static final int DIVIDE_EXP = 22;
    private static final int MAX_EXP = 23;
    private static final int EQUAL_EXP = 24;
    private static final int GREATER_EXP = 25;
    private static final int MIN_EXP = 26;
  
    private static final int SUB_EXP = 27;
    private static final int LESSER_EXP = 28;
    private static final int XOR_EXP = 29;
  
    private static final int SWITCH_EXP = 30;
    private static final int ASSIGN_EXP = 31;
    private static final int LOOKUP_EXP = 32;
    private static final int NUMBER_EXP = 33;
    private static final int VARIABLE_EXP = 34;
    private static final int FOREIGN_VARIABLE_EXP = 35;
    private static final int VARIABLE_GET_EXP = 36;
  
    private int typ;
    private BExpression op1;
    private BExpression op2;
    private BExpression op3;
    private float numberValue;
    private int variableIdx;
    private int lookupNameIdx = -1;
    private int[] lookupValueIdxArray;
    private boolean doNotChange;
  
    // Parse the expression and all subexpression
    public static BExpression parse(BExpressionContext ctx, int level) throws Exception {
      return parse(ctx, level, null);
    }
  
    private static BExpression parse(BExpressionContext ctx, int level, String optionalToken) throws Exception {
      BExpression e = parseRaw(ctx, level, optionalToken);
      if (e == null) {
        return null;
      }
  
      if (ASSIGN_EXP == e.typ) {
        // manage assined an injected values
        BExpression assignedBefore = ctx.lastAssignedExpression.get(e.variableIdx);
        if (assignedBefore != null && assignedBefore.doNotChange) {
          e.op1 = assignedBefore; // was injected as key-value
          e.op1.doNotChange = false; // protect just once, can be changed in second assignement
        }
        ctx.lastAssignedExpression.set(e.variableIdx, e.op1);
      }
      else if (!ctx.skipConstantExpressionOptimizations) {
        // try to simplify the expression
        if (VARIABLE_EXP == e.typ) {
          BExpression ae = ctx.lastAssignedExpression.get(e.variableIdx);
          if (ae != null && ae.typ == NUMBER_EXP) {
            e = ae;
          }
        } else {
          BExpression eCollapsed = e.tryCollapse();
          if (e != eCollapsed) {
            e = eCollapsed; // allow breakpoint..
          }
          BExpression eEvaluated = e.tryEvaluateConstant();
          if (e != eEvaluated) {
            e = eEvaluated; // allow breakpoint..
          }
        }
      }
      if (level == 0) {
        // mark the used lookups after the
        // expression is collapsed to not mark
        // lookups as used that appear in the profile
        // but are de-activated by constant expressions
        int nodeCount = e.markLookupIdxUsed(ctx);
        ctx.expressionNodeCount += nodeCount;
      }
      return e;
    }
  
    private int markLookupIdxUsed(BExpressionContext ctx) {
      int nodeCount = 1;
      if (lookupNameIdx >= 0) {
        ctx.markLookupIdxUsed(lookupNameIdx);
      }
      if (op1 != null) {
        nodeCount += op1.markLookupIdxUsed(ctx);
      }
      if (op2 != null) {
        nodeCount += op2.markLookupIdxUsed(ctx);
      }
      if (op3 != null) {
        nodeCount += op3.markLookupIdxUsed(ctx);
      }
      return nodeCount;
    }
  
    private static BExpression parseRaw(BExpressionContext ctx, int level, String optionalToken) throws Exception {
  
      boolean brackets = false;
      String operator = ctx.parseToken();
      if (optionalToken != null && optionalToken.equals(operator)) {
        operator = ctx.parseToken();
      }
      if ("(".equals(operator)) {
        brackets = true;
        operator = ctx.parseToken();
      }
  
      if (operator == null) {
        if (level == 0) return null;
        else throw new IllegalArgumentException("unexpected end of file");
      }
  
      if (level == 0) {
        if (!"assign".equals(operator)) {
          throw new IllegalArgumentException("operator " + operator + " is invalid on toplevel (only 'assign' allowed)");
        }
      }
  
      BExpression exp = new BExpression();
      int nops = 3;
  
      boolean ifThenElse = false;
  
      if ("switch".equals(operator)) {
        exp.typ = SWITCH_EXP;
      } else if ("if".equals(operator)) {
        exp.typ = SWITCH_EXP;
        ifThenElse = true;
      } else {
        nops = 2; // check binary expressions
  
        if ("or".equals(operator)) {
          exp.typ = OR_EXP;
        } else if ("and".equals(operator)) {
          exp.typ = AND_EXP;
        } else if ("multiply".equals(operator)) {
          exp.typ = MULTIPLY_EXP;
        } else if ("divide".equals(operator)) {
          exp.typ = DIVIDE_EXP;
        } else if ("add".equals(operator)) {
          exp.typ = ADD_EXP;
        } else if ("max".equals(operator)) {
          exp.typ = MAX_EXP;
        } else if ("min".equals(operator)) {
          exp.typ = MIN_EXP;
        } else if ("equal".equals(operator)) {
          exp.typ = EQUAL_EXP;
        } else if ("greater".equals(operator)) {
          exp.typ = GREATER_EXP;
        } else if ("sub".equals(operator)) {
          exp.typ = SUB_EXP;
        } else if ("lesser".equals(operator)) {
          exp.typ = LESSER_EXP;
        } else if ("xor".equals(operator)) {
          exp.typ = XOR_EXP;
        } else {
          nops = 1; // check unary expressions
          if ("assign".equals(operator)) {
            if (level > 0) throw new IllegalArgumentException("assign operator within expression");
            exp.typ = ASSIGN_EXP;
            String variable = ctx.parseToken();
            if (variable == null) throw new IllegalArgumentException("unexpected end of file");
            if (variable.indexOf('=') >= 0)
              throw new IllegalArgumentException("variable name cannot contain '=': " + variable);
            if (variable.indexOf(':') >= 0)
              throw new IllegalArgumentException("cannot assign context-prefixed variable: " + variable);
            exp.variableIdx = ctx.getVariableIdx(variable, true);
            if (exp.variableIdx < ctx.getMinWriteIdx())
              throw new IllegalArgumentException("cannot assign to readonly variable " + variable);
          } else if ("not".equals(operator)) {
            exp.typ = NOT_EXP;
          } else {
            nops = 0; // check elemantary expressions
            int idx = operator.indexOf('=');
            if (idx >= 0) {
              exp.typ = LOOKUP_EXP;
              String name = operator.substring(0, idx);
              String values = operator.substring(idx + 1);
  
              exp.lookupNameIdx = ctx.getLookupNameIdx(name);
              if (exp.lookupNameIdx < 0) {
                throw new IllegalArgumentException("unknown lookup name: " + name);
              }
              StringTokenizer tk = new StringTokenizer(values, "|");
              int nt = tk.countTokens();
              int nt2 = nt == 0 ? 1 : nt;
              exp.lookupValueIdxArray = new int[nt2];
              for (int ti = 0; ti < nt2; ti++) {
                String value = ti < nt ? tk.nextToken() : "";
                exp.lookupValueIdxArray[ti] = ctx.getLookupValueIdx(exp.lookupNameIdx, value);
                if (exp.lookupValueIdxArray[ti] < 0) {
                  throw new IllegalArgumentException("unknown lookup value: " + value);
                }
              }
            } else if ((idx = operator.indexOf(':')) >= 0) {
              /*
              use of variable values
              assign no_height
                 switch and not      maxheight=
                          lesser v:maxheight  my_height  true
              false
               */
              if (operator.startsWith("v:")) {
                String name = operator.substring(2);
                exp.typ = VARIABLE_GET_EXP;
                exp.lookupNameIdx = ctx.getLookupNameIdx(name);
              } else {
                String context = operator.substring(0, idx);
                String varname = operator.substring(idx + 1);
                exp.typ = FOREIGN_VARIABLE_EXP;
                exp.variableIdx = ctx.getForeignVariableIdx(context, varname);
              }
            } else if ((idx = ctx.getVariableIdx(operator, false)) >= 0) {
              exp.typ = VARIABLE_EXP;
              exp.variableIdx = idx;
            } else if ("true".equals(operator)) {
              exp.numberValue = 1.f;
              exp.typ = NUMBER_EXP;
            } else if ("false".equals(operator)) {
              exp.numberValue = 0.f;
              exp.typ = NUMBER_EXP;
            } else {
              try {
                exp.numberValue = Float.parseFloat(operator);
                exp.typ = NUMBER_EXP;
              } catch (NumberFormatException nfe) {
                throw new IllegalArgumentException("unknown expression: " + operator);
              }
            }
          }
        }
      }
      // parse operands
      if (nops > 0) {
        exp.op1 = parse(ctx, level + 1, exp.typ == ASSIGN_EXP ? "=" : null);
      }
      if (nops > 1) {
        if (ifThenElse) checkExpectedToken(ctx, "then");
        exp.op2 = parse(ctx, level + 1, null);
      }
      if (nops > 2) {
        if (ifThenElse) checkExpectedToken(ctx, "else");
        exp.op3 = parse(ctx, level + 1, null);
      }
      if (brackets) {
        checkExpectedToken(ctx, ")");
      }
      return exp;
    }
  
    private static void checkExpectedToken(BExpressionContext ctx, String expected) throws Exception {
      String token = ctx.parseToken();
      if (!expected.equals(token)) {
        throw new IllegalArgumentException("unexpected token: " + token + ", expected: " + expected);
      }
    }
  
    // Evaluate the expression
    public float evaluate(BExpressionContext ctx) {
      switch (typ) {
        case OR_EXP:
          return op1.evaluate(ctx) != 0.f ? 1.f : (op2.evaluate(ctx) != 0.f ? 1.f : 0.f);
        case XOR_EXP:
          return ((op1.evaluate(ctx) != 0.f) ^ (op2.evaluate(ctx) != 0.f) ? 1.f : 0.f);
        case AND_EXP:
          return op1.evaluate(ctx) != 0.f ? (op2.evaluate(ctx) != 0.f ? 1.f : 0.f) : 0.f;
        case ADD_EXP:
          return op1.evaluate(ctx) + op2.evaluate(ctx);
        case SUB_EXP:
          return op1.evaluate(ctx) - op2.evaluate(ctx);
        case MULTIPLY_EXP:
          return op1.evaluate(ctx) * op2.evaluate(ctx);
        case DIVIDE_EXP:
          return divide(op1.evaluate(ctx), op2.evaluate(ctx));
        case MAX_EXP:
          return max(op1.evaluate(ctx), op2.evaluate(ctx));
        case MIN_EXP:
          return min(op1.evaluate(ctx), op2.evaluate(ctx));
        case EQUAL_EXP:
          return op1.evaluate(ctx) == op2.evaluate(ctx) ? 1.f : 0.f;
        case GREATER_EXP:
          return op1.evaluate(ctx) > op2.evaluate(ctx) ? 1.f : 0.f;
        case LESSER_EXP:
          return op1.evaluate(ctx) < op2.evaluate(ctx) ? 1.f : 0.f;
        case SWITCH_EXP:
          return op1.evaluate(ctx) != 0.f ? op2.evaluate(ctx) : op3.evaluate(ctx);
        case ASSIGN_EXP:
          return ctx.assign(variableIdx, op1.evaluate(ctx));
        case LOOKUP_EXP:
          return ctx.getLookupMatch(lookupNameIdx, lookupValueIdxArray);
        case NUMBER_EXP:
          return numberValue;
        case VARIABLE_EXP:
          return ctx.getVariableValue(variableIdx);
        case FOREIGN_VARIABLE_EXP:
          return ctx.getForeignVariableValue(variableIdx);
        case VARIABLE_GET_EXP:
          return ctx.getLookupValue(lookupNameIdx);
        case NOT_EXP:
          return op1.evaluate(ctx) == 0.f ? 1.f : 0.f;
        default:
          throw new IllegalArgumentException("unknown op-code: " + typ);
      }
    }
  
    // Try to collapse the expression
    // if logically possible
    private BExpression tryCollapse() {
      switch (typ) {
        case OR_EXP:
          return NUMBER_EXP == op1.typ ?
            (op1.numberValue != 0.f ? op1 : op2)
            : (NUMBER_EXP == op2.typ ?
              (op2.numberValue != 0.f ? op2 : op1)
              : this);
        case AND_EXP:
          return NUMBER_EXP == op1.typ ?
            (op1.numberValue == 0.f ? op1 : op2)
            : (NUMBER_EXP == op2.typ ?
              (op2.numberValue == 0.f ? op2 : op1)
              : this);
        case ADD_EXP:
          return NUMBER_EXP == op1.typ ?
            (op1.numberValue == 0.f ? op2 : this)
            : (NUMBER_EXP == op2.typ ?
              (op2.numberValue == 0.f ? op1 : this)
              : this);
        case SWITCH_EXP:
          return NUMBER_EXP == op1.typ ?
            (op1.numberValue == 0.f ? op3 : op2) : this;
        default:
          return this;
      }
    }
  
    // Try to evaluate the expression
    // if all operands are constant
    private BExpression tryEvaluateConstant() {
      if (op1 != null && NUMBER_EXP == op1.typ
        && (op2 == null || NUMBER_EXP == op2.typ)
        && (op3 == null || NUMBER_EXP == op3.typ)) {
        BExpression exp = new BExpression();
        exp.typ = NUMBER_EXP;
        exp.numberValue = evaluate(null);
        return exp;
      }
      return this;
    }
  
    private float max(float v1, float v2) {
      return v1 > v2 ? v1 : v2;
    }
  
    private float min(float v1, float v2) {
      return v1 < v2 ? v1 : v2;
    }
  
    private float divide(float v1, float v2) {
      if (v2 == 0f) throw new IllegalArgumentException("div by zero");
      return v1 / v2;
    }
  
    @Override
    public String toString() {
      if (typ == NUMBER_EXP) {
        return "" + numberValue;
      }
      if (typ == VARIABLE_EXP) {
        return "vidx=" + variableIdx;
      }
      StringBuilder sb = new StringBuilder("typ=" + typ + " ops=(");
      addOp(sb, op1);
      addOp(sb, op2);
      addOp(sb, op3);
      sb.append(')');
      return sb.toString();
    }
  
    private void addOp(StringBuilder sb, BExpression e) {
      if (e != null) {
        sb.append('[').append(e.toString()).append(']');
      }
    }
  
    static BExpression createAssignExpressionFromKeyValue(BExpressionContext ctx, String key, String value) {
      BExpression e = new BExpression();
      e.typ = ASSIGN_EXP;
      e.variableIdx = ctx.getVariableIdx(key, true);
      e.op1 = new BExpression();
      e.op1.typ = NUMBER_EXP;
      e.op1.numberValue = Float.parseFloat(value);
      e.op1.doNotChange = true;
      ctx.lastAssignedExpression.set(e.variableIdx, e.op1);
      return e;
    }
  }
  