public Expression replaceExpr(Expression expr) { replacementExpr = null; expr.visit(this); Expression result = replacementExpr == null ? expr : replacementExpr; replacementExpr = null; return result; }
public void visitBooleanExpression(BooleanExpression expression) { expression.getExpression().visit(this); }
public void visitReturnStatement(ReturnStatement statement) { statement.getExpression().visit(this); }
public void visitReturnStatement(ReturnStatement statement) { statement.getExpression().visit(this); }
public T convert(Expression expr) { result = null; expr.visit(this); if (result == null) Assert.fail("No result set for expression: " + expr); T temp = result; result = null; return temp; }
public void visitBinaryExpression(BinaryExpression expression) { Expression left = expression.getLeftExpression(); Expression right = expression.getRightExpression(); boolean leaf = (right instanceof ConstantExpression || left instanceof ConstantExpression); if (!leaf) buffer.append("("); left.visit(this); buffer.append(" "); Token token = expression.getOperation(); buffer.append(tokenAsSql(token)); buffer.append(" "); right.visit(this); if (!leaf) buffer.append(")"); }
@Override public void visitVariableExpression(VariableExpression expr) { if (expr instanceof OldValueExpression) { Expression originalExpr = ((OldValueExpression)expr).getOrginalExpression(); originalExpr.visit(this); // just to count up recordCount and produce the correct number of N/A values at runtime result = expr; return; } result = record(expr); }
public void visitField(FieldNode node) { visitAnnotations(node); Expression init = node.getInitialExpression(); if (init != null) init.visit(this); }
@Override public void visitCaseStatement(CaseStatement stat) { stat.getExpression().visit(this); stat.setCode(replace(stat.getCode())); }
@Override public void visitSynchronizedStatement(SynchronizedStatement stat) { stat.getExpression().visit(this); stat.setCode(replace(stat.getCode())); }
@Override public void visitForLoop(ForStatement stat) { stat.getCollectionExpression().visit(this); stat.setLoopBlock(replace(stat.getLoopBlock())); }
public void visitAssertStatement(final AssertStatement statement) { assertStatementAuthorized(statement); statement.getBooleanExpression().visit(this); statement.getMessageExpression().visit(this); }
@Override protected void visitConstructorOrMethod(MethodNode node, boolean isConstructor) { // ClassCodeVisitorSupport doesn't seem to visit parameters for (Parameter param: node.getParameters()) { visitAnnotations(param); if (param.getInitialExpression() != null) param.getInitialExpression().visit(this); } super.visitConstructorOrMethod(node, isConstructor); }
public void visitSwitch(SwitchStatement statement) { statement.getExpression().visit(this); for (CaseStatement caseStatement : statement.getCaseStatements()) { caseStatement.visit(this); } statement.getDefaultStatement().visit(this); }
@SuppressWarnings("unchecked") @Override public void visitSwitch(SwitchStatement stat) { stat.getExpression().visit(this); replaceAll(stat.getCaseStatements()); stat.setDefaultStatement(replace(stat.getDefaultStatement())); }
public void visitSwitch(final SwitchStatement statement) { assertStatementAuthorized(statement); statement.getExpression().visit(this); for (CaseStatement caseStatement : statement.getCaseStatements()) { caseStatement.visit(this); } statement.getDefaultStatement().visit(this); }
private void visitExpressionOrStatement(Object o) { if (o == EmptyExpression.INSTANCE) return; if (o instanceof Expression) { Expression expr = (Expression) o; int mark = controller.getOperandStack().getStackLength(); expr.visit(controller.getAcg()); controller.getOperandStack().popDownTo(mark); } else { ((Statement) o).visit(controller.getAcg()); } }
public void writeUnaryPlus(UnaryPlusExpression expression) { Expression subExpression = expression.getExpression(); subExpression.visit(controller.getAcg()); controller.getOperandStack().box(); unaryPlus.call(controller.getMethodVisitor()); controller.getOperandStack().replace(ClassHelper.OBJECT_TYPE); controller.getAssertionWriter().record(expression); }
public void writeNotExpression(NotExpression expression) { Expression subExpression = expression.getExpression(); int mark = controller.getOperandStack().getStackLength(); subExpression.visit(controller.getAcg()); controller.getOperandStack().castToBool(mark, true); BytecodeHelper.negateBoolean(controller.getMethodVisitor()); controller.getAssertionWriter().record(expression); } }
public void writeThrow(ThrowStatement statement) { controller.getAcg().onLineNumber(statement, "visitThrowStatement"); writeStatementLabel(statement); MethodVisitor mv = controller.getMethodVisitor(); statement.getExpression().visit(controller.getAcg()); // we should infer the type of the exception from the expression mv.visitTypeInsn(CHECKCAST, "java/lang/Throwable"); mv.visitInsn(ATHROW); controller.getOperandStack().remove(1); }