Java Code Examples for com.google.javascript.rhino.Token#SUB

The following examples show how to use com.google.javascript.rhino.Token#SUB . You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
Source File: jKali_003_s.java    From coming with MIT License 5 votes vote down vote up 
static boolean isNumericResultHelper(Node n) {
  switch (n.getType()) {
    case Token.ADD:
      return !mayBeString(n.getFirstChild())
          && !mayBeString(n.getLastChild());
    case Token.BITNOT:
    case Token.BITOR:
    case Token.BITXOR:
    case Token.BITAND:
    case Token.LSH:
    case Token.RSH:
    case Token.URSH:
    case Token.SUB:
    case Token.MUL:
    case Token.MOD:
    case Token.DIV:
    case Token.INC:
    case Token.DEC:
    case Token.POS:
    case Token.NEG:
    case Token.NUMBER:
      return true;
    case Token.NAME:
      String name = n.getString();
      if (name.equals("NaN")) {
        return true;
      }
      if (name.equals("Infinity")) {
        return true;
      }
      return false;
    default:
      return false;
  }
}
Example 2
Source File: jMutRepair_003_s.java    From coming with MIT License 5 votes vote down vote up 
static boolean isNumericResultHelper(Node n) {
  switch (n.getType()) {
    case Token.ADD:
      return !mayBeString(n.getFirstChild())
          && !mayBeString(n.getLastChild());
    case Token.BITNOT:
    case Token.BITOR:
    case Token.BITXOR:
    case Token.BITAND:
    case Token.LSH:
    case Token.RSH:
    case Token.URSH:
    case Token.SUB:
    case Token.MUL:
    case Token.MOD:
    case Token.DIV:
    case Token.INC:
    case Token.DEC:
    case Token.POS:
    case Token.NEG:
    case Token.NUMBER:
      return true;
    case Token.NAME:
      String name = n.getString();
      if (name.equals("NaN")) {
        return true;
      }
      if (name.equals("Infinity")) {
        return true;
      }
      return false;
    default:
      return false;
  }
}
Example 3
Source File: Closure_78_PeepholeFoldConstants_t.java    From coming with MIT License 5 votes vote down vote up 
private void tryReduceOperandsForOp(Node n) {
  switch (n.getType()) {
    case Token.ADD:
      Node left = n.getFirstChild();
      Node right = n.getLastChild();
      if (!NodeUtil.mayBeString(left) && !NodeUtil.mayBeString(right)) {
        tryConvertOperandsToNumber(n);
      }
      break;
    case Token.ASSIGN_BITOR:
    case Token.ASSIGN_BITXOR:
    case Token.ASSIGN_BITAND:
      // TODO(johnlenz): convert these to integers.
    case Token.ASSIGN_LSH:
    case Token.ASSIGN_RSH:
    case Token.ASSIGN_URSH:
    case Token.ASSIGN_SUB:
    case Token.ASSIGN_MUL:
    case Token.ASSIGN_MOD:
    case Token.ASSIGN_DIV:
      tryConvertToNumber(n.getLastChild());
      break;
    case Token.BITNOT:
    case Token.BITOR:
    case Token.BITXOR:
    case Token.BITAND:
    case Token.LSH:
    case Token.RSH:
    case Token.URSH:
    case Token.SUB:
    case Token.MUL:
    case Token.MOD:
    case Token.DIV:
    case Token.POS:
    case Token.NEG:
      tryConvertOperandsToNumber(n);
      break;
  }
}
Example 4
Source File: Closure_75_NodeUtil_t.java    From coming with MIT License 5 votes vote down vote up 
/**
 * A "simple" operator is one whose children are expressions,
 * has no direct side-effects (unlike '+='), and has no
 * conditional aspects (unlike '||').
 */
static boolean isSimpleOperatorType(int type) {
  switch (type) {
    case Token.ADD:
    case Token.BITAND:
    case Token.BITNOT:
    case Token.BITOR:
    case Token.BITXOR:
    case Token.COMMA:
    case Token.DIV:
    case Token.EQ:
    case Token.GE:
    case Token.GETELEM:
    case Token.GETPROP:
    case Token.GT:
    case Token.INSTANCEOF:
    case Token.LE:
    case Token.LSH:
    case Token.LT:
    case Token.MOD:
    case Token.MUL:
    case Token.NE:
    case Token.NOT:
    case Token.RSH:
    case Token.SHEQ:
    case Token.SHNE:
    case Token.SUB:
    case Token.TYPEOF:
    case Token.VOID:
    case Token.POS:
    case Token.NEG:
    case Token.URSH:
      return true;

    default:
      return false;
  }
}
Example 5
Source File: Closure_60_NodeUtil_s.java    From coming with MIT License 5 votes vote down vote up 
static int getOpFromAssignmentOp(Node n) {
  switch (n.getType()){
    case Token.ASSIGN_BITOR:
      return Token.BITOR;
    case Token.ASSIGN_BITXOR:
      return Token.BITXOR;
    case Token.ASSIGN_BITAND:
      return Token.BITAND;
    case Token.ASSIGN_LSH:
      return Token.LSH;
    case Token.ASSIGN_RSH:
      return Token.RSH;
    case Token.ASSIGN_URSH:
      return Token.URSH;
    case Token.ASSIGN_ADD:
      return Token.ADD;
    case Token.ASSIGN_SUB:
      return Token.SUB;
    case Token.ASSIGN_MUL:
      return Token.MUL;
    case Token.ASSIGN_DIV:
      return Token.DIV;
    case Token.ASSIGN_MOD:
      return Token.MOD;
  }
  throw new IllegalArgumentException("Not an assiment op");
}
Example 6
Source File: Closure_60_NodeUtil_t.java    From coming with MIT License 5 votes vote down vote up 
static boolean isNumericResultHelper(Node n) {
  switch (n.getType()) {
    case Token.ADD:
      return !mayBeString(n.getFirstChild())
          && !mayBeString(n.getLastChild());
    case Token.BITNOT:
    case Token.BITOR:
    case Token.BITXOR:
    case Token.BITAND:
    case Token.LSH:
    case Token.RSH:
    case Token.URSH:
    case Token.SUB:
    case Token.MUL:
    case Token.MOD:
    case Token.DIV:
    case Token.INC:
    case Token.DEC:
    case Token.POS:
    case Token.NEG:
    case Token.NUMBER:
      return true;
    case Token.NAME:
      String name = n.getString();
      if (name.equals("NaN")) {
        return true;
      }
      if (name.equals("Infinity")) {
        return true;
      }
      return false;
    default:
      return false;
  }
}
Example 7
Source File: Closure_94_NodeUtil_t.java    From coming with MIT License 5 votes vote down vote up 
/**
 * A "simple" operator is one whose children are expressions,
 * has no direct side-effects (unlike '+='), and has no
 * conditional aspects (unlike '||').
 */
static boolean isSimpleOperatorType(int type) {
  switch (type) {
    case Token.ADD:
    case Token.BITAND:
    case Token.BITNOT:
    case Token.BITOR:
    case Token.BITXOR:
    case Token.COMMA:
    case Token.DIV:
    case Token.EQ:
    case Token.GE:
    case Token.GETELEM:
    case Token.GETPROP:
    case Token.GT:
    case Token.INSTANCEOF:
    case Token.LE:
    case Token.LSH:
    case Token.LT:
    case Token.MOD:
    case Token.MUL:
    case Token.NE:
    case Token.NOT:
    case Token.RSH:
    case Token.SHEQ:
    case Token.SHNE:
    case Token.SUB:
    case Token.TYPEOF:
    case Token.VOID:
    case Token.POS:
    case Token.NEG:
    case Token.URSH:
      return true;

    default:
      return false;
  }
}
Example 8
Source File: Cardumen_00149_t.java    From coming with MIT License 5 votes vote down vote up 
static boolean isNumericResultHelper(Node n) {
  switch (n.getType()) {
    case Token.ADD:
      return !mayBeString(n.getFirstChild())
          && !mayBeString(n.getLastChild());
    case Token.BITNOT:
    case Token.BITOR:
    case Token.BITXOR:
    case Token.BITAND:
    case Token.LSH:
    case Token.RSH:
    case Token.URSH:
    case Token.SUB:
    case Token.MUL:
    case Token.MOD:
    case Token.DIV:
    case Token.INC:
    case Token.DEC:
    case Token.POS:
    case Token.NEG:
    case Token.NUMBER:
      return true;
    case Token.NAME:
      String name = n.getString();
      if (name.equals("NaN")) {
        return true;
      }
      if (name.equals("Infinity")) {
        return true;
      }
      return false;
    default:
      return false;
  }
}
Example 9
Source File: Cardumen_0087_s.java    From coming with MIT License 5 votes vote down vote up 
/**
 * A "simple" operator is one whose children are expressions,
 * has no direct side-effects (unlike '+='), and has no
 * conditional aspects (unlike '||').
 */
static boolean isSimpleOperatorType(int type) {
  switch (type) {
    case Token.ADD:
    case Token.BITAND:
    case Token.BITNOT:
    case Token.BITOR:
    case Token.BITXOR:
    case Token.COMMA:
    case Token.DIV:
    case Token.EQ:
    case Token.GE:
    case Token.GETELEM:
    case Token.GETPROP:
    case Token.GT:
    case Token.INSTANCEOF:
    case Token.LE:
    case Token.LSH:
    case Token.LT:
    case Token.MOD:
    case Token.MUL:
    case Token.NE:
    case Token.NOT:
    case Token.RSH:
    case Token.SHEQ:
    case Token.SHNE:
    case Token.SUB:
    case Token.TYPEOF:
    case Token.VOID:
    case Token.POS:
    case Token.NEG:
    case Token.URSH:
      return true;

    default:
      return false;
  }
}
Example 10
Source File: PeepholeFoldConstants.java    From astor with GNU General Public License v2.0 5 votes vote down vote up 
private void tryReduceOperandsForOp(Node n) {
  switch (n.getType()) {
    case Token.ADD:
      Node left = n.getFirstChild();
      Node right = n.getLastChild();
      if (!NodeUtil.mayBeString(left) && !NodeUtil.mayBeString(right)) {
        tryConvertOperandsToNumber(n);
      }
      break;
    case Token.ASSIGN_BITOR:
    case Token.ASSIGN_BITXOR:
    case Token.ASSIGN_BITAND:
      // TODO(johnlenz): convert these to integers.
    case Token.ASSIGN_LSH:
    case Token.ASSIGN_RSH:
    case Token.ASSIGN_URSH:
    case Token.ASSIGN_SUB:
    case Token.ASSIGN_MUL:
    case Token.ASSIGN_MOD:
    case Token.ASSIGN_DIV:
      tryConvertToNumber(n.getLastChild());
      break;
    case Token.BITNOT:
    case Token.BITOR:
    case Token.BITXOR:
    case Token.BITAND:
    case Token.LSH:
    case Token.RSH:
    case Token.URSH:
    case Token.SUB:
    case Token.MUL:
    case Token.MOD:
    case Token.DIV:
    case Token.POS:
    case Token.NEG:
      tryConvertOperandsToNumber(n);
      break;
  }
}
Example 11
Source File: Cardumen_0087_s.java    From coming with MIT License 4 votes vote down vote up 
/**
 * Determines whether the given value may be assigned to a define.
 *
 * @param val The value being assigned.
 * @param defines The list of names of existing defines.
 */
static boolean isValidDefineValue(Node val, Set<String> defines) {
  switch (val.getType()) {
    case Token.STRING:
    case Token.NUMBER:
    case Token.TRUE:
    case Token.FALSE:
      return true;

    // Binary operators are only valid if both children are valid.
    case Token.ADD:
    case Token.BITAND:
    case Token.BITNOT:
    case Token.BITOR:
    case Token.BITXOR:
    case Token.DIV:
    case Token.EQ:
    case Token.GE:
    case Token.GT:
    case Token.LE:
    case Token.LSH:
    case Token.LT:
    case Token.MOD:
    case Token.MUL:
    case Token.NE:
    case Token.RSH:
    case Token.SHEQ:
    case Token.SHNE:
    case Token.SUB:
    case Token.URSH:
      return isValidDefineValue(val.getFirstChild(), defines)
          && isValidDefineValue(val.getLastChild(), defines);

    // Unary operators are valid if the child is valid.
    case Token.NOT:
    case Token.NEG:
    case Token.POS:
      return isValidDefineValue(val.getFirstChild(), defines);

    // Names are valid if and only if they are defines themselves.
    case Token.NAME:
    case Token.GETPROP:
      if (val.isQualifiedName()) {
        return defines.contains(val.getQualifiedName());
      }
  }
  return false;
}
Example 12
Source File: Cardumen_0014_t.java    From coming with MIT License 4 votes vote down vote up 
/**
 * Determines whether the given value may be assigned to a define.
 *
 * @param val The value being assigned.
 * @param defines The list of names of existing defines.
 */
static boolean isValidDefineValue(Node val, Set<String> defines) {
  switch (val.getType()) {
    case Token.STRING:
    case Token.NUMBER:
    case Token.TRUE:
    case Token.FALSE:
      return true;

    // Binary operators are only valid if both children are valid.
    case Token.ADD:
    case Token.BITAND:
    case Token.BITNOT:
    case Token.BITOR:
    case Token.BITXOR:
    case Token.DIV:
    case Token.EQ:
    case Token.GE:
    case Token.GT:
    case Token.LE:
    case Token.LSH:
    case Token.LT:
    case Token.MOD:
    case Token.MUL:
    case Token.NE:
    case Token.RSH:
    case Token.SHEQ:
    case Token.SHNE:
    case Token.SUB:
    case Token.URSH:
      return isValidDefineValue(val.getFirstChild(), defines)
          && isValidDefineValue(val.getLastChild(), defines);

    // Unary operators are valid if the child is valid.
    case Token.NOT:
    case Token.NEG:
    case Token.POS:
      return isValidDefineValue(val.getFirstChild(), defines);

    // Names are valid if and only if they are defines themselves.
    case Token.NAME:
    case Token.GETPROP:
      if (val.isQualifiedName()) {
        return defines.contains(val.getQualifiedName());
      }
  }
  return false;
}
Example 13
Source File: Closure_23_PeepholeFoldConstants_s.java    From coming with MIT License 4 votes vote down vote up 
private Node tryFoldBinaryOperator(Node subtree) {
  Node left = subtree.getFirstChild();

  if (left == null) {
    return subtree;
  }

  Node right = left.getNext();

  if (right == null) {
    return subtree;
  }

  // If we've reached here, node is truly a binary operator.
  switch(subtree.getType()) {
    case Token.GETPROP:
      return tryFoldGetProp(subtree, left, right);

    case Token.GETELEM:
      return tryFoldGetElem(subtree, left, right);

    case Token.INSTANCEOF:
      return tryFoldInstanceof(subtree, left, right);

    case Token.AND:
    case Token.OR:
      return tryFoldAndOr(subtree, left, right);

    case Token.LSH:
    case Token.RSH:
    case Token.URSH:
      return tryFoldShift(subtree, left, right);

    case Token.ASSIGN:
      return tryFoldAssign(subtree, left, right);

    case Token.ASSIGN_BITOR:
    case Token.ASSIGN_BITXOR:
    case Token.ASSIGN_BITAND:
    case Token.ASSIGN_LSH:
    case Token.ASSIGN_RSH:
    case Token.ASSIGN_URSH:
    case Token.ASSIGN_ADD:
    case Token.ASSIGN_SUB:
    case Token.ASSIGN_MUL:
    case Token.ASSIGN_DIV:
    case Token.ASSIGN_MOD:
      return tryUnfoldAssignOp(subtree, left, right);

    case Token.ADD:
      return tryFoldAdd(subtree, left, right);

    case Token.SUB:
    case Token.DIV:
    case Token.MOD:
      return tryFoldArithmeticOp(subtree, left, right);

    case Token.MUL:
    case Token.BITAND:
    case Token.BITOR:
    case Token.BITXOR:
      Node result = tryFoldArithmeticOp(subtree, left, right);
      if (result != subtree) {
        return result;
      }
      return tryFoldLeftChildOp(subtree, left, right);

    case Token.LT:
    case Token.GT:
    case Token.LE:
    case Token.GE:
    case Token.EQ:
    case Token.NE:
    case Token.SHEQ:
    case Token.SHNE:
      return tryFoldComparison(subtree, left, right);

    default:
      return subtree;
  }
}
Example 14
Source File: Closure_23_PeepholeFoldConstants_t.java    From coming with MIT License 4 votes vote down vote up 
/**
 * Try to fold arithmetic binary operators
 */
private Node performArithmeticOp(int opType, Node left, Node right) {
  // Unlike other operations, ADD operands are not always converted
  // to Number.
  if (opType == Token.ADD
      && (NodeUtil.mayBeString(left, false)
          || NodeUtil.mayBeString(right, false))) {
    return null;
  }

  double result;

  // TODO(johnlenz): Handle NaN with unknown value. BIT ops convert NaN
  // to zero so this is a little awkward here.

  Double lValObj = NodeUtil.getNumberValue(left);
  if (lValObj == null) {
    return null;
  }
  Double rValObj = NodeUtil.getNumberValue(right);
  if (rValObj == null) {
    return null;
  }

  double lval = lValObj;
  double rval = rValObj;

  switch (opType) {
    case Token.BITAND:
      result = ScriptRuntime.toInt32(lval) & ScriptRuntime.toInt32(rval);
      break;
    case Token.BITOR:
      result = ScriptRuntime.toInt32(lval) | ScriptRuntime.toInt32(rval);
      break;
    case Token.BITXOR:
      result = ScriptRuntime.toInt32(lval) ^ ScriptRuntime.toInt32(rval);
      break;
    case Token.ADD:
      result = lval + rval;
      break;
    case Token.SUB:
      result = lval - rval;
      break;
    case Token.MUL:
      result = lval * rval;
      break;
    case Token.MOD:
      if (rval == 0) {
        return null;
      }
      result = lval % rval;
      break;
    case Token.DIV:
      if (rval == 0) {
        return null;
      }
      result = lval / rval;
      break;
    default:
      throw new Error("Unexpected arithmetic operator");
  }

  // TODO(johnlenz): consider removing the result length check.
  // length of the left and right value plus 1 byte for the operator.
  if ((String.valueOf(result).length() <=
      String.valueOf(lval).length() + String.valueOf(rval).length() + 1

      // Do not try to fold arithmetic for numbers > 2^53. After that
      // point, fixed-point math starts to break down and become inaccurate.
      && Math.abs(result) <= MAX_FOLD_NUMBER)
      || Double.isNaN(result)
      || result == Double.POSITIVE_INFINITY
      || result == Double.NEGATIVE_INFINITY) {
    return NodeUtil.numberNode(result, null);
  }
  return null;
}
Example 15
Source File: Cardumen_0014_t.java    From coming with MIT License 4 votes vote down vote up 
/**
 * Converts an operator's token value (see {@link Token}) to a string
 * representation.
 *
 * @param operator the operator's token value to convert
 * @return the string representation or {@code null} if the token value is
 * not an operator
 */
static String opToStr(int operator) {
  switch (operator) {
    case Token.BITOR: return "|";
    case Token.OR: return "||";
    case Token.BITXOR: return "^";
    case Token.AND: return "&&";
    case Token.BITAND: return "&";
    case Token.SHEQ: return "===";
    case Token.EQ: return "==";
    case Token.NOT: return "!";
    case Token.NE: return "!=";
    case Token.SHNE: return "!==";
    case Token.LSH: return "<<";
    case Token.IN: return "in";
    case Token.LE: return "<=";
    case Token.LT: return "<";
    case Token.URSH: return ">>>";
    case Token.RSH: return ">>";
    case Token.GE: return ">=";
    case Token.GT: return ">";
    case Token.MUL: return "*";
    case Token.DIV: return "/";
    case Token.MOD: return "%";
    case Token.BITNOT: return "~";
    case Token.ADD: return "+";
    case Token.SUB: return "-";
    case Token.POS: return "+";
    case Token.NEG: return "-";
    case Token.ASSIGN: return "=";
    case Token.ASSIGN_BITOR: return "|=";
    case Token.ASSIGN_BITXOR: return "^=";
    case Token.ASSIGN_BITAND: return "&=";
    case Token.ASSIGN_LSH: return "<<=";
    case Token.ASSIGN_RSH: return ">>=";
    case Token.ASSIGN_URSH: return ">>>=";
    case Token.ASSIGN_ADD: return "+=";
    case Token.ASSIGN_SUB: return "-=";
    case Token.ASSIGN_MUL: return "*=";
    case Token.ASSIGN_DIV: return "/=";
    case Token.ASSIGN_MOD: return "%=";
    case Token.VOID: return "void";
    case Token.TYPEOF: return "typeof";
    case Token.INSTANCEOF: return "instanceof";
    default: return null;
  }
}
Example 16
Source File: Closure_94_NodeUtil_s.java    From coming with MIT License 4 votes vote down vote up 
static int precedence(int type) {
  switch (type) {
    case Token.COMMA:  return 0;
    case Token.ASSIGN_BITOR:
    case Token.ASSIGN_BITXOR:
    case Token.ASSIGN_BITAND:
    case Token.ASSIGN_LSH:
    case Token.ASSIGN_RSH:
    case Token.ASSIGN_URSH:
    case Token.ASSIGN_ADD:
    case Token.ASSIGN_SUB:
    case Token.ASSIGN_MUL:
    case Token.ASSIGN_DIV:
    case Token.ASSIGN_MOD:
    case Token.ASSIGN: return 1;
    case Token.HOOK:   return 2;  // ?: operator
    case Token.OR:     return 3;
    case Token.AND:    return 4;
    case Token.BITOR:  return 5;
    case Token.BITXOR: return 6;
    case Token.BITAND: return 7;
    case Token.EQ:
    case Token.NE:
    case Token.SHEQ:
    case Token.SHNE:   return 8;
    case Token.LT:
    case Token.GT:
    case Token.LE:
    case Token.GE:
    case Token.INSTANCEOF:
    case Token.IN:     return 9;
    case Token.LSH:
    case Token.RSH:
    case Token.URSH:   return 10;
    case Token.SUB:
    case Token.ADD:    return 11;
    case Token.MUL:
    case Token.MOD:
    case Token.DIV:    return 12;
    case Token.INC:
    case Token.DEC:
    case Token.NEW:
    case Token.DELPROP:
    case Token.TYPEOF:
    case Token.VOID:
    case Token.NOT:
    case Token.BITNOT:
    case Token.POS:
    case Token.NEG:    return 13;

    case Token.ARRAYLIT:
    case Token.CALL:
    case Token.EMPTY:
    case Token.FALSE:
    case Token.FUNCTION:
    case Token.GETELEM:
    case Token.GETPROP:
    case Token.GET_REF:
    case Token.IF:
    case Token.LP:
    case Token.NAME:
    case Token.NULL:
    case Token.NUMBER:
    case Token.OBJECTLIT:
    case Token.REGEXP:
    case Token.RETURN:
    case Token.STRING:
    case Token.THIS:
    case Token.TRUE:
      return 15;

    default: throw new Error("Unknown precedence for " +
                             Node.tokenToName(type) +
                             " (type " + type + ")");
  }
}
Example 17
Source File: Closure_60_NodeUtil_s.java    From coming with MIT License 4 votes vote down vote up 
/**
 * Determines whether the given value may be assigned to a define.
 *
 * @param val The value being assigned.
 * @param defines The list of names of existing defines.
 */
static boolean isValidDefineValue(Node val, Set<String> defines) {
  switch (val.getType()) {
    case Token.STRING:
    case Token.NUMBER:
    case Token.TRUE:
    case Token.FALSE:
      return true;

    // Binary operators are only valid if both children are valid.
    case Token.ADD:
    case Token.BITAND:
    case Token.BITNOT:
    case Token.BITOR:
    case Token.BITXOR:
    case Token.DIV:
    case Token.EQ:
    case Token.GE:
    case Token.GT:
    case Token.LE:
    case Token.LSH:
    case Token.LT:
    case Token.MOD:
    case Token.MUL:
    case Token.NE:
    case Token.RSH:
    case Token.SHEQ:
    case Token.SHNE:
    case Token.SUB:
    case Token.URSH:
      return isValidDefineValue(val.getFirstChild(), defines)
          && isValidDefineValue(val.getLastChild(), defines);

    // Uniary operators are valid if the child is valid.
    case Token.NOT:
    case Token.NEG:
    case Token.POS:
      return isValidDefineValue(val.getFirstChild(), defines);

    // Names are valid if and only if they are defines themselves.
    case Token.NAME:
    case Token.GETPROP:
      if (val.isQualifiedName()) {
        return defines.contains(val.getQualifiedName());
      }
  }
  return false;
}
Example 18
Source File: Closure_61_NodeUtil_s.java    From coming with MIT License 4 votes vote down vote up 
/**
 * Converts an operator's token value (see {@link Token}) to a string
 * representation.
 *
 * @param operator the operator's token value to convert
 * @return the string representation or {@code null} if the token value is
 * not an operator
 */
static String opToStr(int operator) {
  switch (operator) {
    case Token.BITOR: return "|";
    case Token.OR: return "||";
    case Token.BITXOR: return "^";
    case Token.AND: return "&&";
    case Token.BITAND: return "&";
    case Token.SHEQ: return "===";
    case Token.EQ: return "==";
    case Token.NOT: return "!";
    case Token.NE: return "!=";
    case Token.SHNE: return "!==";
    case Token.LSH: return "<<";
    case Token.IN: return "in";
    case Token.LE: return "<=";
    case Token.LT: return "<";
    case Token.URSH: return ">>>";
    case Token.RSH: return ">>";
    case Token.GE: return ">=";
    case Token.GT: return ">";
    case Token.MUL: return "*";
    case Token.DIV: return "/";
    case Token.MOD: return "%";
    case Token.BITNOT: return "~";
    case Token.ADD: return "+";
    case Token.SUB: return "-";
    case Token.POS: return "+";
    case Token.NEG: return "-";
    case Token.ASSIGN: return "=";
    case Token.ASSIGN_BITOR: return "|=";
    case Token.ASSIGN_BITXOR: return "^=";
    case Token.ASSIGN_BITAND: return "&=";
    case Token.ASSIGN_LSH: return "<<=";
    case Token.ASSIGN_RSH: return ">>=";
    case Token.ASSIGN_URSH: return ">>>=";
    case Token.ASSIGN_ADD: return "+=";
    case Token.ASSIGN_SUB: return "-=";
    case Token.ASSIGN_MUL: return "*=";
    case Token.ASSIGN_DIV: return "/=";
    case Token.ASSIGN_MOD: return "%=";
    case Token.VOID: return "void";
    case Token.TYPEOF: return "typeof";
    case Token.INSTANCEOF: return "instanceof";
    default: return null;
  }
}
Example 19
Source File: Cardumen_00200_t.java    From coming with MIT License 4 votes vote down vote up 
/**
 * Converts an operator's token value (see {@link Token}) to a string
 * representation.
 *
 * @param operator the operator's token value to convert
 * @return the string representation or {@code null} if the token value is
 * not an operator
 */
static String opToStr(int operator) {
  switch (operator) {
    case Token.BITOR: return "|";
    case Token.OR: return "||";
    case Token.BITXOR: return "^";
    case Token.AND: return "&&";
    case Token.BITAND: return "&";
    case Token.SHEQ: return "===";
    case Token.EQ: return "==";
    case Token.NOT: return "!";
    case Token.NE: return "!=";
    case Token.SHNE: return "!==";
    case Token.LSH: return "<<";
    case Token.IN: return "in";
    case Token.LE: return "<=";
    case Token.LT: return "<";
    case Token.URSH: return ">>>";
    case Token.RSH: return ">>";
    case Token.GE: return ">=";
    case Token.GT: return ">";
    case Token.MUL: return "*";
    case Token.DIV: return "/";
    case Token.MOD: return "%";
    case Token.BITNOT: return "~";
    case Token.ADD: return "+";
    case Token.SUB: return "-";
    case Token.POS: return "+";
    case Token.NEG: return "-";
    case Token.ASSIGN: return "=";
    case Token.ASSIGN_BITOR: return "|=";
    case Token.ASSIGN_BITXOR: return "^=";
    case Token.ASSIGN_BITAND: return "&=";
    case Token.ASSIGN_LSH: return "<<=";
    case Token.ASSIGN_RSH: return ">>=";
    case Token.ASSIGN_URSH: return ">>>=";
    case Token.ASSIGN_ADD: return "+=";
    case Token.ASSIGN_SUB: return "-=";
    case Token.ASSIGN_MUL: return "*=";
    case Token.ASSIGN_DIV: return "/=";
    case Token.ASSIGN_MOD: return "%=";
    case Token.VOID: return "void";
    case Token.TYPEOF: return "typeof";
    case Token.INSTANCEOF: return "instanceof";
    default: return null;
  }
}
Example 20
Source File: Closure_105_FoldConstants_s.java    From coming with MIT License 4 votes vote down vote up 
private void tryFoldAssign(NodeTraversal t, Node n, Node left, Node right) {
  Preconditions.checkArgument(n.getType() == Token.ASSIGN);

  // Tries to convert x = x + y -> x += y;
  if (!right.hasChildren() ||
      right.getFirstChild().getNext() != right.getLastChild()) {
    // RHS must have two children.
    return;
  }

  if (NodeUtil.mayHaveSideEffects(left)) {
    return;
  }

  Node leftChild = right.getFirstChild();
  if (!compiler.areNodesEqualForInlining(left, leftChild)) {
    return;
  }

  int newType = -1;
  switch (right.getType()) {
    case Token.ADD:
      newType = Token.ASSIGN_ADD;
      break;
    case Token.BITAND:
      newType = Token.ASSIGN_BITAND;
      break;
    case Token.BITOR:
      newType = Token.ASSIGN_BITOR;
      break;
    case Token.BITXOR:
      newType = Token.ASSIGN_BITXOR;
      break;
    case Token.DIV:
      newType = Token.ASSIGN_DIV;
      break;
    case Token.LSH:
      newType = Token.ASSIGN_LSH;
      break;
    case Token.MOD:
      newType = Token.ASSIGN_MOD;
      break;
    case Token.MUL:
      newType = Token.ASSIGN_MUL;
      break;
    case Token.RSH:
      newType = Token.ASSIGN_RSH;
      break;
    case Token.SUB:
      newType = Token.ASSIGN_SUB;
      break;
    case Token.URSH:
      newType = Token.ASSIGN_URSH;
      break;
    default:
      return;
  }

  n.getParent().replaceChild(n, new Node(newType,
      left.detachFromParent(), right.getLastChild().detachFromParent()));
  t.getCompiler().reportCodeChange();
}