Attachment #124424 for bug #261510




import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;

public class CharLiteral extends NumberLiteral {
	
	char value;
	
public CharLiteral(char[] token, int s, int e) {
	super(token, s, e);
	computeValue();
}

public void computeConstant() {
	//The source is a  char[3] first and last char are '
	//This is true for both regular char AND unicode char
	//BUT not for escape char like '\b' which are char[4]....

	this.constant = CharConstant.fromValue(this.value);
}

private void computeValue() {
	//The source is a  char[3] first and last char are '
	//This is true for both regular char AND unicode char
	//BUT not for escape char like '\b' which are char[4]....

	if ((this.value = this.source[1]) != '\\')
		return;
	char digit;

			break;
	}
}

/**
 * CharLiteral code generation
 *

	}
	codeStream.recordPositionsFrom(pc, this.sourceStart);
}

public TypeBinding literalType(BlockScope scope) {
	return TypeBinding.CHAR;
}

public void traverse(ASTVisitor visitor, BlockScope blockScope) {
	visitor.visit(this, blockScope);
	visitor.endVisit(this, blockScope);

Lines 18-24 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/TrueLiteral.java (+2 lines)
18	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;	18	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
19		19
20	public class TrueLiteral extends MagicLiteral {	20	public class TrueLiteral extends MagicLiteral {
		21
21	static final char[] source = {'t' , 'r' , 'u' , 'e'};	22	static final char[] source = {'t' , 'r' , 'u' , 'e'};
		23
22	public TrueLiteral(int s , int e) {	24	public TrueLiteral(int s , int e) {
23	super(s,e);	25	super(s,e);
24	}	26	}

Lines 18-24 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/FalseLiteral.java (+2 lines)
18	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;	18	import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
19		19
20	public class FalseLiteral extends MagicLiteral {	20	public class FalseLiteral extends MagicLiteral {
		21
21	static final char[] source = {'f', 'a', 'l', 's', 'e'};	22	static final char[] source = {'f', 'a', 'l', 's', 'e'};
		23
22	public FalseLiteral(int s , int e) {	24	public FalseLiteral(int s , int e) {
23	super(s,e);	25	super(s,e);
24	}	26	}




import org.eclipse.jdt.internal.compiler.util.FloatUtil;

public class FloatLiteral extends NumberLiteral {
	
	float value;
	
public FloatLiteral(char[] token, int s, int e) {
	super(token, s, e);
}

public void computeConstant() {
	Float computedValue;
	try {
		computedValue = Float.valueOf(String.valueOf(this.source));
	} catch (NumberFormatException e) {
		// hex floating point literal
		// being rejected by 1.4 libraries where Float.valueOf(...) doesn't handle hex decimal floats
		try {
			float v = FloatUtil.valueOfHexFloatLiteral(this.source);
			if (v == Float.POSITIVE_INFINITY) {
				// error: the number is too large to represent
				return;
			try {
				float v = FloatUtil.valueOfHexFloatLiteral(this.source);
				if (v == Float.POSITIVE_INFINITY) {
					// error: the number is too large to represent
					return;
				}
				if (Float.isNaN(v)) {
					// error: the number is too small to represent
					return;
				}
				this.value = v;
				this.constant = FloatConstant.fromValue(v);
			} catch (NumberFormatException e1) {
				// if the computation of the constant fails
			}
			if (Float.isNaN(v)) {
				// error: the number is too small to represent
				return;
		final float floatValue = computedValue.floatValue();
		if (floatValue > Float.MAX_VALUE) {
			// error: the number is too large to represent
			return;
		}
		if (floatValue < Float.MIN_VALUE) {
			// see 1F6IGUU
			// a true 0 only has '0' and '.' in mantissa
			// 1.0e-5000d is non-zero, but underflows to 0
			boolean isHexaDecimal = false;
			label : for (int i = 0; i < this.source.length; i++) { //it is welled formated so just test against '0' and potential . D d
				switch (this.source[i]) {
					case '0' :
					case '.' :
						break;
					case 'x' :
					case 'X' :
						isHexaDecimal = true;
						break;
					case 'e' :
					case 'E' :
					case 'f' :
					case 'F' :
					case 'd' :
					case 'D' :
						if (isHexaDecimal) {
							return;
						}
						// starting the exponent - mantissa is all zero
						// no exponent - mantissa is all zero
						break label;
					case 'p' :
					case 'P' :
						break label;
					default :
						// error: the number is too small to represent
						return;
				}
			}
			this.value = v;
			this.constant = FloatConstant.fromValue(v);
		} catch (NumberFormatException e1) {
			// if the computation of the constant fails
		}
		return;
		this.constant = FloatConstant.fromValue(this.value);
	}
	final float floatValue = computedValue.floatValue();
	if (floatValue > Float.MAX_VALUE) {
		// error: the number is too large to represent
		return;
	 * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
	 * @param valueRequired boolean
	 */
	public void generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired) {
		int pc = codeStream.position;
		if (valueRequired) {
			codeStream.generateConstant(this.constant, this.implicitConversion);
		}
		codeStream.recordPositionsFrom(pc, this.sourceStart);
	}
	if (floatValue < Float.MIN_VALUE) {
		// see 1F6IGUU
		// a true 0 only has '0' and '.' in mantissa
		// 1.0e-5000d is non-zero, but underflows to 0
		boolean isHexaDecimal = false;
		label : for (int i = 0; i < this.source.length; i++) { //it is welled formated so just test against '0' and potential . D d
			switch (this.source[i]) {
				case '0' :
				case '.' :
					break;
				case 'x' :
				case 'X' :
					isHexaDecimal = true;
					break;
				case 'e' :
				case 'E' :
				case 'f' :
				case 'F' :
				case 'd' :
				case 'D' :
					if (isHexaDecimal) {
						return;
					}
					// starting the exponent - mantissa is all zero
					// no exponent - mantissa is all zero
					break label;
				case 'p' :
				case 'P' :
					break label;
				default :
					// error: the number is too small to represent
					return;
			}
		}
	}
	this.value = floatValue;
	this.constant = FloatConstant.fromValue(this.value);
}

/**
 * Code generation for float literal
 *
 * @param currentScope org.eclipse.jdt.internal.compiler.lookup.BlockScope
 * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
 * @param valueRequired boolean
 */
public void generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired) {
	int pc = codeStream.position;
	if (valueRequired) {
		codeStream.generateConstant(this.constant, this.implicitConversion);
	}
	codeStream.recordPositionsFrom(pc, this.sourceStart);
}

public TypeBinding literalType(BlockScope scope) {
	return TypeBinding.FLOAT;
}

public void traverse(ASTVisitor visitor, BlockScope scope) {
	visitor.visit(this, scope);
	visitor.endVisit(this, scope);
}
}




import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;

public class LongLiteral extends NumberLiteral {
	static final Constant FORMAT_ERROR = DoubleConstant.fromValue(1.0/0.0); // NaN;

public LongLiteral(char[] token, int s,int e) {
	super(token, s,e);
}

public void computeConstant() {
	//the overflow (when radix=10) is tested using the fact that
	//the value should always grow during its computation
	int length = this.source.length - 1; //minus one because the last char is 'l' or 'L'

	long computedValue ;
	if (this.source[0] == '0') {
		if (length == 1) {

			if ( j == length) {
				//watch for 0000000000000L
				this.constant = LongConstant.fromValue(0L);
				return;
			}
		}

		int digitValue ;
		if ((digitValue = ScannerHelper.digit(this.source[j++],radix)) < 0 ) {
			return; /*constant stays null*/
		}
		if (digitValue >= 8)
			nbDigit = 4;

		computedValue = digitValue ;
		while (j<length) {
			if ((digitValue = ScannerHelper.digit(this.source[j++],radix)) < 0) {
				return; /*constant stays null*/
			}
			if ((nbDigit += shift) > 64)
				return; /*constant stays null*/
			computedValue = (computedValue<<shift) | digitValue ;
		}
	} else {

			if ((digitValue = ScannerHelper.digit(this.source[i], 10)) < 0 ) return /*constant stays null*/;
			previous = computedValue;
			if (computedValue > limit)
				return; /*constant stays null*/
			computedValue *= 10;
			if ((computedValue + digitValue) > Long.MAX_VALUE)
				return; /*constant stays null*/
			computedValue += digitValue;
			if (previous > computedValue)
				return; /*constant stays null*/
		}
	}
	this.constant = LongConstant.fromValue(computedValue);
}

/**
 * Code generation for long literal
 *

	}
	codeStream.recordPositionsFrom(pc, this.sourceStart);
}

public TypeBinding literalType(BlockScope scope) {
	return TypeBinding.LONG;
}

public final boolean mayRepresentMIN_VALUE(){
	//a special autorized int literral is 9223372036854775808L
	//which is ONE over the limit. This special case
	//only is used in combinaison with - to denote
	//the minimal value of int -9223372036854775808L

	return ((this.source.length == 20) &&
			(this.source[0] == '9') &&
			(this.source[1] == '2') &&

			(this.source[18] == '8') &&
			(((this.bits & ASTNode.ParenthesizedMASK) >> ASTNode.ParenthesizedSHIFT) == 0));
}

	// the format may be incorrect while the scanner could detect
	// such error only on painfull tests...easier and faster here

	TypeBinding tb = super.resolveType(scope);
	if (this.constant == FORMAT_ERROR) {
		this.constant = Constant.NotAConstant;
		scope.problemReporter().constantOutOfFormat(this);
		this.resolvedType = null;
		return null;
	}
	return tb;
}
public void traverse(ASTVisitor visitor, BlockScope scope) {
	visitor.visit(this, scope);
	visitor.endVisit(this, scope);

Lines 206-212 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/UnaryExpression.java (-1 lines)
206	}	206	}
207		207
208	public TypeBinding resolveType(BlockScope scope) {	208	public TypeBinding resolveType(BlockScope scope) {
209
210	boolean expressionIsCast;	209	boolean expressionIsCast;
211	if ((expressionIsCast = this.expression instanceof CastExpression) == true) this.expression.bits \|= DisableUnnecessaryCastCheck; // will check later on	210	if ((expressionIsCast = this.expression instanceof CastExpression) == true) this.expression.bits \|= DisableUnnecessaryCastCheck; // will check later on
212	TypeBinding expressionType = this.expression.resolveType(scope);	211	TypeBinding expressionType = this.expression.resolveType(scope);




public class LongLiteralMinValue extends LongLiteral {

	final static char[] CharValue = new char[]{'-', '9','2','2','3','3','7','2','0','3','6','8','5','4','7','7','5','8','0','8','L'};
	final static Constant MIN_VALUE = LongConstant.fromValue(Long.MIN_VALUE) ;

public LongLiteralMinValue(){
	super(CharValue,0,0);
	this.constant = LongConstant.fromValue(Long.MIN_VALUE);
}
public void computeConstant() {

	/*precomputed at creation time*/}
}




import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;

public class IntLiteral extends NumberLiteral {
	
	public int value;

	public static final IntLiteral One = new IntLiteral(new char[]{'1'},0,0,1);//used for ++ and --
	

	static final Constant FORMAT_ERROR = DoubleConstant.fromValue(1.0/0.0); // NaN;
public IntLiteral(char[] token, int s, int e) {
	super(token, s,e);
}

public IntLiteral(char[] token, int s,int e, int value) {
	this(token, s,e);
	this.value = value;
}

public IntLiteral(int intValue) {
	//special optimized constructor : the cst is the argument

	//value that should not be used
	//	tokens = null ;
	//	sourceStart = 0;

	super(null,0,0);
	this.constant = IntConstant.fromValue(intValue);
	this.value = intValue;

}

public void computeConstant() {
	//a special constant is use for the potential Integer.MAX_VALUE+1
	//which is legal if used with a - as prefix....cool....
	//notice that Integer.MIN_VALUE  == -2147483648

	long MAX = Integer.MAX_VALUE;
	if (this == One) {	
		this.constant = IntConstant.fromValue(1); 
		return ;
	}
	int length = this.source.length;
	long computedValue = 0L;
	if (this.source[0] == '0') {	
		MAX = 0xFFFFFFFFL ; //a long in order to be positive !
		if (length == 1) {
			this.constant = IntConstant.fromValue(0); return ;
		}
		final int shift,radix;
		int j ;
		if ((this.source[1] == 'x') || (this.source[1] == 'X')) {	
			shift = 4 ; j = 2; radix = 16;
		} else {	
			shift = 3 ; j = 1; radix = 8;
		}
		while (this.source[j]=='0')	 {	
			j++; //jump over redondant zero
			if (j == length) {
				//watch for 000000000000000000
				this.constant = IntConstant.fromValue(this.value = (int)computedValue);
				return;
			}
		}
		while (j<length) {	
			int digitValue ;
			if ((digitValue = ScannerHelper.digit(this.source[j++],radix))	< 0 ) {
				return; /*constant stays null*/
			}
			computedValue = (computedValue<<shift) | digitValue ;
			if (computedValue > MAX) return; /*constant stays null*/
		}
	} else {	
		//-----------regular case : radix = 10-----------
		for (int i = 0 ; i < length;i++) {	
			int digitValue ;
			if ((digitValue = ScannerHelper.digit(this.source[i],10))	< 0 ) {
				return; /*constant stays null*/
			}
			computedValue = 10*computedValue + digitValue;
			if (computedValue > MAX) return /*constant stays null*/ ;
		}
	}
	this.constant = IntConstant.fromValue(this.value = (int)computedValue);

}

/**
 * Code generation for int literal
 *

	}
	codeStream.recordPositionsFrom(pc, this.sourceStart);
}

public TypeBinding literalType(BlockScope scope) {
	return TypeBinding.INT;
}

public final boolean mayRepresentMIN_VALUE(){
	//a special autorized int literral is 2147483648
	//which is ONE over the limit. This special case
	//only is used in combinaison with - to denote
	//the minimal value of int -2147483648

	return ((this.source.length == 10) &&
			(this.source[0] == '2') &&
			(this.source[1] == '1') &&

			(this.source[9] == '8') &&
			(((this.bits & ASTNode.ParenthesizedMASK) >> ASTNode.ParenthesizedSHIFT) == 0));
}
public TypeBinding resolveType(BlockScope scope) {
	// the format may be incorrect while the scanner could detect
	// such an error only on painfull tests...easier and faster here

	TypeBinding tb = super.resolveType(scope);
	if (this.constant == FORMAT_ERROR) {
		this.constant = Constant.NotAConstant;
		scope.problemReporter().constantOutOfFormat(this);
		this.resolvedType = null;
		return null;
	}
	return tb;
}
public StringBuffer printExpression(int indent, StringBuffer output){

public StringBuffer printExpression(int indent, StringBuffer output){
	if (this.source == null) {
	/* special optimized IntLiteral that are created by the compiler */
		return output.append(String.valueOf(this.value));




import org.eclipse.jdt.internal.compiler.util.FloatUtil;

public class DoubleLiteral extends NumberLiteral {
	
	double value;
	
public DoubleLiteral(char[] token, int s, int e) {
	super(token, s, e);
}

public void computeConstant() {
	Double computedValue;
	try {
		computedValue = Double.valueOf(String.valueOf(this.source));
	} catch (NumberFormatException e) {
		// hex floating point literal
		// being rejected by 1.4 libraries where Double.valueOf(...) doesn't handle hex decimal floats
		try {
			double v = FloatUtil.valueOfHexDoubleLiteral(this.source);
			if (v == Double.POSITIVE_INFINITY) {
				// error: the number is too large to represent
				return;
			try {
				double v = FloatUtil.valueOfHexDoubleLiteral(this.source);
				if (v == Double.POSITIVE_INFINITY) {
					// error: the number is too large to represent
					return;
				}
				if (Double.isNaN(v)) {
					// error: the number is too small to represent
					return;
				}
				this.value = v;
				this.constant = DoubleConstant.fromValue(v);
			} catch (NumberFormatException e1) {
				// if the computation of the constant fails
			}
			if (Double.isNaN(v)) {
				// error: the number is too small to represent
				return;
		final double doubleValue = computedValue.doubleValue();
		if (doubleValue > Double.MAX_VALUE) {
			// error: the number is too large to represent
			return;
		}
		if (doubleValue < Double.MIN_VALUE) {
			// see 1F6IGUU
			// a true 0 only has '0' and '.' in mantissa
			// 1.0e-5000d is non-zero, but underflows to 0
			boolean isHexaDecimal = false;
			label : for (int i = 0; i < this.source.length; i++) { //it is welled formated so just test against '0' and potential . D d
				switch (this.source[i]) {
					case '0' :
					case '.' :
						break;
					case 'x' :
					case 'X' :
						isHexaDecimal = true;
						break;
					case 'e' :
					case 'E' :
					case 'f' :
					case 'F' :
					case 'd' :
					case 'D' :
						if (isHexaDecimal) {
							return;
						}
						// starting the exponent - mantissa is all zero
						// no exponent - mantissa is all zero
						break label;
					case 'p' :
					case 'P' :
						break label;
					default :
						// error: the number is too small to represent
						return;
				}
			}
			this.value = v;
			this.constant = DoubleConstant.fromValue(v);
		} catch (NumberFormatException e1) {
			// if the computation of the constant fails
		}
		return;
		this.constant = DoubleConstant.fromValue(this.value);
	}
	final double doubleValue = computedValue.doubleValue();
	if (doubleValue > Double.MAX_VALUE) {
		// error: the number is too large to represent
		return;
	 * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
	 * @param valueRequired boolean
	 */
	public void generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired) {
		int pc = codeStream.position;
		if (valueRequired) {
			codeStream.generateConstant(this.constant, this.implicitConversion);
		}
		codeStream.recordPositionsFrom(pc, this.sourceStart);
	}
	if (doubleValue < Double.MIN_VALUE) {
		// see 1F6IGUU
		// a true 0 only has '0' and '.' in mantissa
		// 1.0e-5000d is non-zero, but underflows to 0
		boolean isHexaDecimal = false;
		label : for (int i = 0; i < this.source.length; i++) { //it is welled formated so just test against '0' and potential . D d
			switch (this.source[i]) {
				case '0' :
				case '.' :
					break;
				case 'x' :
				case 'X' :
					isHexaDecimal = true;
					break;
				case 'e' :
				case 'E' :
				case 'f' :
				case 'F' :
				case 'd' :
				case 'D' :
					if (isHexaDecimal) {
						return;
					}
					// starting the exponent - mantissa is all zero
					// no exponent - mantissa is all zero
					break label;
				case 'p' :
				case 'P' :
					break label;
				default :
					// error: the number is too small to represent
					return;
			}
		}
	}
	this.value = doubleValue;
	this.constant = DoubleConstant.fromValue(this.value);
}

/**
 * Code generation for the double literak
 *
 * @param currentScope org.eclipse.jdt.internal.compiler.lookup.BlockScope
 * @param codeStream org.eclipse.jdt.internal.compiler.codegen.CodeStream
 * @param valueRequired boolean
 */
public void generateCode(BlockScope currentScope, CodeStream codeStream, boolean valueRequired) {
	int pc = codeStream.position;
	if (valueRequired) {
		codeStream.generateConstant(this.constant, this.implicitConversion);
	}
	codeStream.recordPositionsFrom(pc, this.sourceStart);
}

public TypeBinding literalType(BlockScope scope) {
	return TypeBinding.DOUBLE;
}

public void traverse(ASTVisitor visitor, BlockScope scope) {
	visitor.visit(this, scope);
	visitor.endVisit(this, scope);
}
}




public class IntLiteralMinValue extends IntLiteral {

	final static char[] CharValue = new char[]{'-','2','1','4','7','4','8','3','6','4','8'};
	final static Constant MIN_VALUE = IntConstant.fromValue(Integer.MIN_VALUE) ;

public IntLiteralMinValue() {
	super(CharValue,0,0,Integer.MIN_VALUE);
	this.constant = IntConstant.fromValue(Integer.MIN_VALUE);
}
public void computeConstant(){

public void computeConstant(){
	/*precomputed at creation time*/ }
}




	char[] source;

	public NumberLiteral(char[] token, int s, int e) {

		this(s,e) ;
		this.source = token ;
	}

	}

	public boolean isValidJavaStatement(){

		return false ;
	}

	public char[] source(){

		return this.source;
	}
}




 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.impl;

/*
 * Implementors are valid compilation contexts from which we can
 * escape in case of error:

import org.eclipse.jdt.internal.compiler.CompilationResult;

public interface ReferenceContext {

	void abort(int abortLevel, CategorizedProblem problem);

	CompilationResult compilationResult();

	boolean hasErrors();

	void tagAsHavingErrors();
}




package org.eclipse.jdt.internal.compiler.impl;

public class ShortConstant extends Constant {
	
	private short value;

	public static Constant fromValue(short value) {
		return new ShortConstant(value);
	}
private ShortConstant(short value) {
	this.value = value;
}
public byte byteValue() {
	return (byte) this.value;
}
public char charValue() {
	return (char) this.value;
}
public double doubleValue() {
	return this.value; // implicit cast to return type
}
public float floatValue() {
	return this.value; // implicit cast to return type
}
public int intValue() {
	return this.value; // implicit cast to return type
}
public long longValue() {
	return this.value; // implicit cast to return type
}
public short shortValue() {
	return this.value;
}
public String stringValue() {
	//spec 15.17.11
	return String.valueOf(this.value);
}
public String toString(){

	private ShortConstant(short value) {
		this.value = value;
	}

	public byte byteValue() {
		return (byte) this.value;
	}

	public char charValue() {
		return (char) this.value;
	}

	public double doubleValue() {
		return this.value; // implicit cast to return type
	}

	public float floatValue() {
		return this.value; // implicit cast to return type
	}

	public int intValue() {
		return this.value; // implicit cast to return type
	}

	public long longValue() {
		return this.value; // implicit cast to return type
	}

	public short shortValue() {
		return this.value;
	}

	public String stringValue() {
		// spec 15.17.11
		return String.valueOf(this.value);
	}

	public String toString() {

		return "(short)" + this.value; //$NON-NLS-1$
	}

	public int typeID() {
		return T_short;
	}
}




package org.eclipse.jdt.internal.compiler.impl;

public class LongConstant extends Constant {
private static final LongConstant ZERO = new LongConstant(0L);

		private static final LongConstant ZERO = new LongConstant(0L);
		private static final LongConstant MIN_VALUE = new LongConstant(Long.MIN_VALUE);
		
		private long value;

public static Constant fromValue(long value) {
	if (value == 0L) {
		return ZERO;
	} else if (value == Long.MIN_VALUE) {
		return MIN_VALUE;
	}
	return new LongConstant(value);
}

private LongConstant(long value) {
	this.value = value;
}

public byte byteValue() {
	return (byte) this.value;
}

public char charValue() {
	return (char) this.value;
}

public double doubleValue() {
	return this.value; // implicit cast to return type
}

public float floatValue() {
	return this.value; // implicit cast to return type
}

public int intValue() {
	return (int) this.value;
}

public long longValue() {
	return this.value;
}

public short shortValue() {
	return (short) this.value;
}

public String stringValue() {
	//spec 15.17.11
	return String.valueOf(this.value);
}

public String toString(){

	return "(long)" + this.value ; //$NON-NLS-1$
}

public int typeID() {
	return T_long;
}





public class BooleanConstant extends Constant {

	private boolean value;

	private static final BooleanConstant TRUE = new BooleanConstant(true);
	private static final BooleanConstant FALSE = new BooleanConstant(false);

	public static BooleanConstant fromValue(boolean value) {
		return value ? BooleanConstant.TRUE : BooleanConstant.FALSE;
	}

	private BooleanConstant(boolean value) {
		this.value = value;
	}

	public boolean booleanValue() {
		return this.value;
	}

	public String stringValue() {
		// spec 15.17.11
		return String.valueOf(this.value);
	}

	public String toString() {
		return "(boolean)" + this.value; //$NON-NLS-1$
	}

	public int typeID() {
		return T_boolean;
	}
}




package org.eclipse.jdt.internal.compiler.impl;

public class StringConstant extends Constant {
private String value;

	private String value;

	public static Constant fromValue(String value) {
		return new StringConstant(value);
	}

	private StringConstant(String value) {
		this.value = value;
	}

	public String stringValue() {
		// spec 15.17.11

		// the next line do not go into the toString() send....!
		return this.value;
		/*
		 * String s = value.toString() ; if (s == null) return "null"; else return s;
		 */
	}

	public String toString() {
		return "(String)\"" + this.value + "\""; //$NON-NLS-2$ //$NON-NLS-1$
	}

	public int typeID() {
		return T_JavaLangString;
	}
	return "(String)\"" + this.value +"\""; } //$NON-NLS-2$ //$NON-NLS-1$
public int typeID() {
	return T_JavaLangString;
}
}




public abstract class Constant implements TypeIds, OperatorIds {

	public static final Constant NotAConstant = DoubleConstant.fromValue(Double.NaN);
	
	public boolean booleanValue() {

		throw new ShouldNotImplement(Messages.bind(Messages.constant_cannotCastedInto, new String[] { typeName(), "boolean" })); //$NON-NLS-1$
	}

	public byte byteValue() {

		throw new ShouldNotImplement(Messages.bind(Messages.constant_cannotCastedInto, new String[] { typeName(), "byte" })); //$NON-NLS-1$
	}


		    case (T_int<<4)+T_int  		 	 : return this;

		}

		return NotAConstant;
	}

	public char charValue() {

		throw new ShouldNotImplement(Messages.bind(Messages.constant_cannotCastedInto, new String[] { typeName(), "char" })); //$NON-NLS-1$
	}

	public static final Constant computeConstantOperation(Constant cst, int id, int operator) {

		switch (operator) {
			case NOT	:
							return BooleanConstant.fromValue(!cst.booleanValue());

	}

	public static final Constant computeConstantOperation(Constant left, int leftId, int operator, Constant right, int rightId) {

		switch (operator) {
			case AND		: return computeConstantOperationAND		(left,leftId,right,rightId);
			case AND_AND	: return computeConstantOperationAND_AND	(left,leftId,right,rightId);

			case RIGHT_SHIFT: return computeConstantOperationRIGHT_SHIFT(left,leftId,right,rightId);
			case UNSIGNED_RIGHT_SHIFT: return computeConstantOperationUNSIGNED_RIGHT_SHIFT(left,leftId,right,rightId);
			case XOR		: return computeConstantOperationXOR		(left,leftId,right,rightId);

			default : return NotAConstant;
		}
	}

	public static final Constant computeConstantOperationAND(Constant left, int leftId, Constant right, int rightId) {

		switch (leftId){
			case T_boolean :		return BooleanConstant.fromValue(left.booleanValue() & right.booleanValue());
			case T_char :

					case T_int:		return IntConstant.fromValue(left.charValue() & right.intValue());
					case T_long:	return LongConstant.fromValue(left.charValue() & right.longValue());
				}
				break;
			case T_byte :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.byteValue() & right.charValue());

					case T_int:		return IntConstant.fromValue(left.byteValue() & right.intValue());
					case T_long:	return LongConstant.fromValue(left.byteValue() & right.longValue());
				}
				break;
			case T_short :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.shortValue() & right.charValue());

					case T_int:		return IntConstant.fromValue(left.shortValue() & right.intValue());
					case T_long:	return LongConstant.fromValue(left.shortValue() & right.longValue());
				}
				break;
			case T_int :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.intValue() & right.charValue());

					case T_int:		return IntConstant.fromValue(left.intValue() & right.intValue());
					case T_long:	return LongConstant.fromValue(left.intValue() & right.longValue());
				}
				break;
			case T_long :
				switch (rightId){
					case T_char :	return LongConstant.fromValue(left.longValue() & right.charValue());

					case T_int:		return LongConstant.fromValue(left.longValue() & right.intValue());
					case T_long:	return LongConstant.fromValue(left.longValue() & right.longValue());
				}
		}

		return NotAConstant;
	}

	public static final Constant computeConstantOperationAND_AND(Constant left, int leftId, Constant right, int rightId) {

		return BooleanConstant.fromValue(left.booleanValue() && right.booleanValue());
	}

	public static final Constant computeConstantOperationDIVIDE(Constant left, int leftId, Constant right, int rightId) {
		// division by zero must be handled outside this method (error reporting)

		switch (leftId){
			case T_char :
				switch (rightId){

					case T_int:		return IntConstant.fromValue(left.charValue() / right.intValue());
					case T_long:	return LongConstant.fromValue(left.charValue() / right.longValue());
				}
				break;
			case T_float :
				switch (rightId){
					case T_char :	return FloatConstant.fromValue(left.floatValue() / right.charValue());

					case T_int:		return FloatConstant.fromValue(left.floatValue() / right.intValue());
					case T_long:	return FloatConstant.fromValue(left.floatValue() / right.longValue());
				}
				break;
			case T_double :
				switch (rightId){
					case T_char :	return DoubleConstant.fromValue(left.doubleValue() / right.charValue());

					case T_int:		return DoubleConstant.fromValue(left.doubleValue() / right.intValue());
					case T_long:	return DoubleConstant.fromValue(left.doubleValue() / right.longValue());
				}
				break;
			case T_byte :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.byteValue() / right.charValue());

					case T_int:		return IntConstant.fromValue(left.byteValue() / right.intValue());
					case T_long:	return LongConstant.fromValue(left.byteValue() / right.longValue());
				}
				break;
			case T_short :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.shortValue() / right.charValue());

					case T_int:		return IntConstant.fromValue(left.shortValue() / right.intValue());
					case T_long:	return LongConstant.fromValue(left.shortValue() / right.longValue());
				}
				break;
			case T_int :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.intValue() / right.charValue());

					case T_int:		return IntConstant.fromValue(left.intValue() / right.intValue());
					case T_long:	return LongConstant.fromValue(left.intValue() / right.longValue());
				}
				break;
			case T_long :
				switch (rightId){
					case T_char :	return LongConstant.fromValue(left.longValue() / right.charValue());

					case T_int:		return LongConstant.fromValue(left.longValue() / right.intValue());
					case T_long:	return LongConstant.fromValue(left.longValue() / right.longValue());
				}
		}
			}

		return NotAConstant;
	}

	public static final Constant computeConstantOperationEQUAL_EQUAL(Constant left, int leftId, Constant right, int rightId) {

		switch (leftId){
			case T_boolean :
				if (rightId == T_boolean) {
					return BooleanConstant.fromValue(left.booleanValue() == right.booleanValue());
				}
				break;
			case T_char :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.charValue() == right.charValue());

					case T_short:	return BooleanConstant.fromValue(left.charValue() == right.shortValue());
					case T_int:		return BooleanConstant.fromValue(left.charValue() == right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.charValue() == right.longValue());}
				break;
			case T_float :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.floatValue() == right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.floatValue() == right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.floatValue() == right.longValue());
				}
				break;
			case T_double :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.doubleValue() == right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.doubleValue() == right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.doubleValue() == right.longValue());
				}
				break;
			case T_byte :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.byteValue() == right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.byteValue() == right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.byteValue() == right.longValue());
				}
				break;
			case T_short :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.shortValue() == right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.shortValue() == right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.shortValue() == right.longValue());
				}
				break;
			case T_int :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.intValue() == right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.intValue() == right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.intValue() == right.longValue());
				}
				break;
			case T_long :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.longValue() == right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.longValue() == right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.longValue() == right.longValue());
				}
				break;
			case T_JavaLangString :
				if (rightId == T_JavaLangString) {
					//String are interned in th compiler==>thus if two string constant
					//get to be compared, it is an equal on the vale which is done
					return BooleanConstant.fromValue(((StringConstant)left).hasSameValue(right));
				}
				break;
			case T_null :
				if (rightId == T_JavaLangString) {
					return BooleanConstant.fromValue(false);

						return BooleanConstant.fromValue(true);
					}
				}
		}

		return BooleanConstant.fromValue(false);
	}

	public static final Constant computeConstantOperationGREATER(Constant left, int leftId, Constant right, int rightId) {

		switch (leftId){
			case T_char :
				switch (rightId){

					case T_int:		return BooleanConstant.fromValue(left.charValue() > right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.charValue() > right.longValue());
				}
				break;
			case T_float :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.floatValue() > right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.floatValue() > right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.floatValue() > right.longValue());
				}
				break;
			case T_double :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.doubleValue() > right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.doubleValue() > right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.doubleValue() > right.longValue());
				}
				break;
			case T_byte :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.byteValue() > right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.byteValue() > right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.byteValue() > right.longValue());
				}
				break;
			case T_short :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.shortValue() > right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.shortValue() > right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.shortValue() > right.longValue());
				}
				break;
			case T_int :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.intValue() > right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.intValue() > right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.intValue() > right.longValue());
				}
				break;
			case T_long :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.longValue() > right.charValue());

					case T_long:	return BooleanConstant.fromValue(left.longValue() > right.longValue());
				}

		}

		return NotAConstant;
	}

	public static final Constant computeConstantOperationGREATER_EQUAL(Constant left, int leftId, Constant right, int rightId) {

		switch (leftId){
			case T_char :
				switch (rightId){

					case T_int:		return BooleanConstant.fromValue(left.charValue() >= right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.charValue() >= right.longValue());
				}
				break;
			case T_float :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.floatValue() >= right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.floatValue() >= right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.floatValue() >= right.longValue());
				}
				break;
			case T_double :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.doubleValue() >= right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.doubleValue() >= right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.doubleValue() >= right.longValue());
				}
				break;
			case T_byte :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.byteValue() >= right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.byteValue() >= right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.byteValue() >= right.longValue());
				}
				break;
			case T_short :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.shortValue() >= right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.shortValue() >= right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.shortValue() >= right.longValue());
				}
				break;
			case T_int :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.intValue() >= right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.intValue() >= right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.intValue() >= right.longValue());
				}
				break;
			case T_long :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.longValue() >= right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.longValue() >= right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.longValue() >= right.longValue());
				}
		}
			}

		return NotAConstant;
	}

	public static final Constant computeConstantOperationLEFT_SHIFT(Constant left, int leftId, Constant right, int rightId) {

		switch (leftId){
			case T_char :
				switch (rightId){

					case T_int:		return IntConstant.fromValue(left.charValue() << right.intValue());
					case T_long:	return IntConstant.fromValue(left.charValue() << right.longValue());
				}
				break;
			case T_byte :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.byteValue() << right.charValue());

					case T_int:		return IntConstant.fromValue(left.byteValue() << right.intValue());
					case T_long:	return IntConstant.fromValue(left.byteValue() << right.longValue());
				}
				break;
			case T_short :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.shortValue() << right.charValue());

					case T_int:		return IntConstant.fromValue(left.shortValue() << right.intValue());
					case T_long:	return IntConstant.fromValue(left.shortValue() << right.longValue());
				}
				break;
			case T_int :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.intValue() << right.charValue());

					case T_int:		return IntConstant.fromValue(left.intValue() << right.intValue());
					case T_long:	return IntConstant.fromValue(left.intValue() << right.longValue());
				}
				break;
			case T_long :
				switch (rightId){
					case T_char :	return LongConstant.fromValue(left.longValue() << right.charValue());

					case T_int:		return LongConstant.fromValue(left.longValue() << right.intValue());
					case T_long:	return LongConstant.fromValue(left.longValue() << right.longValue());
				}
		}
			}

		return NotAConstant;
	}

	public static final Constant computeConstantOperationLESS(Constant left, int leftId, Constant right, int rightId) {

		switch (leftId){
			case T_char :
				switch (rightId){

					case T_int:		return BooleanConstant.fromValue(left.charValue() < right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.charValue() < right.longValue());
				}
				break;
			case T_float :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.floatValue() < right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.floatValue() < right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.floatValue() < right.longValue());
				}
				break;
			case T_double :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.doubleValue() < right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.doubleValue() < right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.doubleValue() < right.longValue());
				}
				break;
			case T_byte :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.byteValue() < right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.byteValue() < right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.byteValue() < right.longValue());
				}
				break;
			case T_short :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.shortValue() < right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.shortValue() < right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.shortValue() < right.longValue());
				}
				break;
			case T_int :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.intValue() < right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.intValue() < right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.intValue() < right.longValue());
				}
				break;
			case T_long :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.longValue() < right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.longValue() < right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.longValue() < right.longValue());
				}
		}
			}

		return NotAConstant;
	}

	public static final Constant computeConstantOperationLESS_EQUAL(Constant left, int leftId, Constant right, int rightId) {

		switch (leftId){
			case T_char :
				switch (rightId){

					case T_int:		return BooleanConstant.fromValue(left.charValue() <= right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.charValue() <= right.longValue());
				}
				break;
			case T_float :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.floatValue() <= right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.floatValue() <= right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.floatValue() <= right.longValue());
				}
				break;
			case T_double :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.doubleValue() <= right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.doubleValue() <= right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.doubleValue() <= right.longValue());
				}
				break;
			case T_byte :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.byteValue() <= right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.byteValue() <= right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.byteValue() <= right.longValue());
				}
				break;
			case T_short :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.shortValue() <= right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.intValue() <= right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.intValue() <= right.longValue());
				}
				break;
			case T_long :
				switch (rightId){
					case T_char :	return BooleanConstant.fromValue(left.longValue() <= right.charValue());

					case T_int:		return BooleanConstant.fromValue(left.longValue() <= right.intValue());
					case T_long:	return BooleanConstant.fromValue(left.longValue() <= right.longValue());
				}
		}

		return NotAConstant;
	}

	public static final Constant computeConstantOperationMINUS(Constant left, int leftId, Constant right, int rightId) {

		switch (leftId){
			case T_char :
				switch (rightId){

					case T_int:		return IntConstant.fromValue(left.charValue() - right.intValue());
					case T_long:	return LongConstant.fromValue(left.charValue() - right.longValue());
				}
				break;
			case T_float :
				switch (rightId){
					case T_char :	return FloatConstant.fromValue(left.floatValue() - right.charValue());

					case T_int:		return FloatConstant.fromValue(left.floatValue() - right.intValue());
					case T_long:	return FloatConstant.fromValue(left.floatValue() - right.longValue());
				}
				break;
			case T_double :
				switch (rightId){
					case T_char :	return DoubleConstant.fromValue(left.doubleValue() - right.charValue());

					case T_int:		return DoubleConstant.fromValue(left.doubleValue() - right.intValue());
					case T_long:	return DoubleConstant.fromValue(left.doubleValue() - right.longValue());
				}
				break;
			case T_byte :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.byteValue() - right.charValue());

					case T_int:		return IntConstant.fromValue(left.byteValue() - right.intValue());
					case T_long:	return LongConstant.fromValue(left.byteValue() - right.longValue());
				}
				break;
			case T_short :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.shortValue() - right.charValue());

					case T_int:		return IntConstant.fromValue(left.shortValue() - right.intValue());
					case T_long:	return LongConstant.fromValue(left.shortValue() - right.longValue());
				}
				break;
			case T_int :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.intValue() - right.charValue());

					case T_int:		return IntConstant.fromValue(left.intValue() - right.intValue());
					case T_long:	return LongConstant.fromValue(left.intValue() - right.longValue());
				}
				break;
			case T_long :
				switch (rightId){
					case T_char :	return LongConstant.fromValue(left.longValue() - right.charValue());

					case T_int:		return LongConstant.fromValue(left.longValue() - right.intValue());
					case T_long:	return LongConstant.fromValue(left.longValue() - right.longValue());
				}
		}
			}

		return NotAConstant;
	}

	public static final Constant computeConstantOperationMULTIPLY(Constant left, int leftId, Constant right, int rightId) {

		switch (leftId){
			case T_char :
				switch (rightId){

					case T_int:		return IntConstant.fromValue(left.charValue() * right.intValue());
					case T_long:	return LongConstant.fromValue(left.charValue() * right.longValue());
				}
				break;
			case T_float :
				switch (rightId){
					case T_char :	return FloatConstant.fromValue(left.floatValue() * right.charValue());

					case T_int:		return FloatConstant.fromValue(left.floatValue() * right.intValue());
					case T_long:	return FloatConstant.fromValue(left.floatValue() * right.longValue());
				}
				break;
			case T_double :
				switch (rightId){
					case T_char :	return DoubleConstant.fromValue(left.doubleValue() * right.charValue());

					case T_int:		return DoubleConstant.fromValue(left.doubleValue() * right.intValue());
					case T_long:	return DoubleConstant.fromValue(left.doubleValue() * right.longValue());
				}
				break;
			case T_byte :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.byteValue() * right.charValue());

					case T_int:		return IntConstant.fromValue(left.byteValue() * right.intValue());
					case T_long:	return LongConstant.fromValue(left.byteValue() * right.longValue());
				}
				break;
			case T_short :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.shortValue() * right.charValue());

					case T_int:		return IntConstant.fromValue(left.shortValue() * right.intValue());
					case T_long:	return LongConstant.fromValue(left.shortValue() * right.longValue());
				}
				break;
			case T_int :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.intValue() * right.charValue());

					case T_int:		return IntConstant.fromValue(left.intValue() * right.intValue());
					case T_long:	return LongConstant.fromValue(left.intValue() * right.longValue());
				}
				break;
			case T_long :
				switch (rightId){
					case T_char :	return LongConstant.fromValue(left.longValue() * right.charValue());

					case T_int:		return LongConstant.fromValue(left.longValue() * right.intValue());
					case T_long:	return LongConstant.fromValue(left.longValue() * right.longValue());
				}
		}

		return NotAConstant;
	}

	public static final Constant computeConstantOperationOR(Constant left, int leftId, Constant right, int rightId) {

		switch (leftId){
			case T_boolean :		return BooleanConstant.fromValue(left.booleanValue() | right.booleanValue());
			case T_char :

					case T_int:		return IntConstant.fromValue(left.charValue() | right.intValue());
					case T_long:	return LongConstant.fromValue(left.charValue() | right.longValue());
				}
				break;
			case T_byte :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.byteValue() | right.charValue());

					case T_int:		return IntConstant.fromValue(left.byteValue() | right.intValue());
					case T_long:	return LongConstant.fromValue(left.byteValue() | right.longValue());
				}
				break;
			case T_short :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.shortValue() | right.charValue());

					case T_int:		return IntConstant.fromValue(left.shortValue() | right.intValue());
					case T_long:	return LongConstant.fromValue(left.shortValue() | right.longValue());
				}
				break;
			case T_int :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.intValue() | right.charValue());

					case T_int:		return IntConstant.fromValue(left.intValue() | right.intValue());
					case T_long:	return LongConstant.fromValue(left.intValue() | right.longValue());
				}
				break;
			case T_long :
				switch (rightId){
					case T_char :	return LongConstant.fromValue(left.longValue() | right.charValue());

					case T_int:		return LongConstant.fromValue(left.longValue() | right.intValue());
					case T_long:	return LongConstant.fromValue(left.longValue() | right.longValue());
				}
		}
			}

		return NotAConstant;
	}

	public static final Constant computeConstantOperationOR_OR(Constant left, int leftId, Constant right, int rightId) {

		return BooleanConstant.fromValue(left.booleanValue() || right.booleanValue());
	}

	public static final Constant computeConstantOperationPLUS(Constant left, int leftId, Constant right, int rightId) {

		switch (leftId){
			case T_JavaLangObject :
				if (rightId == T_JavaLangString) {

//					case T_JavaLangString:	return Constant.fromValue(left.stringValue() + right.stringValue());
//					case T_boolean:	return Constant.fromValue(left.stringValue() + right.booleanValue());
//				}
		}

		return NotAConstant;
	}

	public static final Constant computeConstantOperationREMAINDER(Constant left, int leftId, Constant right, int rightId) {

		switch (leftId){
			case T_char :
				switch (rightId){

					case T_int:		return IntConstant.fromValue(left.charValue() % right.intValue());
					case T_long:	return LongConstant.fromValue(left.charValue() % right.longValue());
				}
				break;
			case T_float :
				switch (rightId){
					case T_char :	return FloatConstant.fromValue(left.floatValue() % right.charValue());

					case T_int:		return FloatConstant.fromValue(left.floatValue() % right.intValue());
					case T_long:	return FloatConstant.fromValue(left.floatValue() % right.longValue());
				}
				break;
			case T_double :
				switch (rightId){
					case T_char :	return DoubleConstant.fromValue(left.doubleValue() % right.charValue());

					case T_int:		return DoubleConstant.fromValue(left.doubleValue() % right.intValue());
					case T_long:	return DoubleConstant.fromValue(left.doubleValue() % right.longValue());
				}
				break;
			case T_byte :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.byteValue() % right.charValue());

					case T_int:		return IntConstant.fromValue(left.byteValue() % right.intValue());
					case T_long:	return LongConstant.fromValue(left.byteValue() % right.longValue());
				}
				break;
			case T_short :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.shortValue() % right.charValue());

					case T_int:		return IntConstant.fromValue(left.shortValue() % right.intValue());
					case T_long:	return LongConstant.fromValue(left.shortValue() % right.longValue());
				}
				break;
			case T_int :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.intValue() % right.charValue());

					case T_int:		return IntConstant.fromValue(left.intValue() % right.intValue());
					case T_long:	return LongConstant.fromValue(left.intValue() % right.longValue());
				}
				break;
			case T_long :
				switch (rightId){
					case T_char :	return LongConstant.fromValue(left.longValue() % right.charValue());

					case T_int:		return LongConstant.fromValue(left.longValue() % right.intValue());
					case T_long:	return LongConstant.fromValue(left.longValue() % right.longValue());
				}
		}
			}

		return NotAConstant;
	}

	public static final Constant computeConstantOperationRIGHT_SHIFT(Constant left, int leftId, Constant right, int rightId) {

		switch (leftId){
			case T_char :
				switch (rightId){

					case T_int:		return IntConstant.fromValue(left.charValue() >> right.intValue());
					case T_long:	return IntConstant.fromValue(left.charValue() >> right.longValue());
				}
				break;
			case T_byte :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.byteValue() >> right.charValue());

					case T_int:		return IntConstant.fromValue(left.byteValue() >> right.intValue());
					case T_long:	return IntConstant.fromValue(left.byteValue() >> right.longValue());
				}
				break;
			case T_short :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.shortValue() >> right.charValue());

					case T_int:		return IntConstant.fromValue(left.shortValue() >> right.intValue());
					case T_long:	return IntConstant.fromValue(left.shortValue() >> right.longValue());
				}
				break;
			case T_int :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.intValue() >> right.charValue());

					case T_int:		return IntConstant.fromValue(left.intValue() >> right.intValue());
					case T_long:	return IntConstant.fromValue(left.intValue() >> right.longValue());
				}
				break;
			case T_long :
				switch (rightId){
					case T_char :	return LongConstant.fromValue(left.longValue() >> right.charValue());

					case T_int:		return LongConstant.fromValue(left.longValue() >> right.intValue());
					case T_long:	return LongConstant.fromValue(left.longValue() >> right.longValue());
				}
		}
			}

		return NotAConstant;
	}

	public static final Constant computeConstantOperationUNSIGNED_RIGHT_SHIFT(Constant left, int leftId, Constant right, int rightId) {

		switch (leftId){
			case T_char :
				switch (rightId){

					case T_int:		return IntConstant.fromValue(left.charValue() >>> right.intValue());
					case T_long:	return IntConstant.fromValue(left.charValue() >>> right.longValue());
				}
				break;
			case T_byte :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.byteValue() >>> right.charValue());

					case T_int:		return IntConstant.fromValue(left.byteValue() >>> right.intValue());
					case T_long:	return IntConstant.fromValue(left.byteValue() >>> right.longValue());
				}
				break;
			case T_short :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.shortValue() >>> right.charValue());

					case T_int:		return IntConstant.fromValue(left.shortValue() >>> right.intValue());
					case T_long:	return IntConstant.fromValue(left.shortValue() >>> right.longValue());
				}
				break;
			case T_int :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.intValue() >>> right.charValue());

					case T_int:		return IntConstant.fromValue(left.intValue() >>> right.intValue());
					case T_long:	return IntConstant.fromValue(left.intValue() >>> right.longValue());
				}
				break;
			case T_long :
				switch (rightId){
					case T_char :	return LongConstant.fromValue(left.longValue() >>> right.charValue());

					case T_int:		return LongConstant.fromValue(left.longValue() >>> right.intValue());
					case T_long:	return LongConstant.fromValue(left.longValue() >>> right.longValue());
				}
		}
			}

		return NotAConstant;
	}

	public static final Constant computeConstantOperationXOR(Constant left, int leftId, Constant right, int rightId) {

		switch (leftId){
			case T_boolean :		return BooleanConstant.fromValue(left.booleanValue() ^ right.booleanValue());
			case T_char :

					case T_int:		return IntConstant.fromValue(left.charValue() ^ right.intValue());
					case T_long:	return LongConstant.fromValue(left.charValue() ^ right.longValue());
				}
				break;
			case T_byte :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.byteValue() ^ right.charValue());

					case T_int:		return IntConstant.fromValue(left.byteValue() ^ right.intValue());
					case T_long:	return LongConstant.fromValue(left.byteValue() ^ right.longValue());
				}
				break;
			case T_short :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.shortValue() ^ right.charValue());

					case T_int:		return IntConstant.fromValue(left.shortValue() ^ right.intValue());
					case T_long:	return LongConstant.fromValue(left.shortValue() ^ right.longValue());
				}
				break;
			case T_int :
				switch (rightId){
					case T_char :	return IntConstant.fromValue(left.intValue() ^ right.charValue());

					case T_int:		return IntConstant.fromValue(left.intValue() ^ right.intValue());
					case T_long:	return LongConstant.fromValue(left.intValue() ^ right.longValue());
				}
				break;
			case T_long :
				switch (rightId){
					case T_char :	return LongConstant.fromValue(left.longValue() ^ right.charValue());

					case T_int:		return LongConstant.fromValue(left.longValue() ^ right.intValue());
					case T_long:	return LongConstant.fromValue(left.longValue() ^ right.longValue());
				}
		}

		return NotAConstant;
	}

	public double doubleValue() {

		throw new ShouldNotImplement(Messages.bind(Messages.constant_cannotCastedInto, new String[] { typeName(), "double" })); //$NON-NLS-1$
	}

	public float floatValue() {

		throw new ShouldNotImplement(Messages.bind(Messages.constant_cannotCastedInto, new String[] { typeName(), "float" })); //$NON-NLS-1$
	}
	
	/**
	 * Returns true if both constants have the same type and the same actual value
	 * @param otherConstant

	}

	public int intValue() {

		throw new ShouldNotImplement(Messages.bind(Messages.constant_cannotCastedInto, new String[] { typeName(), "int" })); //$NON-NLS-1$
	}

	public long longValue() {

		throw new ShouldNotImplement(Messages.bind(Messages.constant_cannotCastedInto, new String[] { typeName(), "long" })); //$NON-NLS-1$
	}

	public short shortValue() {

		throw new ShouldNotImplement(Messages.bind(Messages.constant_cannotConvertedTo, new String[] { typeName(), "short" })); //$NON-NLS-1$
	}

	public String stringValue() {

		throw new ShouldNotImplement(Messages.bind(Messages.constant_cannotConvertedTo, new String[] { typeName(), "String" })); //$NON-NLS-1$
	}

	public String toString(){

		if (this == NotAConstant) return "(Constant) NotAConstant"; //$NON-NLS-1$
		return super.toString(); }





package org.eclipse.jdt.internal.compiler.impl;

public class ByteConstant extends Constant {

	private byte value;

	public static Constant fromValue(byte value) {
		return new ByteConstant(value);
	}
private ByteConstant(byte value) {
	this.value = value;
}
public byte byteValue() {
	return this.value;
}
public char charValue() {
	return (char) this.value;
}
public double doubleValue() {
	return this.value; // implicit cast to return type
}
public float floatValue() {
	return this.value; // implicit cast to return type
}
public int intValue() {
	return this.value; // implicit cast to return type
}
public long longValue() {
	return this.value; // implicit cast to return type
}
public short shortValue() {
	return this.value; // implicit cast to return type
}
public String stringValue() {
	//spec 15.17.11
	return String.valueOf(this.value) ;
}
public String toString(){

	private ByteConstant(byte value) {
		this.value = value;
	}

	public byte byteValue() {
		return this.value;
	}

	public char charValue() {
		return (char) this.value;
	}

	public double doubleValue() {
		return this.value; // implicit cast to return type
	}

	public float floatValue() {
		return this.value; // implicit cast to return type
	}

	public int intValue() {
		return this.value; // implicit cast to return type
	}

	public long longValue() {
		return this.value; // implicit cast to return type
	}

	public short shortValue() {
		return this.value; // implicit cast to return type
	}

	public String stringValue() {
		// spec 15.17.11
		return String.valueOf(this.value);
	}

	public String toString() {
		return "(byte)" + this.value; //$NON-NLS-1$
	}

	public int typeID() {
		return T_byte;
	}
}





	int value;

	private static final IntConstant MIN_VALUE = new IntConstant(Integer.MIN_VALUE);
	private static final IntConstant MINUS_FOUR = new IntConstant(-4);
	private static final IntConstant MINUS_THREE = new IntConstant(-3);
	private static final IntConstant MINUS_TWO = new IntConstant(-2);

	private static final IntConstant TEN = new IntConstant(10);

	public static Constant fromValue(int value) {

		switch (value) {
			case Integer.MIN_VALUE : return IntConstant.MIN_VALUE;
			case -4 : return IntConstant.MINUS_FOUR;
			case -3 : return IntConstant.MINUS_THREE;
			case -2 : return IntConstant.MINUS_TWO;




	private CharConstant(char value) {
		this.value = value;
	}

	public byte byteValue() {
		return (byte) this.value;
	}

	public char charValue() {
		return this.value;
	}

	public double doubleValue() {
		return this.value; // implicit cast to return type
	}

	public float floatValue() {
		return this.value; // implicit cast to return type
	}

	public int intValue() {
		return this.value; // implicit cast to return type
	}

	public long longValue() {
		return this.value; // implicit cast to return type
	}

	public short shortValue() {
		return (short) this.value;
	}

	public String stringValue() {
		// spec 15.17.11
		return String.valueOf(this.value);
	}
	public String toString(){

	public String toString() {
		return "(char)" + this.value; //$NON-NLS-1$
	}

	public int typeID() {
		return T_char;
	}

Return to bug 261510

Lines 15-27 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/LongLiteralMinValue.java (-3 / +1 lines)
15	public class LongLiteralMinValue extends LongLiteral {	15	public class LongLiteralMinValue extends LongLiteral {
16		16
17	final static char[] CharValue = new char[]{'-', '9','2','2','3','3','7','2','0','3','6','8','5','4','7','7','5','8','0','8','L'};	17	final static char[] CharValue = new char[]{'-', '9','2','2','3','3','7','2','0','3','6','8','5','4','7','7','5','8','0','8','L'};
18	final static Constant MIN_VALUE = LongConstant.fromValue(Long.MIN_VALUE) ;
19		18
20	public LongLiteralMinValue(){	19	public LongLiteralMinValue(){
21	super(CharValue,0,0);	20	super(CharValue,0,0);
22	this.constant = MIN_VALUE;	21	this.constant = LongConstant.fromValue(Long.MIN_VALUE);
23	}	22	}
24	public void computeConstant() {	23	public void computeConstant() {
25
26	/precomputed at creation time/}	24	/precomputed at creation time/}
27	}	25	}

Lines 15-27 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/IntLiteralMinValue.java (-3 / +2 lines)
15	public class IntLiteralMinValue extends IntLiteral {	15	public class IntLiteralMinValue extends IntLiteral {
16		16
17	final static char[] CharValue = new char[]{'-','2','1','4','7','4','8','3','6','4','8'};	17	final static char[] CharValue = new char[]{'-','2','1','4','7','4','8','3','6','4','8'};
18	final static Constant MIN_VALUE = IntConstant.fromValue(Integer.MIN_VALUE) ;
19		18
20	public IntLiteralMinValue() {	19	public IntLiteralMinValue() {
21	super(CharValue,0,0,Integer.MIN_VALUE);	20	super(CharValue,0,0,Integer.MIN_VALUE);
22	this.constant = MIN_VALUE;	21	this.constant = IntConstant.fromValue(Integer.MIN_VALUE);
23	}	22	}
24	public void computeConstant(){
25		23
		24	public void computeConstant(){
26	/precomputed at creation time/ }	25	/precomputed at creation time/ }
27	}	26	}

Lines 15-21 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/NumberLiteral.java (-3 lines)
15	char[] source;	15	char[] source;
16		16
17	public NumberLiteral(char[] token, int s, int e) {	17	public NumberLiteral(char[] token, int s, int e) {
18
19	this(s,e) ;	18	this(s,e) ;
20	this.source = token ;	19	this.source = token ;
21	}	20	}
Lines 25-36 Link Here
25	}	24	}
26		25
27	public boolean isValidJavaStatement(){	26	public boolean isValidJavaStatement(){
28
29	return false ;	27	return false ;
30	}	28	}
31		29
32	public char[] source(){	30	public char[] source(){
33
34	return this.source;	31	return this.source;
35	}	32	}
36	}	33	}

Lines 9-14 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/impl/ReferenceContext.java (+5 lines)
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.impl;	11	package org.eclipse.jdt.internal.compiler.impl;
		12
12	/*	13	/*
13	* Implementors are valid compilation contexts from which we can	14	* Implementors are valid compilation contexts from which we can
14	* escape in case of error:	15	* escape in case of error:
Lines 19-26 Link Here
19	import org.eclipse.jdt.internal.compiler.CompilationResult;	20	import org.eclipse.jdt.internal.compiler.CompilationResult;
20		21
21	public interface ReferenceContext {	22	public interface ReferenceContext {
		23
22	void abort(int abortLevel, CategorizedProblem problem);	24	void abort(int abortLevel, CategorizedProblem problem);
		25
23	CompilationResult compilationResult();	26	CompilationResult compilationResult();
		27
24	boolean hasErrors();	28	boolean hasErrors();
		29
25	void tagAsHavingErrors();	30	void tagAsHavingErrors();
26	}	31	}

Lines 12-43 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/impl/BooleanConstant.java (-26 / +27 lines)
12		12
13	public class BooleanConstant extends Constant {	13	public class BooleanConstant extends Constant {
14		14
15	private boolean value;	15	private boolean value;
16		16
17	private static final BooleanConstant TRUE = new BooleanConstant(true);	17	private static final BooleanConstant TRUE = new BooleanConstant(true);
18	private static final BooleanConstant FALSE = new BooleanConstant(false);	18	private static final BooleanConstant FALSE = new BooleanConstant(false);
19		19
20	public static BooleanConstant fromValue(boolean value) {	20	public static BooleanConstant fromValue(boolean value) {
21	return value ? BooleanConstant.TRUE : BooleanConstant.FALSE;	21	return value ? BooleanConstant.TRUE : BooleanConstant.FALSE;
22	}	22	}
23	private BooleanConstant(boolean value) {	23
24	this.value = value;	24	private BooleanConstant(boolean value) {
25	}	25	this.value = value;
26		26	}
27	public boolean booleanValue() {	27
28	return this.value;	28	public boolean booleanValue() {
29	}	29	return this.value;
30		30	}
31	public String stringValue() {	31
32	//spec 15.17.11	32	public String stringValue() {
33	return String.valueOf(this.value);	33	// spec 15.17.11
34	}	34	return String.valueOf(this.value);
35		35	}
36	public String toString(){	36
37	return "(boolean)" + this.value ; //$NON-NLS-1$	37	public String toString() {
38	}	38	return "(boolean)" + this.value; //$NON-NLS-1$
39		39	}
40	public int typeID() {	40
41	return T_boolean;	41	public int typeID() {
42	}	42	return T_boolean;
		43	}
43	}	44	}

Lines 14-19 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/impl/IntConstant.java (-1 / +2 lines)
14		14
15	int value;	15	int value;
16		16
		17	private static final IntConstant MIN_VALUE = new IntConstant(Integer.MIN_VALUE);
17	private static final IntConstant MINUS_FOUR = new IntConstant(-4);	18	private static final IntConstant MINUS_FOUR = new IntConstant(-4);
18	private static final IntConstant MINUS_THREE = new IntConstant(-3);	19	private static final IntConstant MINUS_THREE = new IntConstant(-3);
19	private static final IntConstant MINUS_TWO = new IntConstant(-2);	20	private static final IntConstant MINUS_TWO = new IntConstant(-2);
Lines 31-38 Link Here
31	private static final IntConstant TEN = new IntConstant(10);	32	private static final IntConstant TEN = new IntConstant(10);
32		33
33	public static Constant fromValue(int value) {	34	public static Constant fromValue(int value) {
34
35	switch (value) {	35	switch (value) {
		36	case Integer.MIN_VALUE : return IntConstant.MIN_VALUE;
36	case -4 : return IntConstant.MINUS_FOUR;	37	case -4 : return IntConstant.MINUS_FOUR;
37	case -3 : return IntConstant.MINUS_THREE;	38	case -3 : return IntConstant.MINUS_THREE;
38	case -2 : return IntConstant.MINUS_TWO;	39	case -2 : return IntConstant.MINUS_TWO;

Lines 21-55 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/impl/CharConstant.java (-2 / +11 lines)
21	private CharConstant(char value) {	21	private CharConstant(char value) {
22	this.value = value;	22	this.value = value;
23	}	23	}
		24
24	public byte byteValue() {	25	public byte byteValue() {
25	return (byte) this.value;	26	return (byte) this.value;
26	}	27	}
		28
27	public char charValue() {	29	public char charValue() {
28	return this.value;	30	return this.value;
29	}	31	}
		32
30	public double doubleValue() {	33	public double doubleValue() {
31	return this.value; // implicit cast to return type	34	return this.value; // implicit cast to return type
32	}	35	}
		36
33	public float floatValue() {	37	public float floatValue() {
34	return this.value; // implicit cast to return type	38	return this.value; // implicit cast to return type
35	}	39	}
		40
36	public int intValue() {	41	public int intValue() {
37	return this.value; // implicit cast to return type	42	return this.value; // implicit cast to return type
38	}	43	}
		44
39	public long longValue() {	45	public long longValue() {
40	return this.value; // implicit cast to return type	46	return this.value; // implicit cast to return type
41	}	47	}
		48
42	public short shortValue() {	49	public short shortValue() {
43	return (short) this.value;	50	return (short) this.value;
44	}	51	}
		52
45	public String stringValue() {	53	public String stringValue() {
46	//spec 15.17.11	54	// spec 15.17.11
47	return String.valueOf(this.value);	55	return String.valueOf(this.value);
48	}	56	}
49	public String toString(){
50		57
		58	public String toString() {
51	return "(char)" + this.value; //$NON-NLS-1$	59	return "(char)" + this.value; //$NON-NLS-1$
52	}	60	}
		61
53	public int typeID() {	62	public int typeID() {
54	return T_char;	63	return T_char;
55	}	64	}