/*******************************************************************************
* Copyright (c) 2006, 2008 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.compiler.ast;
import org.eclipse.jdt.internal.compiler.ASTVisitor;
import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
import org.eclipse.jdt.internal.compiler.flow.FlowContext;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.impl.Constant;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
/**
* CombinedBinaryExpression is an implementation of BinaryExpression that
* specifically attempts to mitigate the issues raised by expressions which
* have a very deep leftmost branch. It does so by maintaining a table of
* direct references to its subexpressions, and implementing non-recursive
* variants of the most significant recursive algorithms of its ancestors.
* The subexpressions table only holds intermediate binary expressions. Its
* role is to provide the reversed navigation through the left relationship
* of BinaryExpression to Expression. To cope with potentially very deep
* left branches, an instance of CombinedBinaryExpression is created once in
* a while, using variable thresholds held by {@link #arityMax}.
* As a specific case, the topmost node of all binary expressions that are
* deeper than one is a CombinedBinaryExpression, but it has no references
* table.<br>
* Notes:
* <ul>
* <li>CombinedBinaryExpression is not meant to behave in other ways than
* BinaryExpression in any observable respect;</li>
* <li>visitors that implement their own traversal upon binary expressions
* should consider taking advantage of combined binary expressions, or
* else face a risk of StackOverflowError upon deep instances;</li>
* <li>callers that need to change the operator should rebuild the expression
* from scratch, or else amend the references table as needed to cope with
* the resulting, separated expressions.</li>
* </ul>
*/
public class CombinedBinaryExpression extends BinaryExpression {
/**
* The number of consecutive binary expressions of this' left branch that
* bear the same operator as this.<br>
* Notes:
* <ul><li>the presence of a CombinedBinaryExpression instance resets
* arity, even when its operator is compatible;</li>
* <li>this property is maintained by the parser.</li>
* </ul>
*/
public int arity;
/**
* The threshold that will trigger the creation of the next full-fledged
* CombinedBinaryExpression. This field is only maintained for the
* topmost binary expression (it is 0 otherwise). It enables a variable
* policy, which scales better with very large expressions.
*/
public int arityMax;
/**
* Upper limit for {@link #arityMax}.
*/
public static final int ARITY_MAX_MAX = 160;
/**
* Default lower limit for {@link #arityMax}.
*/
public static final int ARITY_MAX_MIN = 20;
/**
* Default value for the first term of the series of {@link #arityMax}
* values. Changing this allows for experimentation. Not meant to be
* changed during a parse operation.
*/
public static int defaultArityMaxStartingValue = ARITY_MAX_MIN;
/**
* A table of references to the binary expressions of this' left branch.
* Instances of CombinedBinaryExpression are not repeated here. Instead,
* the left subexpression of referencesTable[0] may be a combined binary
* expression, if appropriate. Null when this only cares about tracking
* the expression's arity.
*/
public BinaryExpression referencesTable[];
/**
* Make a new CombinedBinaryExpression. If arity is strictly greater than one,
* a references table is built and initialized with the reverse relationship of
* the one defined by {@link BinaryExpression#left}. arity and left must be
* compatible with each other (that is, there must be at least arity - 1
* consecutive compatible binary expressions into the leftmost branch of left,
* the topmost of which being left's immediate left expression).
* @param left the left branch expression
* @param right the right branch expression
* @param operator the operator for this binary expression - only PLUS for now
* @param arity the number of binary expressions of a compatible operator that
* already exist into the leftmost branch of left (including left); must
* be strictly greater than 0
*/
public CombinedBinaryExpression(Expression left, Expression right, int operator, int arity) {
super(left, right, operator);
initArity(left, arity);
}
public CombinedBinaryExpression(CombinedBinaryExpression expression) {
super(expression);
initArity(expression.left, expression.arity);
}
public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext,
FlowInfo flowInfo) {
// keep implementation in sync with BinaryExpression#analyseCode
if (this.referencesTable == null) {
return super.analyseCode(currentScope, flowContext, flowInfo);
}
BinaryExpression cursor;
if ((cursor = this.referencesTable[0]).resolvedType.id !=
TypeIds.T_JavaLangString) {
cursor.left.checkNPE(currentScope, flowContext, flowInfo);
}
flowInfo = cursor.left.analyseCode(currentScope, flowContext, flowInfo).
unconditionalInits();
for (int i = 0, end = this.arity; i < end; i ++) {
if ((cursor = this.referencesTable[i]).resolvedType.id !=
TypeIds.T_JavaLangString) {
cursor.right.checkNPE(currentScope, flowContext, flowInfo);
}
flowInfo = cursor.right.
analyseCode(currentScope, flowContext, flowInfo).
unconditionalInits();
}
if (this.resolvedType.id != TypeIds.T_JavaLangString) {
this.right.checkNPE(currentScope, flowContext, flowInfo);
}
return this.right.analyseCode(currentScope, flowContext, flowInfo).
unconditionalInits();
}
public void generateOptimizedStringConcatenation(BlockScope blockScope,
CodeStream codeStream, int typeID) {
// keep implementation in sync with BinaryExpression and Expression
// #generateOptimizedStringConcatenation
if (this.referencesTable == null) {
super.generateOptimizedStringConcatenation(blockScope, codeStream,
typeID);
} else {
if ((((this.bits & ASTNode.OperatorMASK) >> ASTNode.OperatorSHIFT) ==
OperatorIds.PLUS)
&& ((this.bits & ASTNode.ReturnTypeIDMASK) == TypeIds.T_JavaLangString)) {
if (this.constant != Constant.NotAConstant) {
codeStream.generateConstant(this.constant, this.implicitConversion);
codeStream.invokeStringConcatenationAppendForType(
this.implicitConversion & TypeIds.COMPILE_TYPE_MASK);
} else {
BinaryExpression cursor = this.referencesTable[0];
int restart = 0;
// int cursorTypeID;
int pc = codeStream.position;
for (restart = this.arity - 1; restart >= 0; restart--) {
if ((cursor = this.referencesTable[restart]).constant !=
Constant.NotAConstant) {
codeStream.generateConstant(cursor.constant,
cursor.implicitConversion);
codeStream.invokeStringConcatenationAppendForType(
cursor.implicitConversion & TypeIds.COMPILE_TYPE_MASK);
break;
}
// never happens for now - may reconsider if we decide to
// cover more than string concatenation
// if (!((((cursor = this.referencesTable[restart]).bits &
// ASTNode.OperatorMASK) >> ASTNode.OperatorSHIFT) ==
// OperatorIds.PLUS) &
// ((cursorTypeID = cursor.bits & ASTNode.ReturnTypeIDMASK) ==
// TypeIds.T_JavaLangString)) {
// if (cursorTypeID == T_JavaLangString &&
// cursor.constant != Constant.NotAConstant &&
// cursor.constant.stringValue().length() == 0) {
// break; // optimize str + ""
// }
// cursor.generateCode(blockScope, codeStream, true);
// codeStream.invokeStringConcatenationAppendForType(
// cursorTypeID);
// break;
// }
}
restart++;
if (restart == 0) { // reached the leftmost expression
cursor.left.generateOptimizedStringConcatenation(
blockScope,
codeStream,
cursor.left.implicitConversion & TypeIds.COMPILE_TYPE_MASK);
}
int pcAux;
for (int i = restart; i < this.arity; i++) {
codeStream.recordPositionsFrom(pc,
(cursor = this.referencesTable[i]).left.sourceStart);
pcAux = codeStream.position;
cursor.right.generateOptimizedStringConcatenation(blockScope,
codeStream, cursor.right.implicitConversion &
TypeIds.COMPILE_TYPE_MASK);
codeStream.recordPositionsFrom(pcAux, cursor.right.sourceStart);
}
codeStream.recordPositionsFrom(pc, this.left.sourceStart);
pc = codeStream.position;
this.right.generateOptimizedStringConcatenation(
blockScope,
codeStream,
this.right.implicitConversion & TypeIds.COMPILE_TYPE_MASK);
codeStream.recordPositionsFrom(pc, this.right.sourceStart);
}
} else {
super.generateOptimizedStringConcatenation(blockScope, codeStream,
typeID);
}
}
}
public void generateOptimizedStringConcatenationCreation(BlockScope blockScope,
CodeStream codeStream, int typeID) {
// keep implementation in sync with BinaryExpression
// #generateOptimizedStringConcatenationCreation
if (this.referencesTable == null) {
super.generateOptimizedStringConcatenationCreation(blockScope,
codeStream, typeID);
} else {
if ((((this.bits & ASTNode.OperatorMASK) >> ASTNode.OperatorSHIFT) ==
OperatorIds.PLUS) &&
((this.bits & ASTNode.ReturnTypeIDMASK) ==
TypeIds.T_JavaLangString) &&
this.constant == Constant.NotAConstant) {
int pc = codeStream.position;
BinaryExpression cursor = this.referencesTable[this.arity - 1];
// silence warnings
int restart = 0;
for (restart = this.arity - 1; restart >= 0; restart--) {
if (((((cursor = this.referencesTable[restart]).bits &
ASTNode.OperatorMASK) >> ASTNode.OperatorSHIFT) ==
OperatorIds.PLUS) &&
((cursor.bits & ASTNode.ReturnTypeIDMASK) ==
TypeIds.T_JavaLangString)) {
if (cursor.constant != Constant.NotAConstant) {
codeStream.newStringContatenation(); // new: java.lang.StringBuffer
codeStream.dup();
codeStream.ldc(cursor.constant.stringValue());
codeStream.invokeStringConcatenationStringConstructor();
// invokespecial: java.lang.StringBuffer.<init>(Ljava.lang.String;)V
break;
}
} else {
cursor.generateOptimizedStringConcatenationCreation(blockScope,
codeStream, cursor.implicitConversion &
TypeIds.COMPILE_TYPE_MASK);
break;
}
}
restart++;
if (restart == 0) { // reached the leftmost expression
cursor.left.generateOptimizedStringConcatenationCreation(
blockScope,
codeStream,
cursor.left.implicitConversion & TypeIds.COMPILE_TYPE_MASK);
}
int pcAux;
for (int i = restart; i < this.arity; i++) {
codeStream.recordPositionsFrom(pc,
(cursor = this.referencesTable[i]).left.sourceStart);
pcAux = codeStream.position;
cursor.right.generateOptimizedStringConcatenation(blockScope,
codeStream, cursor.right.implicitConversion &
TypeIds.COMPILE_TYPE_MASK);
codeStream.recordPositionsFrom(pcAux, cursor.right.sourceStart);
}
codeStream.recordPositionsFrom(pc, this.left.sourceStart);
pc = codeStream.position;
this.right.generateOptimizedStringConcatenation(
blockScope,
codeStream,
this.right.implicitConversion & TypeIds.COMPILE_TYPE_MASK);
codeStream.recordPositionsFrom(pc, this.right.sourceStart);
} else {
super.generateOptimizedStringConcatenationCreation(blockScope,
codeStream, typeID);
}
}
}
private void initArity(Expression expression, int value) {
this.arity = value;
if (value > 1) {
this.referencesTable = new BinaryExpression[value];
this.referencesTable[value - 1] = (BinaryExpression) expression;
for (int i = value - 1; i > 0; i--) {
this.referencesTable[i - 1] =
(BinaryExpression) this.referencesTable[i].left;
}
} else {
this.arityMax = defaultArityMaxStartingValue;
}
}
public StringBuffer printExpressionNoParenthesis(int indent,
StringBuffer output) {
// keep implementation in sync with
// BinaryExpression#printExpressionNoParenthesis and
// OperatorExpression#printExpression
if (this.referencesTable == null) {
return super.printExpressionNoParenthesis(indent, output);
}
String operatorString = operatorToString();
for (int i = this.arity - 1; i >= 0; i--) {
output.append('(');
}
output = this.referencesTable[0].left.
printExpression(indent, output);
for (int i = 0, end = this.arity;
i < end; i++) {
output.append(' ').append(operatorString).append(' ');
output = this.referencesTable[i].right.
printExpression(0, output);
output.append(')');
}
output.append(' ').append(operatorString).append(' ');
return this.right.printExpression(0, output);
}
public TypeBinding resolveType(BlockScope scope) {
// keep implementation in sync with BinaryExpression#resolveType
if (this.referencesTable == null) {
return super.resolveType(scope);
}
BinaryExpression cursor;
if ((cursor = this.referencesTable[0]).left instanceof CastExpression) {
cursor.left.bits |= ASTNode.DisableUnnecessaryCastCheck;
// will check later on
}
cursor.left.resolveType(scope);
for (int i = 0, end = this.arity; i < end; i ++) {
this.referencesTable[i].nonRecursiveResolveTypeUpwards(scope);
}
nonRecursiveResolveTypeUpwards(scope);
return this.resolvedType;
}
public void traverse(ASTVisitor visitor, BlockScope scope) {
if (this.referencesTable == null) {
super.traverse(visitor, scope);
} else {
if (visitor.visit(this, scope)) {
int restart;
for (restart = this.arity - 1;
restart >= 0;
restart--) {
if (!visitor.visit(
this.referencesTable[restart], scope)) {
visitor.endVisit(
this.referencesTable[restart], scope);
break;
}
}
restart++;
// restart now points to the deepest BE for which
// visit returned true, if any
if (restart == 0) {
this.referencesTable[0].left.traverse(visitor, scope);
}
for (int i = restart, end = this.arity;
i < end; i++) {
this.referencesTable[i].right.traverse(visitor, scope);
visitor.endVisit(this.referencesTable[i], scope);
}
this.right.traverse(visitor, scope);
}
visitor.endVisit(this, scope);
}
}
/**
* Change {@link #arityMax} if and as needed. The current policy is to double
* arityMax each time this method is called, until it reaches
* {@link #ARITY_MAX_MAX}. Other policies may consider incrementing it less
* agressively. Call only after an appropriate value has been assigned to
* {@link #left}.
*/
// more sophisticate increment policies would leverage the leftmost expression
// to hold an indication of the number of uses of a given arityMax in a row
public void tuneArityMax() {
if (this.arityMax < ARITY_MAX_MAX) {
this.arityMax *= 2;
}
}
}