private void visitSequence(List<Statement> statements) { if (tryCatchFound) { return; } for (Statement statement : statements) { statement.acceptVisitor(this); if (tryCatchFound) { return; } } }
public void visit(List<Statement> statements) { for (Statement part : statements) { part.acceptVisitor(this); } }
private void visitMany(List<Statement> statements) { for (Statement statement : statements) { statement.acceptVisitor(this); } }
private void accept(Statement statement) { statement.acceptVisitor(this); }
private void processSequence(List<Statement> statements) { List<Statement> oldSequence = currentSequence; int oldIndex = currentIndex; currentSequence = statements; for (currentIndex = 0; currentIndex < currentSequence.size(); ++currentIndex) { statements.get(currentIndex).acceptVisitor(this); } currentIndex = oldIndex; currentSequence = oldSequence; }
private void writeSequence(List<Statement> sequence) throws IOException { output.writeShort(sequence.size()); for (Statement part : sequence) { part.acceptVisitor(this); } }
public void eliminate(Statement statement) { usageCounter = new AllBlocksCountVisitor(); statement.acceptVisitor(usageCounter); statement.acceptVisitor(this); }
private void visitStatements(List<Statement> statements) { if (statements.isEmpty()) { return; } boolean oldEnd = end; for (int i = 0; i < statements.size() - 1; ++i) { end = false; statements.get(i).acceptVisitor(this); } end = oldEnd; statements.get(statements.size() - 1).acceptVisitor(this); end = oldEnd; }
@Override public void visit(List<Statement> statements) { if (statements == null) { return; } for (int i = 0; i < statements.size(); ++i) { Statement stmt = statements.get(i); stmt.acceptVisitor(this); if (replaceBy != null) { statements.set(i, replaceBy); replaceBy = null; } } }
public String[] extract(RegularMethodNode node) { node.getBody().acceptVisitor(visitor); String[] result = visitor.dependencies.toArray(new String[0]); visitor.dependencies.clear(); return result; }
private void handleList(List<Statement> statements) { if (statements.isEmpty()) { return; } Statement last = statements.get(statements.size() - 1); if (last instanceof ReturnStatement && ((ReturnStatement) last).getResult() == null) { statements.remove(statements.size() - 1); } else { last.acceptVisitor(this); } } }
@Override public void visit(RegularMethodNode methodNode) { async = false; methodNode.getBody().acceptVisitor(this); }
public void visit(List<Statement> statements) { if (statements == null) { return; } if (statements.isEmpty()) { incrementCurrentBlock(); return; } boolean oldLast = last; for (int i = 0; i < statements.size() - 1; ++i) { last = false; statements.get(i).acceptVisitor(this); } last = true; statements.get(statements.size() - 1).acceptVisitor(this); last = oldLast; }
public boolean check(List<Statement> statements) { if (escaping) { return true; } if (statements.isEmpty()) { escaping = true; return true; } for (int i = statements.size() - 1; i >= 0; --i) { Statement stmt = statements.get(i); if (!isEmpty(stmt)) { stmt.acceptVisitor(this); return escaping; } } escaping = true; return true; }
public String[] extract(AsyncMethodNode node) { for (AsyncMethodPart part : node.getBody()) { part.getStatement().acceptVisitor(visitor); } String[] result = visitor.dependencies.toArray(new String[0]); visitor.dependencies.clear(); return result; }
@Override public void visit(AsyncMethodNode methodNode) { async = true; for (AsyncMethodPart part : methodNode.getBody()) { part.getStatement().acceptVisitor(this); } }
public void write(DataOutput output, RegularMethodNode method) throws IOException { output.writeInt(ElementModifier.pack(method.getModifiers())); output.writeShort(method.getVariables().size()); for (VariableNode var : method.getVariables()) { write(output, var); } try { method.getBody().acceptVisitor(new NodeWriter(output)); } catch (IOExceptionWrapper e) { throw new IOException("Error writing method body", e.getCause()); } }
public void writeAsync(DataOutput output, AsyncMethodNode method) throws IOException { output.writeInt(ElementModifier.pack(method.getModifiers())); output.writeShort(method.getVariables().size()); for (VariableNode var : method.getVariables()) { write(output, var); } try { output.writeShort(method.getBody().size()); for (int i = 0; i < method.getBody().size(); ++i) { method.getBody().get(i).getStatement().acceptVisitor(new NodeWriter(output)); } } catch (IOExceptionWrapper e) { throw new IOException("Error writing method body", e.getCause()); } }
private boolean processSequenceImpl(List<Statement> statements) { for (Statement part : statements) { if (part instanceof SequentialStatement) { if (!processSequenceImpl(((SequentialStatement) part).getSequence())) { return false; } continue; } part.acceptVisitor(this); part = resultStmt; if (part instanceof SequentialStatement) { if (!processSequenceImpl(((SequentialStatement) part).getSequence())) { return false; } continue; } resultSequence.add(part); if (part instanceof BreakStatement) { return false; } } return true; }
public void generateMethod(RegularMethodNode methodNode) { generateMethodSignature(writer, methodNode.getReference(), methodNode.getModifiers().contains(ElementModifier.STATIC), true); writer.print(" {").indent().println(); localsWriter = writer.fragment(); CodeGenerationVisitor visitor = new CodeGenerationVisitor(context, writer, includes); visitor.setCallingMethod(methodNode.getReference()); methodNode.getBody().acceptVisitor(visitor); generateLocals(methodNode, visitor.getTemporaries()); writer.outdent().println("}"); }