Java TernaryValue.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;
  }
}
 

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;
}
 

/**
 * Remove always true loop conditions.
 */
private void tryFoldForCondition(Node forCondition) {
  if (NodeUtil.getBooleanValue(forCondition) == TernaryValue.TRUE) {
    forCondition.getParent().replaceChild(forCondition,
        new Node(Token.EMPTY));
    reportCodeChange();
  }
}
 

static String trimJsWhiteSpace(String s) {
  int start = 0;
  int end = s.length();
  while (end > 0
      && isStrWhiteSpaceChar(s.charAt(end - 1)) == TernaryValue.TRUE) {
    end--;
  }
  while (start < end
      && isStrWhiteSpaceChar(s.charAt(start)) == TernaryValue.TRUE) {
    start++;
  }
  return s.substring(start, end);
}
 

/**
 * Remove always true loop conditions.
 */
private void tryFoldForCondition(Node forCondition) {
  if (NodeUtil.getPureBooleanValue(forCondition) == TernaryValue.TRUE) {
    forCondition.getParent().replaceChild(forCondition,
        IR.empty());
    reportCodeChange();
  }
}
 

/** 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;
  }
}
 

static String trimJsWhiteSpace(String s) {
  int start = 0;
  int end = s.length();
  while (end > 0
      && TokenUtil.isStrWhiteSpaceChar(s.charAt(end - 1)) == TernaryValue.TRUE) {
    end--;
  }
  while (start < end
      && TokenUtil.isStrWhiteSpaceChar(s.charAt(start)) == TernaryValue.TRUE) {
    start++;
  }
  return s.substring(start, end);
}
 

/**
 * Remove always true loop conditions.
 */
private void tryFoldForCondition(Node forCondition) {
  if (NodeUtil.getPureBooleanValue(forCondition) == TernaryValue.TRUE) {
    compiler.reportChangeToEnclosingScope(forCondition);
    forCondition.replaceWith(IR.empty());
  }
}
 

/**
 * Gets the boolean value of a node that represents a literal. This method
 * effectively emulates the <code>Boolean()</code> JavaScript cast function
 * except it return UNKNOWN for known values with side-effects, use
 * getImpureBooleanValue if you don't care about side-effects.
 */
static TernaryValue getPureBooleanValue(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.NOT:
      return getPureBooleanValue(n.getLastChild()).not();

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

    case Token.VOID:
      if (!mayHaveSideEffects(n.getFirstChild())) {
        return TernaryValue.FALSE;
      }
      break;

    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.REGEXP:
      return TernaryValue.TRUE;

    case Token.ARRAYLIT:
    case Token.OBJECTLIT:
      if (!mayHaveSideEffects(n)) {
        return TernaryValue.TRUE;
      }
      break;
  }

  return TernaryValue.UNKNOWN;
}
 

static boolean isImpureTrue(Node n) {
  return getImpureBooleanValue(n) == TernaryValue.TRUE;
}
 

/**
 * Gets the boolean value of a node that represents a literal. This method
 * effectively emulates the <code>Boolean()</code> JavaScript cast function
 * except it return UNKNOWN for known values with side-effects, use
 * getImpureBooleanValue if you don't care about side-effects.
 */
static TernaryValue getPureBooleanValue(Node n) {
  switch (n.getToken()) {
    case TEMPLATELIT:
      if (n.hasOneChild()) {
        return TernaryValue.forBoolean(!n.getFirstChild().getString().isEmpty());
      }
      break;

    case STRING:
      return TernaryValue.forBoolean(n.getString().length() > 0);

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

    case NOT:
      return getPureBooleanValue(n.getLastChild()).not();

    case NULL:
    case FALSE:
      return TernaryValue.FALSE;

    case VOID:
      if (!mayHaveSideEffects(n.getFirstChild())) {
        return TernaryValue.FALSE;
      }
      break;

    case 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 TRUE:
    case REGEXP:
      return TernaryValue.TRUE;

    case FUNCTION:
    case CLASS:
    case NEW:
    case ARRAYLIT:
    case OBJECTLIT:
      if (!mayHaveSideEffects(n)) {
        return TernaryValue.TRUE;
      }
      break;
    default:
      break;
  }

  return TernaryValue.UNKNOWN;
}
 

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

  Node result = null;
  Node dropped = null;

  Token type = n.getToken();

  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;
      dropped = right;
    } else if (!mayHaveSideEffects(left)) {
      // (FALSE || x) => x
      // (TRUE && x) => x
      result = right;
      dropped = left;
    } else {
      // Left side may have side effects, but we know its boolean value.
      // e.g. true_with_sideeffects || foo() => true_with_sideeffects, foo()
      // or: false_with_sideeffects && foo() => false_with_sideeffects, foo()
      // This, combined with PeepholeRemoveDeadCode, helps reduce expressions
      // like "x() || false || z()".
      n.detachChildren();
      result = IR.comma(left, right);
      dropped = null;
    }
  } else if (parent.getToken() == type && n == parent.getFirstChild()) {
    TernaryValue rightValue = NodeUtil.getImpureBooleanValue(right);
    if (!mayHaveSideEffects(right)) {
      if ((rightValue == TernaryValue.FALSE && type == Token.OR)
          || (rightValue == TernaryValue.TRUE && type == Token.AND)) {
        result = left;
        dropped = right;
      }
    }
  }

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

  if (result != null) {
    // Fold it!
    n.detachChildren();
    parent.replaceChild(n, result);
    compiler.reportChangeToEnclosingScope(result);
    if (dropped != null) {
      NodeUtil.markFunctionsDeleted(dropped, compiler);
    }
    return result;
  } else {
    return n;
  }
}
 

/** http://www.ecma-international.org/ecma-262/6.0/#sec-abstract-equality-comparison */
private static TernaryValue tryAbstractEqualityComparison(Node left, Node right) {
  // Evaluate based on the general type.
  ValueType leftValueType = NodeUtil.getKnownValueType(left);
  ValueType rightValueType = NodeUtil.getKnownValueType(right);
  if (leftValueType != ValueType.UNDETERMINED && rightValueType != ValueType.UNDETERMINED) {
    // Delegate to strict equality comparison for values of the same type.
    if (leftValueType == rightValueType) {
      return tryStrictEqualityComparison(left, right);
    }
    if ((leftValueType == ValueType.NULL && rightValueType == ValueType.VOID)
        || (leftValueType == ValueType.VOID && rightValueType == ValueType.NULL)) {
      return TernaryValue.TRUE;
    }
    if ((leftValueType == ValueType.NUMBER && rightValueType == ValueType.STRING)
        || rightValueType == ValueType.BOOLEAN) {
      Double rv = NodeUtil.getNumberValue(right);
      return rv == null
          ? TernaryValue.UNKNOWN
          : tryAbstractEqualityComparison(left, IR.number(rv));
    }
    if ((leftValueType == ValueType.STRING && rightValueType == ValueType.NUMBER)
        || leftValueType == ValueType.BOOLEAN) {
      Double lv = NodeUtil.getNumberValue(left);
      return lv == null
          ? TernaryValue.UNKNOWN
          : tryAbstractEqualityComparison(IR.number(lv), right);
    }
    if ((leftValueType == ValueType.STRING || leftValueType == ValueType.NUMBER)
        && rightValueType == ValueType.OBJECT) {
      return TernaryValue.UNKNOWN;
    }
    if (leftValueType == ValueType.OBJECT
        && (rightValueType == ValueType.STRING || rightValueType == ValueType.NUMBER)) {
      return TernaryValue.UNKNOWN;
    }
    return TernaryValue.FALSE;
  }
  // In general, the rest of the cases cannot be folded.
  return TernaryValue.UNKNOWN;
}