Java TernaryValue.UNKNOWN属性代码示例

@Override
public boolean apply(EdgeTuple<Node, Branch> input) {
  Branch branch = input.edge;
  if (!branch.isConditional()) {
    return true;
  }
  Node predecessor = input.sourceNode;
  Node condition = NodeUtil.getConditionExpression(predecessor);

  // TODO(user): Handle more complicated expression like true == true,
  // etc....
  if (condition != null) {
    TernaryValue val = NodeUtil.getBooleanValue(condition);
    if (val != TernaryValue.UNKNOWN) {
      return val.toBoolean(true) == (branch == Branch.ON_TRUE);
    }
  }
  return true;
}
 

public boolean apply(DiGraphEdge<Node, ControlFlowGraph.Branch> input) {
  // First skill all exceptions.
  Branch branch = input.getValue();
  if (branch == Branch.ON_EX) {
    return false;
  } else if (branch.isConditional()) {
    Node condition = NodeUtil.getConditionExpression(
        input.getSource().getValue());
    // TODO(user): We CAN make this bit smarter just looking at
    // constants. We DO have a full blown ReverseAbstractInterupter and
    // type system that can evaluate some impressions' boolean value but
    // for now we will keep this pass lightweight.
    if (condition != null) {
      TernaryValue val = NodeUtil.getBooleanValue(condition);
      if (val != TernaryValue.UNKNOWN) {
        return val.toBoolean(true) == (Branch.ON_TRUE == branch);
      }
    }
  }
  return true;
}
 

/**
 * Copied from Rhino's ScriptRuntime
 */
public static TernaryValue isStrWhiteSpaceChar(int c) {
  switch (c) {
    case '\u000B': // <VT>
      return TernaryValue.UNKNOWN;  // IE says "no", ECMAScript says "yes"
    case ' ': // <SP>
    case '\n': // <LF>
    case '\r': // <CR>
    case '\t': // <TAB>
    case '\u00A0': // <NBSP>
    case '\u000C': // <FF>
    case '\u2028': // <LS>
    case '\u2029': // <PS>
    case '\uFEFF': // <BOM>
      return TernaryValue.TRUE;
    default:
      return (Character.getType(c) == Character.SPACE_SEPARATOR)
          ? TernaryValue.TRUE : TernaryValue.FALSE;
  }
}
 

@Override
public boolean apply(EdgeTuple<Node, Branch> input) {
  Branch branch = input.edge;
  if (!branch.isConditional()) {
    return true;
  }
  Node predecessor = input.sourceNode;
  Node condition = NodeUtil.getConditionExpression(predecessor);

  // TODO(user): Handle more complicated expression like true == true,
  // etc....
  if (condition != null) {
    TernaryValue val = NodeUtil.getImpureBooleanValue(condition);
    if (val != TernaryValue.UNKNOWN) {
      return val.toBoolean(true) == (branch == Branch.ON_TRUE);
    }
  }
  return true;
}
 

@Override
public boolean apply(DiGraphEdge<Node, ControlFlowGraph.Branch> input) {
  // First skill all exceptions.
  Branch branch = input.getValue();
  if (branch == Branch.ON_EX) {
    return false;
  } else if (branch.isConditional()) {
    Node condition = NodeUtil.getConditionExpression(
        input.getSource().getValue());
    // TODO(user): We CAN make this bit smarter just looking at
    // constants. We DO have a full blown ReverseAbstractInterupter and
    // type system that can evaluate some impressions' boolean value but
    // for now we will keep this pass lightweight.
    if (condition != null) {
      TernaryValue val = NodeUtil.getImpureBooleanValue(condition);
      if (val != TernaryValue.UNKNOWN) {
        return val.toBoolean(true) == (Branch.ON_TRUE == branch);
      }
    }
  }
  return true;
}
 

public static TernaryValue isStrWhiteSpaceChar(int c) {
  switch (c) {
    case '\u000B': // <VT>
      return TernaryValue.UNKNOWN;  // Legacy IE says "no", ECMAScript says "yes"
    case ' ': // <SP>
    case '\n': // <LF>
    case '\r': // <CR>
    case '\t': // <TAB>
    case '\u00A0': // <NBSP>
    case '\u000C': // <FF>
    case '\u2028': // <LS>
    case '\u2029': // <PS>
    case '\uFEFF': // <BOM>
      return TernaryValue.TRUE;
    default:
      return TernaryValue.FALSE; // TODO(moz): Correct this.
  }
}
 

/**
 * Gets the boolean value of a node that represents a literal. This method
 * effectively emulates the <code>Boolean()</code> JavaScript cast function.
 */
static TernaryValue getBooleanValue(Node n) {
  switch (n.getType()) {
    case Token.STRING:
      return TernaryValue.forBoolean(n.getString().length() > 0);

    case Token.NUMBER:
      return TernaryValue.forBoolean(n.getDouble() != 0);

    case Token.NULL:
    case Token.FALSE:
    case Token.VOID:
      return TernaryValue.FALSE;

    case Token.NAME:
      String name = n.getString();
      if ("undefined".equals(name)
          || "NaN".equals(name)) {
        // We assume here that programs don't change the value of the keyword
        // undefined to something other than the value undefined.
        return TernaryValue.FALSE;
      } else if ("Infinity".equals(name)) {
        return TernaryValue.TRUE;
      }
      break;

    case Token.TRUE:
    case Token.ARRAYLIT:
    case Token.OBJECTLIT:
    case Token.REGEXP:
      return TernaryValue.TRUE;
  }

  return TernaryValue.UNKNOWN;
}
 

/**
 * Try folding HOOK (?:) if the condition results of the condition is known.
 * @return the replacement node, if changed, or the original if not
 */
private Node tryFoldHook(Node n) {
  Preconditions.checkState(n.getType() == Token.HOOK);
  Node parent = n.getParent();
  Preconditions.checkNotNull(parent);
  Node cond = n.getFirstChild();
  Node thenBody = cond.getNext();
  Node elseBody = thenBody.getNext();

  TernaryValue condValue = NodeUtil.getExpressionBooleanValue(cond);
  if (condValue == TernaryValue.UNKNOWN) {
    return n;  // We can't remove branches otherwise!
  }

  // Transform "(a = 2) ? x =2 : y" into "a=2,x=2"
  n.detachChildren();
  Node branchToKeep = condValue.toBoolean(true) ? thenBody : elseBody;
  Node replacement;
  if (mayHaveSideEffects(cond)) {
    replacement = new Node(Token.COMMA).copyInformationFrom(n);
    replacement.addChildToFront(cond);
    replacement.addChildToBack(branchToKeep);
  } else {
    replacement = branchToKeep;
  }

  parent.replaceChild(n, replacement);
  reportCodeChange();
  return replacement;
}
 

/**
 * Try folding HOOK (?:) if the condition results of the condition is known.
 * @return the replacement node, if changed, or the original if not
 */
private Node tryFoldHook(Node n) {
  Preconditions.checkState(n.isHook());
  Node parent = n.getParent();
  Preconditions.checkNotNull(parent);
  Node cond = n.getFirstChild();
  Node thenBody = cond.getNext();
  Node elseBody = thenBody.getNext();

  TernaryValue condValue = NodeUtil.getImpureBooleanValue(cond);
  if (condValue == TernaryValue.UNKNOWN) {
    // If the result nodes are equivalent, then one of the nodes can be
    // removed and it doesn't matter which.
    if (!areNodesEqualForInlining(thenBody, elseBody)) {
      return n;  // We can't remove branches otherwise!
    }
  }

  // Transform "(a = 2) ? x =2 : y" into "a=2,x=2"
  n.detachChildren();
  Node branchToKeep = condValue.toBoolean(true) ? thenBody : elseBody;
  Node replacement;
  if (mayHaveSideEffects(cond)) {
    replacement = IR.comma(cond, branchToKeep).srcref(n);
  } else {
    replacement = branchToKeep;
  }

  parent.replaceChild(n, replacement);
  reportCodeChange();
  return replacement;
}
 

/**
 * Try to fold a AND/OR node.
 */
private Node tryFoldAndOr(Node n, Node left, Node right) {
  Node parent = n.getParent();

  Node result = null;

  int type = n.getType();

  TernaryValue leftVal = NodeUtil.getImpureBooleanValue(left);

  if (leftVal != TernaryValue.UNKNOWN) {
    boolean lval = leftVal.toBoolean(true);

    // (TRUE || x) => TRUE (also, (3 || x) => 3)
    // (FALSE && x) => FALSE
    if (lval && type == Token.OR ||
        !lval && type == Token.AND) {
      result = left;

    } else if (!mayHaveSideEffects(left)) {
      // (FALSE || x) => x
      // (TRUE && x) => x
      result = right;
    }
  }

  // Note: Right hand side folding is handled by
  // PeepholeSubstituteAlternateSyntax#tryMinimizeCondition

  if (result != null) {
    // Fold it!
    n.removeChild(result);
    parent.replaceChild(n, result);
    reportCodeChange();

    return result;
  } else {
    return n;
  }
}
 

/**
 * Try to fold comparison nodes, e.g ==
 */
@SuppressWarnings("fallthrough")
private Node tryFoldComparison(Node n, Node left, Node right) {
  TernaryValue result = evaluateComparison(n.getType(), left, right);
  if (result == TernaryValue.UNKNOWN) {
    return n;
  }

  Node newNode = NodeUtil.booleanNode(result.toBoolean(true));
  n.getParent().replaceChild(n, newNode);
  reportCodeChange();

  return newNode;
}
 

/** Returns whether two JS strings are equal. */
private static TernaryValue areStringsEqual(String a, String b) {
  // In JS, browsers parse \v differently. So do not consider strings
  // equal if one contains \v.
  if (a.indexOf('\u000B') != -1 ||
      b.indexOf('\u000B') != -1) {
    return TernaryValue.UNKNOWN;
  } else {
    return a.equals(b) ? TernaryValue.TRUE : TernaryValue.FALSE;
  }
}
 

/**
 * The result of the comparison, or UNKNOWN if the
 * result could not be determined.
 */
private static TernaryValue compareAsNumbers(int op, Node left, Node right) {
  Double leftValue = NodeUtil.getNumberValue(left);
  if (leftValue == null) {
    return TernaryValue.UNKNOWN;
  }
  Double rightValue = NodeUtil.getNumberValue(right);
  if (rightValue == null) {
    return TernaryValue.UNKNOWN;
  }

  double lv = leftValue;
  double rv = rightValue;

  switch (op) {
    case Token.SHEQ:
    case Token.EQ:
      Preconditions.checkState(
          left.isNumber() && right.isNumber());
      return TernaryValue.forBoolean(lv == rv);
    case Token.SHNE:
    case Token.NE:
      Preconditions.checkState(
          left.isNumber() && right.isNumber());
      return TernaryValue.forBoolean(lv != rv);
    case Token.LE:
      return TernaryValue.forBoolean(lv <= rv);
    case Token.LT:
      return TernaryValue.forBoolean(lv <  rv);
    case Token.GE:
      return TernaryValue.forBoolean(lv >= rv);
    case Token.GT:
      return TernaryValue.forBoolean(lv >  rv);
    default:
      return TernaryValue.UNKNOWN;  // don't handle that op
  }
}
 

static TernaryValue evaluateComparison(Token op, Node left, Node right) {
  // Don't try to minimize side-effects here.
  if (NodeUtil.mayHaveSideEffects(left) || NodeUtil.mayHaveSideEffects(right)) {
    return TernaryValue.UNKNOWN;
  }

  switch (op) {
    case EQ:
      return tryAbstractEqualityComparison(left, right);
    case NE:
      return tryAbstractEqualityComparison(left, right).not();
    case SHEQ:
      return tryStrictEqualityComparison(left, right);
    case SHNE:
      return tryStrictEqualityComparison(left, right).not();
    case LT:
      return tryAbstractRelationalComparison(left, right, false);
    case GT:
      return tryAbstractRelationalComparison(right, left, false);
    case LE:
      return tryAbstractRelationalComparison(right, left, true).not();
    case GE:
      return tryAbstractRelationalComparison(left, right, true).not();
    default:
      break;
  }
  throw new IllegalStateException("Unexpected operator for comparison");
}
 

/**
 * Try to fold a AND/OR node.
 */
private Node tryFoldAndOr(Node n, Node left, Node right) {
  Node parent = n.getParent();

  Node result = null;

  int type = n.getType();

  TernaryValue leftVal = NodeUtil.getImpureBooleanValue(left);

  if (leftVal != TernaryValue.UNKNOWN) {
    boolean lval = leftVal.toBoolean(true);

    // (TRUE || x) => TRUE (also, (3 || x) => 3)
    // (FALSE && x) => FALSE
    if (lval && type == Token.OR ||
        !lval && type == Token.AND) {
      result = left;

    } else if (!mayHaveSideEffects(left)) {
      // (FALSE || x) => x
      // (TRUE && x) => x
      result = right;
    }
  }

  // Note: Right hand side folding is handled by
  // PeepholeMinimizeConditions#tryMinimizeCondition

  if (result != null) {
    // Fold it!
    n.removeChild(result);
    parent.replaceChild(n, result);
    reportCodeChange();

    return result;
  } else {
    return n;
  }
}