Java Token.TRY属性代码示例

private void removeDeadExprStatementSafely(Node n, Node parent) {
  if (n.getType() == Token.EMPTY ||
      (n.getType() == Token.BLOCK && !n.hasChildren())) {
    // Not always trivial to remove, let FoldContants work its magic later.
    return;
  }
  // Removing an unreachable DO node is messy because it means we still have
  // to execute one iteration. If the DO's body has breaks in the middle, it
  // can get even more trickier and code size might actually increase.
  switch (n.getType()) {
    case Token.DO:
    case Token.TRY:
    case Token.CATCH:
    case Token.FINALLY:
      return;
  }

  NodeUtil.redeclareVarsInsideBranch(n);
  compiler.reportCodeChange();
  if (logger.isLoggable(Level.FINE)) {
    logger.fine("Removing " + n.toString());
  }
  NodeUtil.removeChild(parent, n);
}
 

/**
 * Determines whether the given node is a FOR, DO, WHILE, WITH, or IF node.
 */
static boolean isControlStructure(Node n) {
  switch (n.getType()) {
    case Token.FOR:
    case Token.DO:
    case Token.WHILE:
    case Token.WITH:
    case Token.IF:
    case Token.LABEL:
    case Token.TRY:
    case Token.CATCH:
    case Token.SWITCH:
    case Token.CASE:
    case Token.DEFAULT:
      return true;
    default:
      return false;
  }
}
 

/**
 * Determines whether the given node is code node for FOR, DO,
 * WHILE, WITH, or IF node.
 */
static boolean isControlStructureCodeBlock(Node parent, Node n) {
  switch (parent.getType()) {
    case Token.FOR:
    case Token.WHILE:
    case Token.LABEL:
    case Token.WITH:
      return parent.getLastChild() == n;
    case Token.DO:
      return parent.getFirstChild() == n;
    case Token.IF:
      return parent.getFirstChild() != n;
    case Token.TRY:
      return parent.getFirstChild() == n || parent.getLastChild() == n;
    case Token.CATCH:
      return parent.getLastChild() == n;
    case Token.SWITCH:
    case Token.CASE:
      return parent.getFirstChild() != n;
    case Token.DEFAULT:
      return true;
    default:
      Preconditions.checkState(isControlStructure(parent));
      return false;
  }
}
 

/**
 * Determines whether the given node can be terminated with a BREAK node.
 */
static boolean isBreakStructure(Node n, boolean labeled) {
  switch (n.getType()) {
    case Token.FOR:
    case Token.DO:
    case Token.WHILE:
    case Token.SWITCH:
      return true;
    case Token.BLOCK:
    case Token.IF:
    case Token.TRY:
      return labeled;
    default:
      return false;
  }
}
 

@Override
public void visit(NodeTraversal t, Node n, Node parent) {
  if (parent == null) {
    return;
  }
  if (n.getType() == Token.FUNCTION || n.getType() == Token.SCRIPT) {
    return;
  }
  // Removes TRYs that had its CATCH removed and/or empty FINALLY.
  if (n.getType() == Token.TRY) {
    Node body = n.getFirstChild();
    Node catchOrFinallyBlock = body.getNext();
    Node finallyBlock = catchOrFinallyBlock.getNext();

    if (!catchOrFinallyBlock.hasChildren() &&
        (finallyBlock == null || !finallyBlock.hasChildren())) {
      n.removeChild(body);
      parent.replaceChild(n, body);
      compiler.reportCodeChange();
      n = body;
    }
  }
  GraphNode<Node, Branch> gNode = curCfg.getNode(n);
  if (gNode == null) { // Not in CFG.
    return;
  }
  if (gNode.getAnnotation() != GraphReachability.REACHABLE ||
      (removeNoOpStatements && !NodeUtil.mayHaveSideEffects(n))) {
    removeDeadExprStatementSafely(n, parent);
  }
}
 

/**
 * @return true if this node marks the start of a new basic block
 */
private static boolean isBlockBoundary(Node n, Node parent) {
  if (parent != null) {
    switch (parent.getType()) {
      case Token.DO:
      case Token.FOR:
      case Token.TRY:
      case Token.WHILE:
      case Token.WITH:
        // NOTE: TRY has up to 3 child blocks:
        // TRY
        //   BLOCK
        //   BLOCK
        //     CATCH
        //   BLOCK
        // Note that there is an explcit CATCH token but no explicit
        // FINALLY token. For simplicity, we consider each BLOCK
        // a separate basic BLOCK.
        return true;
      case Token.AND:
      case Token.HOOK:
      case Token.IF:
      case Token.OR:
        // The first child of a conditional is not a boundary,
        // but all the rest of the children are.
        return n != parent.getFirstChild();

    }
  }

  return n.getType() == Token.CASE;
}
 

/**
 * Is the {@link Node} currently within a 'throw' expression?
 */
private static boolean isInThrowExpression(Node n) {
  // Look up the traversal stack to find a THROW node
  for (Node ancestor : n.getAncestors()) {
    switch (ancestor.getType()) {
      case Token.THROW:
        return true;
      case Token.IF:
      case Token.WHILE:
      case Token.DO:
      case Token.FOR:
      case Token.SWITCH:
      case Token.CASE:
      case Token.DEFAULT:
      case Token.BLOCK:
      case Token.SCRIPT:
      case Token.FUNCTION:
      case Token.TRY:
      case Token.CATCH:
      case Token.RETURN:
      case Token.EXPR_RESULT:
        // early exit - these nodes types can't be within a THROW
        return false;
    }
  }
  return false;
}
 

@Override
Node processTryStatement(TryStatement statementNode) {
  Node node = new Node(Token.TRY, transform(statementNode.getTryBlock()));
  Node block = new Node(Token.BLOCK);
  boolean lineSet = false;

  for (CatchClause cc : statementNode.getCatchClauses()) {
    // Mark the enclosing block at the same line as the first catch
    // clause.
    if (lineSet == false) {
        block.setLineno(cc.getLineno());
        lineSet = true;
    }
    block.addChildToBack(transform(cc));
  }
  node.addChildToBack(block);

  AstNode finallyBlock = statementNode.getFinallyBlock();
  if (finallyBlock != null) {
    node.addChildToBack(transform(finallyBlock));
  }

  // If we didn't set the line on the catch clause, then
  // we've got an empty catch clause.  Set its line to be the same
  // as the finally block (to match Old Rhino's behavior.)
  if ((lineSet == false) && (finallyBlock != null)) {
    block.setLineno(finallyBlock.getLineno());
  }

  return node;
}
 

private void handleBreak(Node node) {
  String label = null;
  // See if it is a break with label.
  if (node.hasChildren()) {
    label = node.getFirstChild().getString();
  }
  Node cur;
  Node lastJump;
  Node parent = node.getParent();
  /*
   * Continuously look up the ancestor tree for the BREAK target or the target
   * with the corresponding label and connect to it. If along the path we
   * discover a FINALLY, we will connect the BREAK to that FINALLY. From then
   * on, we will just record the control flow changes in the finallyMap. This
   * is due to the fact that we need to connect any node that leaves its own
   * FINALLY block to the outer FINALLY or the BREAK's target but those nodes
   * are not known yet due to the way we traverse the nodes.
   */
  for (cur = node, lastJump = node;
      !isBreakTarget(cur, parent, label);
      cur = parent, parent = parent.getParent()) {
    if (cur.getType() == Token.TRY && NodeUtil.hasFinally(cur)) {
      if (lastJump == node) {
        createEdge(lastJump, Branch.UNCOND, computeFallThrough(
            cur.getLastChild()));
      } else {
        finallyMap.put(lastJump, computeFallThrough(cur.getLastChild()));
      }
      lastJump = cur;
    }
    Preconditions.checkState(parent != null, "Cannot find break target.");
  }
  if (lastJump == node) {
    createEdge(lastJump, Branch.UNCOND, computeFollowNode(cur));
  } else {
    finallyMap.put(lastJump, computeFollowNode(cur));
  }
}
 

private void handleContinue(Node node) {
  String label = null;
  if (node.hasChildren()) {
    label = node.getFirstChild().getString();
  }
  Node cur;
  Node lastJump;
  // Similar to handBreak's logic with a few minor variation.
  Node parent = node.getParent();
  for (cur = node, lastJump = node;
      !isContinueTarget(cur, parent, label);
      cur = parent, parent = parent.getParent()) {
    if (cur.getType() == Token.TRY && NodeUtil.hasFinally(cur)) {
      if (lastJump == node) {
        createEdge(lastJump, Branch.UNCOND, cur.getLastChild());
      } else {
        finallyMap.put(lastJump, computeFallThrough(cur.getLastChild()));
      }
      lastJump = cur;
    }
    Preconditions.checkState(parent != null, "Cannot find continue target.");
  }
  Node iter = cur;
  if (cur.getChildCount() == 4) {
    iter = cur.getFirstChild().getNext().getNext();
  }

  if (lastJump == node) {
    createEdge(node, Branch.UNCOND, iter);
  } else {
    finallyMap.put(lastJump, iter);
  }
}
 

/** Whether the child node is the FINALLY block of a try. */
static boolean isTryFinallyNode(Node parent, Node child) {
  return parent.getType() == Token.TRY && parent.getChildCount() == 3
      && child == parent.getLastChild();
}
 

/**
 * @return True if n should be represented by a new CFG node in the control
 * flow graph.
 */
public static boolean isEnteringNewCfgNode(Node n) {
  Node parent = n.getParent();
  switch (parent.getType()) {
    case Token.BLOCK:
    case Token.SCRIPT:
    case Token.TRY:
    case Token.FINALLY:
      return true;
    case Token.FUNCTION:
      // A function node represents the start of a function where the name
      // is bleed into the local scope and parameters has been assigned
      // to the formal argument names. The node includes the name of the
      // function and the LP list since we assume the whole set up process
      // is atomic without change in control flow. The next change of
      // control is going into the function's body represent by the second
      // child.
      return n != parent.getFirstChild().getNext();
    case Token.WHILE:
    case Token.DO:
    case Token.IF:
      // Theses control structure is represented by its node that holds the
      // condition. Each of them is a branch node based on its condition.
      return NodeUtil.getConditionExpression(parent) != n;
      
    case Token.FOR:
      // The FOR(;;) node differs from other control structure in that
      // it has a initialization and a increment statement. Those
      // two statements have its corresponding CFG nodes to represent them.
      // The FOR node represents the condition check for each iteration.
      // That way the following:
      // for(var x = 0; x < 10; x++) { } has a graph that is isomorphic to
      // var x = 0; while(x<10) {  x++; }
      if (NodeUtil.isForIn(parent)) {
        return n == parent.getLastChild(); 
      } else {
        return NodeUtil.getConditionExpression(parent) != n;
      }
    case Token.SWITCH:
    case Token.CASE:
    case Token.CATCH:
    case Token.WITH:
      return n != parent.getFirstChild();
    default:
      return false;
  }
}
 

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

private void handleStmtList(Node node) {
  Node parent = node.getParent();
  // Special case, don't add a block of empty CATCH block to the graph.
  if (node.getType() == Token.BLOCK && parent != null &&
      parent.getType() == Token.TRY &&
      NodeUtil.getCatchBlock(parent) == node &&
      !NodeUtil.hasCatchHandler(node)) {
    return;
  }

  // A block transfer control to its first child if it is not empty.
  Node child = node.getFirstChild();

  // Function declarations are skipped since control doesn't go into that
  // function (unless it is called)
  while (child != null && child.getType() == Token.FUNCTION) {
    child = child.getNext();
  }

  if (child != null) {
    createEdge(node, Branch.UNCOND, computeFallThrough(child));
  } else {
    createEdge(node, Branch.UNCOND, computeFollowNode(node));
  }

  // Synthetic blocks
  if (parent != null) {
    switch (parent.getType()) {
      case Token.DEFAULT:
      case Token.CASE:
      case Token.TRY:
        break;
      default:
        if (node.getType() == Token.BLOCK && node.isSyntheticBlock()) {
          Node next = node.getLastChild();
          if (next != null) {
            createEdge(node, Branch.SYN_BLOCK, computeFallThrough(next));
          }
        }
        break;
    }
  }
}