public void postVisit(ASTNode node) { // check that parent is && or || if (!(node.getParent() instanceof InfixExpression)) return; // we want to add parenthesis around arithmetic operators and instanceof boolean needParenthesis = false; if (node instanceof InfixExpression) { InfixExpression expression = (InfixExpression) node; InfixExpression.Operator operator = expression.getOperator(); InfixExpression parentExpression = (InfixExpression) node.getParent(); InfixExpression.Operator parentOperator = parentExpression.getOperator(); if (parentOperator == operator) return; needParenthesis = (operator == InfixExpression.Operator.LESS) || (operator == InfixExpression.Operator.GREATER) || (operator == InfixExpression.Operator.LESS_EQUALS) || (operator == InfixExpression.Operator.GREATER_EQUALS) || (operator == InfixExpression.Operator.EQUALS) || (operator == InfixExpression.Operator.NOT_EQUALS) || (operator == InfixExpression.Operator.CONDITIONAL_AND) || (operator == InfixExpression.Operator.CONDITIONAL_OR); } if (node instanceof InstanceofExpression) { needParenthesis = true; } if (!needParenthesis) { return; } fNodes.add(node); }
private static int getExpressionPrecedence(Expression expression) { if (expression instanceof PostfixExpression || expression instanceof FunctionInvocation) { return 0; } if (expression instanceof PrefixExpression) { return 1; } if (expression instanceof ClassInstanceCreation) { return 2; } if (expression instanceof InfixExpression) { InfixExpression infixExpression = (InfixExpression) expression; InfixExpression.Operator operator = infixExpression.getOperator(); return getInfixOperatorPrecedence(operator); } if (expression instanceof InstanceofExpression) { return 6; } if (expression instanceof ConditionalExpression) { return 13; } if (expression instanceof Assignment) { return 14; } return -1; }
/* * @see ASTVisitor#visit(InfixExpression) */ public boolean visit(InfixExpression node) { node.getLeftOperand().accept(this); this.fBuffer.append(' '); // for cases like x= i - -1; or x= i++ + ++i; this.fBuffer.append(node.getOperator().toString()); this.fBuffer.append(' '); node.getRightOperand().accept(this); final List extendedOperands = node.extendedOperands(); if (extendedOperands.size() != 0) { this.fBuffer.append(' '); for (Iterator it = extendedOperands.iterator(); it.hasNext(); ) { this.fBuffer.append(node.getOperator().toString()).append(' '); Expression e = (Expression) it.next(); e.accept(this); } } return false; }
public void postVisit(ASTNode node) { if (!(node instanceof ParenthesizedExpression)) { return; } ParenthesizedExpression parenthesizedExpression = (ParenthesizedExpression) node; Expression expression = parenthesizedExpression.getExpression(); while (expression instanceof ParenthesizedExpression) { expression = ((ParenthesizedExpression) expression).getExpression(); } // if this is part of another expression, check for this and parent precedences if (parenthesizedExpression.getParent() instanceof Expression) { Expression parentExpression = (Expression) parenthesizedExpression.getParent(); int expressionPrecedence = getExpressionPrecedence(expression); int parentPrecedence = getExpressionPrecedence(parentExpression); if ((expressionPrecedence > parentPrecedence) && !(parenthesizedExpression.getParent() instanceof ParenthesizedExpression)) { return; } // check for case when precedences for expression and parent are same if ((expressionPrecedence == parentPrecedence) && (parentExpression instanceof InfixExpression)) { // we have expr infix (expr infix expr) removing the parenthesis is equal to (expr infix // expr) infix expr InfixExpression parentInfix = (InfixExpression) parentExpression; Operator parentOperator = parentInfix.getOperator(); if (parentInfix.getLeftOperand() == parenthesizedExpression) { fNodes.add(node); } else if (isAssoziative(parentOperator)) { if (parentOperator == InfixExpression.Operator.PLUS) { if (isStringExpression(parentInfix.getLeftOperand()) || isStringExpression(parentInfix.getRightOperand())) { return; } for (Iterator J = parentInfix.extendedOperands().iterator(); J.hasNext(); ) { Expression operand = (Expression) J.next(); if (isStringExpression(operand)) { return; } } } fNodes.add(node); } return; } else if (expressionPrecedence == parentPrecedence && parentExpression instanceof ConditionalExpression) { if (((ConditionalExpression) parentExpression).getElseExpression() != parenthesizedExpression) return; } } fNodes.add(node); }