com.sun.tools.javac.tree.JCTree.JCDoWhileLoop Java Examples

public void visitDoLoop(JCDoWhileLoop tree) {
	try {
		print("do ");
		printStat(tree.body);
		align();
		print(" while ");
		if (PARENS.equals(treeTag(tree.cond))) {
			printExpr(tree.cond);
		} else {
			print("(");
			printExpr(tree.cond);
			print(")");
		}
		print(";");
	} catch (IOException e) {
		throw new UncheckedIOException(e);
	}
}
 

public void visitDoLoop(JCDoWhileLoop tree) {
    ListBuffer<PendingExit> prevPendingExits = pendingExits;
    pendingExits = new ListBuffer<>();
    scanStat(tree.body);
    alive |= resolveContinues(tree);
    scan(tree.cond);
    alive = alive && !tree.cond.type.isTrue();
    alive |= resolveBreaks(tree, prevPendingExits);
}
 

public void visitDoLoop(JCDoWhileLoop tree) {
    ListBuffer<FlowPendingExit> prevPendingExits = pendingExits;
    pendingExits = new ListBuffer<>();
    scan(tree.body);
    resolveContinues(tree);
    scan(tree.cond);
    resolveBreaks(tree, prevPendingExits);
}
 

public void visitDoLoop(JCDoWhileLoop tree) {
    ListBuffer<AssignPendingExit> prevPendingExits = pendingExits;
    FlowKind prevFlowKind = flowKind;
    flowKind = FlowKind.NORMAL;
    final Bits initsSkip = new Bits(true);
    final Bits uninitsSkip = new Bits(true);
    pendingExits = new ListBuffer<>();
    int prevErrors = log.nerrors;
    do {
        final Bits uninitsEntry = new Bits(uninits);
        uninitsEntry.excludeFrom(nextadr);
        scan(tree.body);
        resolveContinues(tree);
        scanCond(tree.cond);
        if (!flowKind.isFinal()) {
            initsSkip.assign(initsWhenFalse);
            uninitsSkip.assign(uninitsWhenFalse);
        }
        if (log.nerrors !=  prevErrors ||
            flowKind.isFinal() ||
            new Bits(uninitsEntry).diffSet(uninitsWhenTrue).nextBit(firstadr)==-1)
            break;
        inits.assign(initsWhenTrue);
        uninits.assign(uninitsEntry.andSet(uninitsWhenTrue));
        flowKind = FlowKind.SPECULATIVE_LOOP;
    } while (true);
    flowKind = prevFlowKind;
    inits.assign(initsSkip);
    uninits.assign(uninitsSkip);
    resolveBreaks(tree, prevPendingExits);
}
 

private DoWhileStatement convertDoWhileLoop(JCDoWhileLoop statement) {
  return DoWhileStatement.newBuilder()
      .setSourcePosition(getSourcePosition(statement))
      .setConditionExpression(convertConditionRemovingOuterParentheses(statement.getCondition()))
      .setBody(convertStatement(statement.getStatement()))
      .build();
}
 

public void visitDoLoop(JCDoWhileLoop tree) {
    SourceRange sr = new SourceRange(startPos(tree), endPos(tree));
    sr.mergeWith(csp(tree.body));
    sr.mergeWith(csp(tree.cond));
    result = sr;
}
 

public void visitDoLoop(JCDoWhileLoop tree) {
    tree.body = translate(tree.body);
    tree.cond = translate(tree.cond, syms.booleanType);
    result = tree;
}
 

public void visitDoLoop(JCDoWhileLoop tree) {
    tree.body = translate(tree.body);
    tree.cond = translate(tree.cond, syms.booleanType);
    result = tree;
}
 

@Override
public void visitDoLoop(JCDoWhileLoop tree) {
    //skip body (to prevents same statements to be analyzed twice)
    scan(tree.getCondition());
}
 

private Statement convertStatement(JCStatement jcStatement) {
  switch (jcStatement.getKind()) {
    case ASSERT:
      return convertAssert((JCAssert) jcStatement);
    case BLOCK:
      return convertBlock((JCBlock) jcStatement);
    case BREAK:
      return convertBreak((JCBreak) jcStatement);
    case CLASS:
      convertClassDeclaration((JCClassDecl) jcStatement);
      return null;
    case CONTINUE:
      return convertContinue((JCContinue) jcStatement);
    case DO_WHILE_LOOP:
      return convertDoWhileLoop((JCDoWhileLoop) jcStatement);
    case EMPTY_STATEMENT:
      return new EmptyStatement(getSourcePosition(jcStatement));
    case ENHANCED_FOR_LOOP:
      return convertEnhancedForLoop((JCEnhancedForLoop) jcStatement);
    case EXPRESSION_STATEMENT:
      return convertExpressionStatement((JCExpressionStatement) jcStatement);
    case FOR_LOOP:
      return convertForLoop((JCForLoop) jcStatement);
    case IF:
      return convertIf((JCIf) jcStatement);
    case LABELED_STATEMENT:
      return convertLabeledStatement((JCLabeledStatement) jcStatement);
    case RETURN:
      return convertReturn((JCReturn) jcStatement);
    case SWITCH:
      return convertSwitch((JCSwitch) jcStatement);
    case THROW:
      return convertThrow((JCThrow) jcStatement);
    case TRY:
      return convertTry((JCTry) jcStatement);
    case VARIABLE:
      return convertVariableDeclaration((JCVariableDecl) jcStatement);
    case WHILE_LOOP:
      return convertWhileLoop((JCWhileLoop) jcStatement);
    case SYNCHRONIZED:
      return convertSynchronized((JCSynchronized) jcStatement);
    default:
      throw new AssertionError("Unknown statement node type: " + jcStatement.getKind());
  }
}
 

@Override
public void visitDoLoop(JCDoWhileLoop tree) {
    scan(tree.getCondition());
}
 

public JCDoWhileLoop DoLoop(JCStatement body, JCExpression cond) {
	return invoke(DoLoop, body, cond);
}
 

@Override
public JCDoWhileLoop inline(Inliner inliner) throws CouldNotResolveImportException {
  return inliner.maker().DoLoop(getStatement().inline(inliner), getCondition().inline(inliner));
}