/*******************************************************************************
* Copyright (c) 2000, 2009 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jdt.internal.formatter;
import java.util.ArrayList;
import org.eclipse.jdt.internal.compiler.ASTVisitor;
import org.eclipse.jdt.internal.compiler.ast.AND_AND_Expression;
import org.eclipse.jdt.internal.compiler.ast.AllocationExpression;
import org.eclipse.jdt.internal.compiler.ast.ArrayAllocationExpression;
import org.eclipse.jdt.internal.compiler.ast.ArrayInitializer;
import org.eclipse.jdt.internal.compiler.ast.ArrayQualifiedTypeReference;
import org.eclipse.jdt.internal.compiler.ast.ArrayReference;
import org.eclipse.jdt.internal.compiler.ast.ArrayTypeReference;
import org.eclipse.jdt.internal.compiler.ast.Assignment;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import org.eclipse.jdt.internal.compiler.ast.BinaryExpression;
import org.eclipse.jdt.internal.compiler.ast.CastExpression;
import org.eclipse.jdt.internal.compiler.ast.CharLiteral;
import org.eclipse.jdt.internal.compiler.ast.ClassLiteralAccess;
import org.eclipse.jdt.internal.compiler.ast.CombinedBinaryExpression;
import org.eclipse.jdt.internal.compiler.ast.CompoundAssignment;
import org.eclipse.jdt.internal.compiler.ast.ConditionalExpression;
import org.eclipse.jdt.internal.compiler.ast.DoubleLiteral;
import org.eclipse.jdt.internal.compiler.ast.EqualExpression;
import org.eclipse.jdt.internal.compiler.ast.Expression;
import org.eclipse.jdt.internal.compiler.ast.ExtendedStringLiteral;
import org.eclipse.jdt.internal.compiler.ast.FalseLiteral;
import org.eclipse.jdt.internal.compiler.ast.FieldReference;
import org.eclipse.jdt.internal.compiler.ast.FloatLiteral;
import org.eclipse.jdt.internal.compiler.ast.InstanceOfExpression;
import org.eclipse.jdt.internal.compiler.ast.IntLiteral;
import org.eclipse.jdt.internal.compiler.ast.LongLiteral;
import org.eclipse.jdt.internal.compiler.ast.MessageSend;
import org.eclipse.jdt.internal.compiler.ast.StringLiteralConcatenation;
import org.eclipse.jdt.internal.compiler.ast.NullLiteral;
import org.eclipse.jdt.internal.compiler.ast.OR_OR_Expression;
import org.eclipse.jdt.internal.compiler.ast.OperatorIds;
import org.eclipse.jdt.internal.compiler.ast.PostfixExpression;
import org.eclipse.jdt.internal.compiler.ast.PrefixExpression;
import org.eclipse.jdt.internal.compiler.ast.QualifiedAllocationExpression;
import org.eclipse.jdt.internal.compiler.ast.QualifiedNameReference;
import org.eclipse.jdt.internal.compiler.ast.QualifiedSuperReference;
import org.eclipse.jdt.internal.compiler.ast.QualifiedThisReference;
import org.eclipse.jdt.internal.compiler.ast.SingleNameReference;
import org.eclipse.jdt.internal.compiler.ast.StringLiteral;
import org.eclipse.jdt.internal.compiler.ast.SuperReference;
import org.eclipse.jdt.internal.compiler.ast.ThisReference;
import org.eclipse.jdt.internal.compiler.ast.TrueLiteral;
import org.eclipse.jdt.internal.compiler.ast.UnaryExpression;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.eclipse.jdt.internal.compiler.lookup.ClassScope;
import org.eclipse.jdt.internal.compiler.parser.TerminalTokens;
class BinaryExpressionFragmentBuilder
extends ASTVisitor {
ArrayList fragmentsList;
ArrayList operatorsList;
private int realFragmentsSize;
BinaryExpressionFragmentBuilder() {
this.fragmentsList = new ArrayList();
this.operatorsList = new ArrayList();
this.realFragmentsSize = 0;
}
private final void addRealFragment(ASTNode node) {
this.fragmentsList.add(node);
this.realFragmentsSize++;
}
private final void addSmallFragment(ASTNode node) {
this.fragmentsList.add(node);
}
private boolean buildFragments(Expression expression) {
if (((expression.bits & ASTNode.ParenthesizedMASK) >> ASTNode.ParenthesizedSHIFT) != 0) {
addRealFragment(expression);
return false;
}
return true;
}
public ASTNode[] fragments() {
ASTNode[] fragments = new ASTNode[this.fragmentsList.size()];
this.fragmentsList.toArray(fragments);
return fragments;
}
public int[] operators() {
int length = this.operatorsList.size();
int[] tab = new int[length];
for (int i = 0; i < length; i++) {
tab[i] = ((Integer)this.operatorsList.get(i)).intValue();
}
return tab;
}
public int realFragmentsSize() {
return this.realFragmentsSize;
}
public boolean visit(
AllocationExpression allocationExpression,
BlockScope scope) {
addRealFragment(allocationExpression);
return false;
}
public boolean visit(
AND_AND_Expression and_and_Expression,
BlockScope scope) {
if (((and_and_Expression.bits & ASTNode.ParenthesizedMASK) >> ASTNode.ParenthesizedSHIFT) != 0) {
addRealFragment(and_and_Expression);
} else {
and_and_Expression.left.traverse(this, scope);
this.operatorsList.add(new Integer(TerminalTokens.TokenNameAND_AND));
and_and_Expression.right.traverse(this, scope);
}
return false;
}
public boolean visit(
ArrayAllocationExpression arrayAllocationExpression,
BlockScope scope) {
addRealFragment(arrayAllocationExpression);
return false;
}
public boolean visit(ArrayInitializer arrayInitializer, BlockScope scope) {
addRealFragment(arrayInitializer);
return false;
}
public boolean visit(
ArrayQualifiedTypeReference arrayQualifiedTypeReference,
BlockScope scope) {
addRealFragment(arrayQualifiedTypeReference);
return false;
}
public boolean visit(
ArrayQualifiedTypeReference arrayQualifiedTypeReference,
ClassScope scope) {
addRealFragment(arrayQualifiedTypeReference);
return false;
}
public boolean visit(ArrayReference arrayReference, BlockScope scope) {
addRealFragment(arrayReference);
return false;
}
public boolean visit(
ArrayTypeReference arrayTypeReference,
BlockScope scope) {
addRealFragment(arrayTypeReference);
return false;
}
public boolean visit(
ArrayTypeReference arrayTypeReference,
ClassScope scope) {
addRealFragment(arrayTypeReference);
return false;
}
public boolean visit(Assignment assignment, BlockScope scope) {
addRealFragment(assignment);
return false;
}
public boolean visit(BinaryExpression binaryExpression, BlockScope scope) {
if (binaryExpression instanceof CombinedBinaryExpression) {
CombinedBinaryExpression expression = (CombinedBinaryExpression) binaryExpression;
if (expression.referencesTable != null) {
return this.visit(expression, scope);
}
}
final int numberOfParens = (binaryExpression.bits & ASTNode.ParenthesizedMASK) >> ASTNode.ParenthesizedSHIFT;
if (numberOfParens > 0) {
addRealFragment(binaryExpression);
} else {
switch((binaryExpression.bits & ASTNode.OperatorMASK) >> ASTNode.OperatorSHIFT) {
case OperatorIds.PLUS :
if (buildFragments(binaryExpression)) {
binaryExpression.left.traverse(this, scope);
this.operatorsList.add(new Integer(TerminalTokens.TokenNamePLUS));
binaryExpression.right.traverse(this, scope);
}
return false;
case OperatorIds.MINUS :
if (buildFragments(binaryExpression)) {
binaryExpression.left.traverse(this, scope);
this.operatorsList.add(new Integer(TerminalTokens.TokenNameMINUS));
binaryExpression.right.traverse(this, scope);
}
return false;
case OperatorIds.MULTIPLY :
if (buildFragments(binaryExpression)) {
binaryExpression.left.traverse(this, scope);
this.operatorsList.add(new Integer(TerminalTokens.TokenNameMULTIPLY));
binaryExpression.right.traverse(this, scope);
}
return false;
case OperatorIds.REMAINDER :
if (buildFragments(binaryExpression)) {
binaryExpression.left.traverse(this, scope);
this.operatorsList.add(new Integer(TerminalTokens.TokenNameREMAINDER));
binaryExpression.right.traverse(this, scope);
}
return false;
case OperatorIds.XOR :
if (buildFragments(binaryExpression)) {
binaryExpression.left.traverse(this, scope);
this.operatorsList.add(new Integer(TerminalTokens.TokenNameXOR));
binaryExpression.right.traverse(this, scope);
}
return false;
case OperatorIds.DIVIDE :
if (buildFragments(binaryExpression)) {
binaryExpression.left.traverse(this, scope);
this.operatorsList.add(new Integer(TerminalTokens.TokenNameDIVIDE));
binaryExpression.right.traverse(this, scope);
}
return false;
case OperatorIds.OR :
if (buildFragments(binaryExpression)) {
binaryExpression.left.traverse(this, scope);
this.operatorsList.add(new Integer(TerminalTokens.TokenNameOR));
binaryExpression.right.traverse(this, scope);
}
return false;
case OperatorIds.AND :
if (buildFragments(binaryExpression)) {
binaryExpression.left.traverse(this, scope);
this.operatorsList.add(new Integer(TerminalTokens.TokenNameAND));
binaryExpression.right.traverse(this, scope);
}
return false;
default:
addRealFragment(binaryExpression);
}
}
return false;
}
public boolean visit(CombinedBinaryExpression combinedBinaryExpression, BlockScope scope) {
// keep implementation in sync with BinaryExpression#resolveType
if (combinedBinaryExpression.referencesTable == null) {
addRealFragment(combinedBinaryExpression.left);
this.operatorsList.add(new Integer(TerminalTokens.TokenNamePLUS));
addRealFragment(combinedBinaryExpression.right);
return false;
}
BinaryExpression cursor = combinedBinaryExpression.referencesTable[0];
if (cursor.left instanceof CombinedBinaryExpression) {
this.visit((CombinedBinaryExpression) cursor.left, scope);
} else {
addRealFragment(cursor.left);
}
for (int i = 0, end = combinedBinaryExpression.arity; i < end; i ++) {
this.operatorsList.add(new Integer(TerminalTokens.TokenNamePLUS));
addRealFragment(combinedBinaryExpression.referencesTable[i].right);
}
this.operatorsList.add(new Integer(TerminalTokens.TokenNamePLUS));
addRealFragment(combinedBinaryExpression.right);
return false;
}
public boolean visit(CastExpression castExpression, BlockScope scope) {
addRealFragment(castExpression);
return false;
}
public boolean visit(CharLiteral charLiteral, BlockScope scope) {
addSmallFragment(charLiteral);
return false;
}
public boolean visit(
ClassLiteralAccess classLiteralAccess,
BlockScope scope) {
addRealFragment(classLiteralAccess);
return false;
}
public boolean visit(
CompoundAssignment compoundAssignment,
BlockScope scope) {
addRealFragment(compoundAssignment);
return false;
}
public boolean visit(
ConditionalExpression conditionalExpression,
BlockScope scope) {
addRealFragment(conditionalExpression);
return false;
}
public boolean visit(DoubleLiteral doubleLiteral, BlockScope scope) {
addSmallFragment(doubleLiteral);
return false;
}
public boolean visit(EqualExpression equalExpression, BlockScope scope) {
addRealFragment(equalExpression);
return false;
}
public boolean visit(
ExtendedStringLiteral extendedStringLiteral,
BlockScope scope) {
addRealFragment(extendedStringLiteral);
return false;
}
public boolean visit(FalseLiteral falseLiteral, BlockScope scope) {
addSmallFragment(falseLiteral);
return false;
}
public boolean visit(FieldReference fieldReference, BlockScope scope) {
addRealFragment(fieldReference);
return false;
}
public boolean visit(FloatLiteral floatLiteral, BlockScope scope) {
addSmallFragment(floatLiteral);
return false;
}
public boolean visit(
InstanceOfExpression instanceOfExpression,
BlockScope scope) {
addRealFragment(instanceOfExpression);
return false;
}
public boolean visit(IntLiteral intLiteral, BlockScope scope) {
addSmallFragment(intLiteral);
return false;
}
public boolean visit(LongLiteral longLiteral, BlockScope scope) {
addSmallFragment(longLiteral);
return false;
}
public boolean visit(MessageSend messageSend, BlockScope scope) {
addRealFragment(messageSend);
return false;
}
public boolean visit(StringLiteralConcatenation stringLiteral, BlockScope scope) {
if (((stringLiteral.bits & ASTNode.ParenthesizedMASK) >> ASTNode.ParenthesizedSHIFT) != 0) {
addRealFragment(stringLiteral);
} else {
for (int i = 0, max = stringLiteral.counter; i < max; i++) {
addRealFragment(stringLiteral.literals[i]);
if (i < max - 1) {
this.operatorsList.add(new Integer(TerminalTokens.TokenNamePLUS));
}
}
}
return false;
}
public boolean visit(NullLiteral nullLiteral, BlockScope scope) {
addRealFragment(nullLiteral);
return false;
}
public boolean visit(OR_OR_Expression or_or_Expression, BlockScope scope) {
if (((or_or_Expression.bits & ASTNode.ParenthesizedMASK) >> ASTNode.ParenthesizedSHIFT) != 0) {
addRealFragment(or_or_Expression);
} else {
or_or_Expression.left.traverse(this, scope);
this.operatorsList.add(new Integer(TerminalTokens.TokenNameOR_OR));
or_or_Expression.right.traverse(this, scope);
}
return false;
}
public boolean visit(
PostfixExpression postfixExpression,
BlockScope scope) {
addRealFragment(postfixExpression);
return false;
}
public boolean visit(PrefixExpression prefixExpression, BlockScope scope) {
addRealFragment(prefixExpression);
return false;
}
public boolean visit(
QualifiedAllocationExpression qualifiedAllocationExpression,
BlockScope scope) {
addRealFragment(qualifiedAllocationExpression);
return false;
}
public boolean visit(
QualifiedNameReference qualifiedNameReference,
BlockScope scope) {
addRealFragment(qualifiedNameReference);
return false;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.internal.compiler.ASTVisitor#visit(org.eclipse.jdt.internal.compiler.ast.QualifiedSuperReference, org.eclipse.jdt.internal.compiler.lookup.BlockScope)
*/
public boolean visit(
QualifiedSuperReference qualifiedSuperReference,
BlockScope scope) {
addRealFragment(qualifiedSuperReference);
return false;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.internal.compiler.ASTVisitor#visit(org.eclipse.jdt.internal.compiler.ast.QualifiedThisReference, org.eclipse.jdt.internal.compiler.lookup.BlockScope)
*/
public boolean visit(
QualifiedThisReference qualifiedThisReference,
BlockScope scope) {
addRealFragment(qualifiedThisReference);
return false;
}
public boolean visit(
SingleNameReference singleNameReference,
BlockScope scope) {
addRealFragment(singleNameReference);
return false;
}
public boolean visit(StringLiteral stringLiteral, BlockScope scope) {
addRealFragment(stringLiteral);
return false;
}
/* (non-Javadoc)
* @see org.eclipse.jdt.internal.compiler.ASTVisitor#visit(org.eclipse.jdt.internal.compiler.ast.SuperReference, org.eclipse.jdt.internal.compiler.lookup.BlockScope)
*/
public boolean visit(SuperReference superReference, BlockScope scope) {
addRealFragment(superReference);
return false;
}
public boolean visit(ThisReference thisReference, BlockScope scope) {
addRealFragment(thisReference);
return false;
}
public boolean visit(TrueLiteral trueLiteral, BlockScope scope) {
addSmallFragment(trueLiteral);
return false;
}
public boolean visit(UnaryExpression unaryExpression, BlockScope scope) {
addRealFragment(unaryExpression);
return false;
}
public int size() {
return this.fragmentsList.size();
}
}