Java Token.BREAK属性代码示例

@Override
public boolean shouldTraverse(NodeTraversal t, Node n, Node parent) {
  GraphNode<Node, Branch> gNode = t.getControlFlowGraph().getNode(n);
  if (gNode != null && gNode.getAnnotation() != GraphReachability.REACHABLE) {

    // Only report error when there are some line number informations.
    // There are synthetic nodes with no line number informations, nodes
    // introduce by other passes (although not likely since this pass should
    // be executed early) or some rhino bug.
    if (n.getLineno() != -1 &&
        // Allow spurious semi-colons and spurious breaks.
        n.getType() != Token.EMPTY && n.getType() != Token.BREAK) {
      compiler.report(JSError.make(t, n, level, UNREACHABLE_CODE));
      // From now on, we are going to assume the user fixed the error and not
      // give more warning related to code section reachable from this node.
      new GraphReachability<Node, ControlFlowGraph.Branch>(
          t.getControlFlowGraph()).recompute(n);

      // Saves time by not traversing children.
      return false;
    }
  }
  return true;
}
 

/** @return Whether the node is a label name. */
static boolean isLabelName(Node n) {
  if (n != null && n.getType() == Token.NAME) {
    Node parent = n.getParent();
    switch (parent.getType()) {
      case Token.LABEL:
      case Token.BREAK:
      case Token.CONTINUE:
        if (n == parent.getFirstChild()) {
          return true;
        }
    }
  }
  return false;
}
 

/**
 * Replace the 'return' statement with its child expression.
 *   "return foo()" becomes "{foo(); break;}" or
 *      "{resultName = foo(); break;}"
 *   "return" becomes {break;} or "{resultName = void 0;break;}".
 */
private static Node replaceReturnWithBreak(Node current, Node parent,
    String resultName, String labelName) {

  if (current.getType() == Token.FUNCTION
      || current.getType() == Token.EXPR_RESULT) {
    // Don't recurse into functions definitions, and expressions can't
    // contain RETURN nodes.
    return current;
  }

  if (current.getType() == Token.RETURN) {
    Preconditions.checkState(NodeUtil.isStatementBlock(parent));

    Node resultNode = getReplacementReturnStatement(current, resultName);
    Node name = Node.newString(Token.NAME, labelName);
    Node breakNode = new Node(Token.BREAK, name);

    // Replace the node in parent, and reset current to the first new child.
    parent.replaceChild(current, breakNode);
    if (resultNode != null) {
      parent.addChildBefore(resultNode, breakNode);
    }
    current = breakNode;
  } else {
    for (Node c = current.getFirstChild(); c != null; c = c.getNext()) {
      // c may be replaced.
      c = replaceReturnWithBreak(c, current, resultName, labelName);
    }
  }

  return current;
}
 

/**
 * Delegate the actual processing of the node to visitLabel and
 * visitBreakOrContinue.
 *
 * {@inheritDoc}
 */
public void visit(NodeTraversal nodeTraversal, Node node, Node parent) {
  switch (node.getType()) {
    case Token.LABEL:
      visitLabel(node, parent);
      break;

    case Token.BREAK:
    case Token.CONTINUE:
      visitBreakOrContinue(node);
      break;
  }
}
 

@Override
Node processBreakStatement(BreakStatement statementNode) {
  Node node = new Node(Token.BREAK);
  if (statementNode.getBreakLabel() != null) {
    node.addChildToBack(transform(statementNode.getBreakLabel()));
  }
  return node;
}
 

@Override
public boolean shouldTraverse(
    NodeTraversal nodeTraversal, Node n, Node parent) {
  astPosition.put(n, astPositionCounter++);

  switch (n.getType()) {
    case Token.FUNCTION:
      if (shouldTraverseFunctions || n == cfg.getEntry().getValue()) {
        exceptionHandler.push(n);
        return true;
      }
      return false;
    case Token.TRY:
      exceptionHandler.push(n);
      return true;
  }

  /*
   * We are going to stop the traversal depending on what the node's parent
   * is.
   *
   * We are only interested in adding edges between nodes that change control
   * flow. The most obvious ones are loops and IF-ELSE's. A statement
   * transfers control to its next sibling.
   *
   * In case of an expression tree, there is no control flow within the tree
   * even when there are short circuited operators and conditionals. When we
   * are doing data flow analysis, we will simply synthesize lattices up the
   * expression tree by finding the meet at each expression node.
   *
   * For example: within a Token.SWITCH, the expression in question does not
   * change the control flow and need not to be considered.
   */
  if (parent != null) {
    switch (parent.getType()) {
      case Token.FOR:
        // Only traverse the body of the for loop.
        return n == parent.getLastChild();

      // Skip the conditions.
      case Token.IF:
      case Token.WHILE:
      case Token.WITH:
        return n != parent.getFirstChild();
      case Token.DO:
        return n != parent.getFirstChild().getNext();
      // Only traverse the body of the cases
      case Token.SWITCH:
      case Token.CASE:
      case Token.CATCH:
      case Token.LABEL:
        return n != parent.getFirstChild();
      case Token.FUNCTION:
        return n == parent.getFirstChild().getNext().getNext();
      case Token.CONTINUE:
      case Token.BREAK:
      case Token.EXPR_RESULT:
      case Token.VAR:
      case Token.RETURN:
      case Token.THROW:
        return false;
      case Token.TRY:
        /* Just before we are about to visit the second child of the TRY node,
         * we know that we will be visiting either the CATCH or the FINALLY.
         * In other words, we know that the post order traversal of the TRY
         * block has been finished, no more exceptions can be caught by the
         * handler at this TRY block and should be taken out of the stack.
         */
        if (n == parent.getFirstChild().getNext()) {
          Preconditions.checkState(exceptionHandler.peek() == parent);
          exceptionHandler.pop();
        }
    }
  }
  return true;
}
 

@Override
public void visit(NodeTraversal t, Node n, Node parent) {
  switch (n.getType()) {
    case Token.IF:
      handleIf(n);
      return;
    case Token.WHILE:
      handleWhile(n);
      return;
    case Token.DO:
      handleDo(n);
      return;
    case Token.FOR:
      handleFor(n);
      return;
    case Token.SWITCH:
      handleSwitch(n);
      return;
    case Token.CASE:
      handleCase(n);
      return;
    case Token.DEFAULT:
      handleDefault(n);
      return;
    case Token.BLOCK:
    case Token.SCRIPT:
      handleStmtList(n);
      return;
    case Token.FUNCTION:
      handleFunction(n);
      return;
    case Token.EXPR_RESULT:
      handleExpr(n);
      return;
    case Token.THROW:
      handleThrow(n);
      return;
    case Token.TRY:
      handleTry(n);
      return;
    case Token.CATCH:
      handleCatch(n);
      return;
    case Token.BREAK:
      handleBreak(n);
      return;
    case Token.CONTINUE:
      handleContinue(n);
      return;
    case Token.RETURN:
      handleReturn(n);
      return;
    case Token.WITH:
      handleWith(n);
      return;
    case Token.LABEL:
      return;
    default:
      handleStmt(n);
      return;
  }
}