Attachment #25240 for bug #104704

Lines 626-632 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ClassFile.java (-2 / +2 lines)
626	if (this.referenceBinding instanceof LocalTypeBinding) {	626	if (this.referenceBinding instanceof LocalTypeBinding) {
627	MethodBinding methodBinding = ((LocalTypeBinding) this.referenceBinding).enclosingMethod;	627	MethodBinding methodBinding = ((LocalTypeBinding) this.referenceBinding).enclosingMethod;
628	if (methodBinding != null) {	628	if (methodBinding != null) {
629	int enclosingMethodIndex = constantPool.literalIndexForMethod(methodBinding.selector, methodBinding.signature());	629	int enclosingMethodIndex = constantPool.literalIndexForNameAndType(methodBinding.selector, methodBinding.signature());
630	methodIndexByte1 = (byte) (enclosingMethodIndex >> 8);	630	methodIndexByte1 = (byte) (enclosingMethodIndex >> 8);
631	methodIndexByte2 = (byte) enclosingMethodIndex;	631	methodIndexByte2 = (byte) enclosingMethodIndex;
632	}	632	}
Lines 2861-2867 Link Here
2861	* @return char[]	2861	* @return char[]
2862	*/	2862	*/
2863	public char[] fileName() {	2863	public char[] fileName() {
2864	return constantPool.UTF8Cache.returnKeyFor(1);	2864	return constantPool.UTF8Cache.returnKeyFor(2);
2865	}	2865	}
2866		2866
2867	private void generateAnnotation(Annotation annotation, int attributeOffset) {	2867	private void generateAnnotation(Annotation annotation, int attributeOffset) {




	return -1;
}
private int hashCodeChar(char[] val) {
	final int length = val.length;
	int hash = 0;
	final int n = 3; // number of characters skipped
	for (int i = 0; i < length; i += n) {
		hash += val[i];
	}
	return (hash & 0x7FFFFFFF) % keyTable.length;
}
/**
 * Puts the specified element into the hashtable if it wasn't there already, 
 * using the specified key.  The element may be retrieved by doing a get() with the same key.
 * The key and the element cannot be null. 
 * 
 * @param key the given key in the hashtable
 * @param value the given value
 * @return int the old value of the key, or -value if it did not have one.
 */
public int putIfAbsent(char[] key, int value) {
	int index = hashCodeChar(key);
	while (keyTable[index] != null) {
		if (CharOperation.equals(keyTable[index], key))
			return valueTable[index];
		index = (index + 1) % keyTable.length;
	}
	keyTable[index] = key;
	valueTable[index] = value;

	// assumes the threshold is never equal to the size of the table
	if (++elementSize > threshold)
		rehash();
	return -value; // negative when added (value is assumed to be > 0)
}

/**
 * Puts the specified element into the hashtable, using the specified
 * key.  The element may be retrieved by doing a get() with the same key.
 * The key and the element cannot be null. 

 * @param value <CODE>int</CODE> the specified element
 * @return int the old value of the key, or -1 if it did not have one.
 */
private int put(char[] key, int value) { 
	int index = hashCodeChar(key);
	while (keyTable[index] != null) {
		if (CharOperation.equals(keyTable[index], key))

Lines 3334-3340 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/codegen/CodeStream.java (-4 / +24 lines)
3334	}	3334	}
3335	position += 3;	3335	position += 3;
3336	bCodeStream[classFileOffset++] = OPC_invokeinterface;	3336	bCodeStream[classFileOffset++] = OPC_invokeinterface;
3337	writeUnsignedShort(constantPool.literalIndex(methodBinding));	3337	writeUnsignedShort(
		3338	constantPool.literalIndexForMethod(
		3339	methodBinding.constantPoolDeclaringClass().constantPoolName(),
		3340	methodBinding.selector,
		3341	methodBinding.signature(),
		3342	true));
3338	for (int i = methodBinding.parameters.length - 1; i >= 0; i--)	3343	for (int i = methodBinding.parameters.length - 1; i >= 0; i--)
3339	if (((id = methodBinding.parameters[i].id) == T_double) \|\| (id == T_long))	3344	if (((id = methodBinding.parameters[i].id) == T_double) \|\| (id == T_long))
3340	argCount += 2;	3345	argCount += 2;
Lines 3402-3408 Link Here
3402	}	3407	}
3403	position++;	3408	position++;
3404	bCodeStream[classFileOffset++] = OPC_invokespecial;	3409	bCodeStream[classFileOffset++] = OPC_invokespecial;
3405	writeUnsignedShort(constantPool.literalIndex(methodBinding));	3410	writeUnsignedShort(
		3411	constantPool.literalIndexForMethod(
		3412	methodBinding.constantPoolDeclaringClass().constantPoolName(),
		3413	methodBinding.selector,
		3414	methodBinding.signature(),
		3415	false));
3406	if (methodBinding.isConstructor() && methodBinding.declaringClass.isNestedType()) {	3416	if (methodBinding.isConstructor() && methodBinding.declaringClass.isNestedType()) {
3407	// enclosing instances	3417	// enclosing instances
3408	TypeBinding[] syntheticArgumentTypes = methodBinding.declaringClass.syntheticEnclosingInstanceTypes();	3418	TypeBinding[] syntheticArgumentTypes = methodBinding.declaringClass.syntheticEnclosingInstanceTypes();
Lines 3454-3460 Link Here
3454	}	3464	}
3455	position++;	3465	position++;
3456	bCodeStream[classFileOffset++] = OPC_invokestatic;	3466	bCodeStream[classFileOffset++] = OPC_invokestatic;
3457	writeUnsignedShort(constantPool.literalIndex(methodBinding));	3467	writeUnsignedShort(
		3468	constantPool.literalIndexForMethod(
		3469	methodBinding.constantPoolDeclaringClass().constantPoolName(),
		3470	methodBinding.selector,
		3471	methodBinding.signature(),
		3472	false));
3458	for (int i = methodBinding.parameters.length - 1; i >= 0; i--)	3473	for (int i = methodBinding.parameters.length - 1; i >= 0; i--)
3459	if (((id = methodBinding.parameters[i].id) == T_double) \|\| (id == T_long))	3474	if (((id = methodBinding.parameters[i].id) == T_double) \|\| (id == T_long))
3460	argCount += 2;	3475	argCount += 2;
Lines 3873-3879 Link Here
3873	}	3888	}
3874	position++;	3889	position++;
3875	bCodeStream[classFileOffset++] = OPC_invokevirtual;	3890	bCodeStream[classFileOffset++] = OPC_invokevirtual;
3876	writeUnsignedShort(constantPool.literalIndex(methodBinding));	3891	writeUnsignedShort(
		3892	constantPool.literalIndexForMethod(
		3893	methodBinding.constantPoolDeclaringClass().constantPoolName(),
		3894	methodBinding.selector,
		3895	methodBinding.signature(),
		3896	false));
3877	for (int i = methodBinding.parameters.length - 1; i >= 0; i--)	3897	for (int i = methodBinding.parameters.length - 1; i >= 0; i--)
3878	if (((id = methodBinding.parameters[i].id) == T_double) \|\| (id == T_long))	3898	if (((id = methodBinding.parameters[i].id) == T_double) \|\| (id == T_long))
3879	argCount += 2;	3899	argCount += 2;





import org.eclipse.jdt.internal.compiler.ClassFile;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.lookup.FieldBinding;
import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
import org.eclipse.jdt.internal.compiler.util.HashtableOfObject;

	System.arraycopy(poolContent, 0, (poolContent = new byte[currentOffset]), 0, currentOffset);
	return poolContent;
}
private int getFromCache(char[] declaringClass, char[] name, char[] signature) {
	HashtableOfObject value = (HashtableOfObject) this.methodsAndFieldsCache.get(declaringClass);
	if (value == null) {
		return -1;
	}
	CharArrayCache value2 = (CharArrayCache) value.get(name);
	if (value2 == null) {
		return -1;
	}
	return value2.get(signature);
}
private int getFromNameAndTypeCache(char[] name, char[] signature) {
	CharArrayCache value = (CharArrayCache) this.nameAndTypeCacheForFieldsAndMethods.get(name);
	if (value == null) {
		return -1;
	}
	return value.get(signature);
}
public int literalIndex(byte[] utf8encoding, char[] stringCharArray) {
	int index;
	if ((index = UTF8Cache.putIfAbsent(stringCharArray, this.currentIndex)) < 0) {
		// The entry doesn't exit yet
		if ((index = -index)> 0xFFFF){
		if (index > 0xFFFF){
			this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
		}
		currentIndex++;
		// Write the tag first
		writeU1(Utf8Tag);
		// Then the size of the stringName array
		//writeU2(utf8Constant.length);
		int savedCurrentOffset = currentOffset;
		int utf8encodingLength = utf8encoding.length;
		if (currentOffset + 2 + utf8encodingLength >= poolContent.length) {

 */
public int literalIndex(char[] utf8Constant) {
	int index;
	if ((index = UTF8Cache.putIfAbsent(utf8Constant, this.currentIndex)) < 0) {
		index = -index;
		// The entry doesn't exit yet
		// Write the tag first
		writeU1(Utf8Tag);

			currentOffset = savedCurrentOffset - 1;
			this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceForConstant(this.classFile.referenceBinding.scope.referenceType());
		}
		index = UTF8Cache.put(utf8Constant, currentIndex);
		if (index > 0xFFFF){
			this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
		}

}
public int literalIndex(char[] stringCharArray, byte[] utf8encoding) {
	int index;
	if ((index = stringCache.putIfAbsent(stringCharArray, this.currentIndex)) < 0) {
	if ((index = stringCache.get(stringCharArray)) < 0) {
		// The entry doesn't exit yet
		this.currentIndex++;
		if ((index = -index) > 0xFFFF){
		if (index > 0xFFFF){
			this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
		}
		// Write the tag first
		writeU1(StringTag);
		// Then the string index
		int stringIndexOffset = this.currentOffset;
		if (currentOffset + 2 >= poolContent.length) {
			resizePoolContents(2);
		}
		currentOffset+=2;

		final int stringIndex = literalIndex(utf8encoding, stringCharArray);
		poolContent[stringIndexOffset++] = (byte) (stringIndex >> 8);
		poolContent[stringIndexOffset] = (byte) stringIndex;
	}
	return index;
}

	if (doubleCache == null) {
			doubleCache = new DoubleCache(DOUBLE_INITIAL_SIZE);
	}
	if ((index = doubleCache.putIfAbsent(key, this.currentIndex)) < 0) {
		if ((index = -index)> 0xFFFF){
		if (index > 0xFFFF){
			this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
		}
		this.currentIndex += 2; // a double needs an extra place into the constant pool
		// Write the double into the constant pool
		// First add the tag
		writeU1(DoubleTag);

		if (currentOffset + 8 >= length) {
			resizePoolContents(8);
		}
		poolContent[currentOffset++] = (byte) (temp >>> 56);
		poolContent[currentOffset++] = (byte) (temp >>> 48);
		poolContent[currentOffset++] = (byte) (temp >>> 40);
		poolContent[currentOffset++] = (byte) (temp >>> 32);
		poolContent[currentOffset++] = (byte) (temp >>> 24);
		poolContent[currentOffset++] = (byte) (temp >>> 16);
		poolContent[currentOffset++] = (byte) (temp >>> 8);
		poolContent[currentOffset++] = (byte) temp;
	}
	return index;
}

	if (floatCache == null) {
		floatCache = new FloatCache(FLOAT_INITIAL_SIZE);
	}
	if ((index = floatCache.putIfAbsent(key, this.currentIndex)) < 0) {
		if ((index = -index) > 0xFFFF){
		if (index > 0xFFFF){
			this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
		}
		this.currentIndex++;
		// Write the float constant entry into the constant pool
		// First add the tag
		writeU1(FloatTag);

		if (currentOffset + 4 >= poolContent.length) {
			resizePoolContents(4);
		}
		poolContent[currentOffset++] = (byte) (temp >>> 24);
		poolContent[currentOffset++] = (byte) (temp >>> 16);
		poolContent[currentOffset++] = (byte) (temp >>> 8);
		poolContent[currentOffset++] = (byte) temp;
	}
	return index;
}

	if (intCache == null) {
		intCache = new IntegerCache(INT_INITIAL_SIZE);
	}
	if ((index = intCache.putIfAbsent(key, this.currentIndex)) < 0) {
		this.currentIndex++;
		if ((index = -index) > 0xFFFF){
			this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
		}
	// Write the integer constant entry into the constant pool
		// First add the tag
		writeU1(IntegerTag);
		// Then add the 4 bytes representing the int
		if (currentOffset + 4 >= poolContent.length) {
			resizePoolContents(4);
		}
		poolContent[currentOffset++] = (byte) (key >>> 24);
		poolContent[currentOffset++] = (byte) (key >>> 16);
		poolContent[currentOffset++] = (byte) (key >>> 8);
		poolContent[currentOffset++] = (byte) key;
	}
	return index;
}

	if (longCache == null) {
		longCache = new LongCache(LONG_INITIAL_SIZE);
	}
	if ((index = longCache.putIfAbsent(key, this.currentIndex)) < 0) {
		if ((index = -index) > 0xFFFF){
		if (index > 0xFFFF){
			this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
		}
		this.currentIndex+= 2; // long value need an extra place into thwe constant pool
		// Write the long into the constant pool
		// First add the tag
		writeU1(LongTag);

		if (currentOffset + 8 >= poolContent.length) {
			resizePoolContents(8);
		}
		poolContent[currentOffset++] = (byte) (key >>> 56);
		poolContent[currentOffset++] = (byte) (key >>> 48);
		poolContent[currentOffset++] = (byte) (key >>> 40);
		poolContent[currentOffset++] = (byte) (key >>> 32);
		poolContent[currentOffset++] = (byte) (key >>> 24);
		poolContent[currentOffset++] = (byte) (key >>> 16);
		poolContent[currentOffset++] = (byte) (key >>> 8);
		poolContent[currentOffset++] = (byte) key;
	}
	return index;
}

public int literalIndex(String stringConstant) {
	int index;
	char[] stringCharArray = stringConstant.toCharArray();
	if ((index = stringCache.putIfAbsent(stringCharArray, this.currentIndex)) < 0) {
		// The entry doesn't exit yet
		currentIndex++;
		if ((index  = -index)> 0xFFFF){
		if (index > 0xFFFF){
			this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
		}
		// Write the tag first
		writeU1(StringTag);
		// Then the string index
		int stringIndexOffset = this.currentOffset;
		if (currentOffset + 2 >= poolContent.length) {
			resizePoolContents(2);
}
/**
 * This method returns the index into the constantPool 
 * corresponding to the field binding aFieldBinding.
 *
 * @param aFieldBinding FieldBinding
 * @return <CODE>int</CODE>
 */
public int literalIndex(FieldBinding aFieldBinding) {
	int index;
	final char[] name = aFieldBinding.name;
	final char[] signature = aFieldBinding.type.signature();
	final char[] declaringClassConstantPoolName = aFieldBinding.declaringClass.constantPoolName();
	if ((index = getFromCache(declaringClassConstantPoolName, name, signature)) < 0) {
		// The entry doesn't exit yet
		int classIndex = literalIndexForType(declaringClassConstantPoolName);
		int nameAndTypeIndex = literalIndexForFields(literalIndex(name), literalIndex(signature), name, signature);
		index = putInCache(declaringClassConstantPoolName, name, signature, currentIndex++);
		if (index > 0xFFFF){
			this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
		}
		writeU1(FieldRefTag);
		writeU2(classIndex);
		writeU2(nameAndTypeIndex);
	}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding to the 
 * method descriptor. It can be either an interface method reference constant
 * or a method reference constant.
 * Note: uses the method binding #constantPoolDeclaringClass which could be an array type
 * for the array clone method (see UpdatedMethodDeclaration).
 * @param aMethodBinding MethodBinding
 * @return <CODE>int</CODE>
 */
public int literalIndex(MethodBinding aMethodBinding) {
	int index;
	final TypeBinding constantPoolDeclaringClass = aMethodBinding.constantPoolDeclaringClass();
	final char[] declaringClassConstantPoolName = constantPoolDeclaringClass.constantPoolName();
	final char[] selector = aMethodBinding.selector;
	final char[] signature = aMethodBinding.signature();
	if ((index = getFromCache(declaringClassConstantPoolName, selector, signature)) < 0) {
		int classIndex = literalIndexForType(constantPoolDeclaringClass.constantPoolName());
		int nameAndTypeIndex = literalIndexForMethods(literalIndex(selector), literalIndex(signature), selector, signature);
		index = putInCache(declaringClassConstantPoolName, selector, signature, currentIndex++);
		if (index > 0xFFFF){
			this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
		}
		currentOffset+=2;
		final int stringIndex = literalIndex(stringCharArray);
		poolContent[stringIndexOffset++] = (byte) (stringIndex >> 8);
		poolContent[stringIndexOffset] = (byte) stringIndex;
		writeU2(classIndex);
		// The write the nameAndType index
		writeU2(nameAndTypeIndex);
	}
	return index;
}

 */
public int literalIndexForType(final char[] constantPoolName) {
	int index;
	if ((index = classCache.putIfAbsent(constantPoolName, this.currentIndex)) < 0) {
		// The entry doesn't exit yet
		this.currentIndex++;
		if ((index = -index) > 0xFFFF){
		if (index > 0xFFFF){
			this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
		}
		writeU1(ClassTag);

		// Then the name index
		int nameIndexOffset = this.currentOffset;
		if (currentOffset + 2 >= poolContent.length) {
			resizePoolContents(2);
		}
		currentOffset+=2;
		final int nameIndex = literalIndex(constantPoolName);
		poolContent[nameIndexOffset++] = (byte) (nameIndex >> 8);
		poolContent[nameIndexOffset] = (byte) nameIndex;
	}
	return index;
}
public int literalIndexForMethod(char[] declaringClass, char[] selector, char[] signature, boolean isInterface) {
	int index;
	if ((index = putInCacheIfAbsent(declaringClass, selector, signature, this.currentIndex)) < 0) {
		// it doesn't exist yet
		this.currentIndex++;
		if ((index = -index) > 0xFFFF){
			int nameIndex = literalIndex(declaringClass);
			classIndex = classCache.put(declaringClass, this.currentIndex++);
			if (index > 0xFFFF){
				this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
			}
			writeU1(ClassTag);
			// Then add the 8 bytes representing the long
			writeU2(nameIndex);
		}
		int nameAndTypeIndex = literalIndexForMethod(selector, signature);
		index = putInCache(declaringClass, selector, signature, currentIndex++);
		if (index > 0xFFFF){
			this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
		}
		// Write the interface method ref constant into the constant pool
		// First add the tag
		writeU1(isInterface ? InterfaceMethodRefTag : MethodRefTag);

		int classIndexOffset = this.currentOffset;
		if (currentOffset + 4 >= poolContent.length) {
			resizePoolContents(4);
	}
	return index;
}
private int literalIndexForField(char[] name, char[] signature) {
	int index = getFromNameAndTypeCache(name, signature);
	if (index == -1) {
		// The entry doesn't exit yet
		int nameIndex = literalIndex(name);
		int typeIndex = literalIndex(signature);
		index = putInNameAndTypeCache(name, signature, currentIndex++);
		if (index > 0xFFFF){
			this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
		}
		currentOffset+=4;
		
		final int classIndex = literalIndexForType(declaringClass);
		final int nameAndTypeIndex = literalIndexForNameAndType(selector, signature);

		poolContent[classIndexOffset++] = (byte) (classIndex >> 8);
		poolContent[classIndexOffset++] = (byte) classIndex;
		poolContent[classIndexOffset++] = (byte) (nameAndTypeIndex >> 8);
		poolContent[classIndexOffset] = (byte) nameAndTypeIndex;
	}
	return index;
}
public int literalIndexForNameAndType(char[] name, char[] signature) {
	int index;
	if ((index = putInNameAndTypeCacheIfAbsent(name, signature, currentIndex)) < 0) {
		// The entry doesn't exit yet
		currentIndex++;
		if ((index = -index) > 0xFFFF){
		index = putInNameAndTypeCache(selector, signature, currentIndex++);
		if (index > 0xFFFF){
			this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
		}
		writeU1(NameAndTypeTag);
		int nameIndexOffset = this.currentOffset;
		if (currentOffset + 4 >= poolContent.length) {
			resizePoolContents(4);
		}
		currentOffset+=4;
		
		final int nameIndex = literalIndex(name);
		final int typeIndex = literalIndex(signature);
		poolContent[nameIndexOffset++] = (byte) (nameIndex >> 8);
		poolContent[nameIndexOffset++] = (byte) nameIndex;
		poolContent[nameIndexOffset++] = (byte) (typeIndex >> 8);
		poolContent[nameIndexOffset] = (byte) typeIndex;
	}
	return index;
}
public int literalIndexForField(char[] declaringClass, char[] name, char[] signature) {
	int index;
	if ((index = putInCacheIfAbsent(declaringClass, name, signature, this.currentIndex)) < 0) {
		this.currentIndex++;
		// doesn't exist yet
		if ((index = -index) > 0xFFFF){
			int nameIndex = literalIndex(declaringClass);
			classIndex = classCache.put(declaringClass, this.currentIndex++);
			if (index > 0xFFFF){
				this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
			}
			writeU1(ClassTag);
			// Then add the 8 bytes representing the long
			writeU2(nameIndex);
		}
		int nameAndTypeIndex = literalIndexForField(name, signature);
		index = putInCache(declaringClass, name, signature, currentIndex++);
		if (index > 0xFFFF){
			this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
		}
		// Write the interface method ref constant into the constant pool
		// First add the tag
		writeU1(FieldRefTag);
		int classIndexOffset = this.currentOffset;
		if (currentOffset + 4 >= poolContent.length) {
			resizePoolContents(4);
		writeU2(nameAndTypeIndex);		
	}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding 
 * nameAndType constant with nameIndex, typeIndex.
 *
 * @param nameIndex the given name index
 * @param typeIndex the given type index
 * @param name the given field name
 * @param signature the given field signature
 * @return the index into the constantPool corresponding 
 * nameAndType constant with nameIndex, typeInde
 */
private int literalIndexForFields(int nameIndex, int typeIndex, char[] name, char[] signature) {
	int index;
	if ((index = getFromNameAndTypeCache(name, signature)) == -1) {
		// The entry doesn't exit yet
		index = putInNameAndTypeCache(name, signature, currentIndex++);
		if (index > 0xFFFF){
			this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
		}
		currentOffset+=4;
		
		final int classIndex = literalIndexForType(declaringClass);
		final int nameAndTypeIndex = literalIndexForNameAndType(name, signature);

		poolContent[classIndexOffset++] = (byte) (classIndex >> 8);
		poolContent[classIndexOffset++] = (byte) classIndex;
		poolContent[classIndexOffset++] = (byte) (nameAndTypeIndex >> 8);
		poolContent[classIndexOffset] = (byte) nameAndTypeIndex;		
	}
	return index;
}

 */
public int literalIndexForLdc(char[] stringCharArray) {
	int index;
	if ((index = stringCache.putIfAbsent(stringCharArray, this.currentIndex)) < 0) {
		int stringIndex;
		// The entry doesn't exit yet
		this.currentIndex++;
		// Write the tag first
		writeU1(StringTag);
		
		// Then the string index
		int stringIndexOffset = this.currentOffset;
		if (currentOffset + 2 >= poolContent.length) {
			resizePoolContents(2);
		}
		currentOffset+=2;

		int stringIndex;
		if ((stringIndex = UTF8Cache.putIfAbsent(stringCharArray, this.currentIndex)) < 0) {
			// The entry doesn't exit yet
			this.currentIndex++;
			// Write the tag first
			writeU1(Utf8Tag);
			// Then the size of the stringName array

				char current = stringCharArray[i];
				if ((current >= 0x0001) && (current <= 0x007F)) {
					// we only need one byte: ASCII table
					writeU1(current);
					length++;
					if (currentOffset + 1 >= poolContent.length) {
						// we need to resize the poolContent array because we won't have
						// enough space to write the length
						resizePoolContents(1);
					}
					poolContent[currentOffset++] = (byte)(current);
				} else
					if (current > 0x07FF) {
						// we need 3 bytes
						length += 3;
						if (currentOffset + 3 >= poolContent.length) {
							// we need to resize the poolContent array because we won't have
							// enough space to write the length
							resizePoolContents(3);
						}
						poolContent[currentOffset++] = (byte) (0xE0 | ((current >> 12) & 0x0F)); // 0xE0 = 1110 0000
						poolContent[currentOffset++] = (byte) (0x80 | ((current >> 6) & 0x3F)); // 0x80 = 1000 0000
						poolContent[currentOffset++] = (byte) (0x80 | (current & 0x3F)); // 0x80 = 1000 0000
					} else {
						if (currentOffset + 2 >= poolContent.length) {
							// we need to resize the poolContent array because we won't have
							// enough space to write the length
							resizePoolContents(2);
						}
						// we can be 0 or between 0x0080 and 0x07FF
						// In that case we only need 2 bytes
						length += 2;
						poolContent[currentOffset++] = (byte) (0xC0 | ((current >> 6) & 0x1F)); // 0xC0 = 1100 0000
						poolContent[currentOffset++] = (byte) (0x80 | (current & 0x3F)); // 0x80 = 1000 0000
					}
			}
			if (length >= 65535) {
				currentOffset = savedCurrentOffset - 1;
				return 0;
			}
			stringIndex = UTF8Cache.put(stringCharArray, currentIndex++);
			// Now we know the length that we have to write in the constant pool
			// we use savedCurrentOffset to do that
			if (length > 65535) {
				return 0;
			}
			poolContent[savedCurrentOffset++] = (byte) (length >> 8);
			poolContent[savedCurrentOffset] = (byte) length;
			stringIndex = -stringIndex;
		index = stringCache.put(stringCharArray, currentIndex++);
		if (index > 0xFFFF){
			this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
		}
		if ((index = -index) > 0xFFFF){
		writeU1(StringTag);
		// Then the string index
		writeU2(stringIndex);
	}
	return index;
}
/**
 * This method returns the index into the constantPool corresponding 
 * nameAndType constant with nameIndex, typeIndex.
 *
 * @param nameIndex the given name index
 * @param typeIndex the given type index
 * @param selector the given method selector
 * @param signature the given method signature
 * @return <CODE>int</CODE>
 */
public int literalIndexForMethods(int nameIndex, int typeIndex, char[] selector, char[] signature) {
	int index;
	if ((index = getFromNameAndTypeCache(selector, signature)) == -1) {
		// The entry doesn't exit yet
		index = putInNameAndTypeCache(selector, signature, currentIndex++);
		if (index > 0xFFFF){
			this.classFile.referenceBinding.scope.problemReporter().noMoreAvailableSpaceInConstantPool(this.classFile.referenceBinding.scope.referenceType());
		}
		poolContent[stringIndexOffset++] = (byte) (stringIndex >> 8);
		poolContent[stringIndexOffset] = (byte) stringIndex;
		writeU2(typeIndex);
	}
	return index;
}
private int putInNameAndTypeCacheIfAbsent(final char[] key1, final char[] key2, int value) {
	int index ;
	CharArrayCache key1Value = (CharArrayCache) this.nameAndTypeCacheForFieldsAndMethods.get(key1);
	if (key1Value == null) {
		CharArrayCache charArrayCache = new CharArrayCache();
		index = charArrayCache.putIfAbsent(key2, value);
		this.nameAndTypeCacheForFieldsAndMethods.put(key1, charArrayCache);
	} else {
		index = key1Value.putIfAbsent(key2, value);
	}
	return index;
}

 * @param key1
 * @param key2
 * @param key3
 * @param value
 * @return the given index
 */
private int putInCacheIfAbsent(final char[] key1, final char[] key2, final char[] key3, int value) {
	int index;
	HashtableOfObject key1Value = (HashtableOfObject) this.methodsAndFieldsCache.get(key1);
	if (key1Value == null) {
		key1Value = new HashtableOfObject();
		this.methodsAndFieldsCache.put(key1, key1Value);
		CharArrayCache charArrayCache = new CharArrayCache();
		index = charArrayCache.putIfAbsent(key3, value);
		key1Value.put(key2, charArrayCache);
	} else {
		CharArrayCache charArrayCache = (CharArrayCache) key1Value.get(key2);
		if (charArrayCache == null) {
			charArrayCache = new CharArrayCache();
			index = charArrayCache.putIfAbsent(key3, value);
			key1Value.put(key2, charArrayCache);
		} else {
			index = charArrayCache.putIfAbsent(key3, value);			
		}
	}
	return index;

	if (currentOffset + 2 >= poolContent.length) {
		resizePoolContents(2);
	}
	poolContent[currentOffset++] = (byte) (value >>> 8);
	poolContent[currentOffset++] = (byte) (value >> 8);
	poolContent[currentOffset++] = (byte) value;
}
}




	}
	return false;
}
/**
 * Puts the specified element into the hashtable, using the specified
 * key.  The element may be retrieved by doing a get() with the same key.
 * 
 * @param key <CODE>double</CODE> the specified key in the hashtable
 * @param value <CODE>int</CODE> the specified element
 * @return int value
 */
public int put(double key, int value) {
	if (elementSize == keyTable.length) {
		// resize
		System.arraycopy(keyTable, 0, (keyTable = new double[elementSize * 2]), 0, elementSize);
		System.arraycopy(valueTable, 0, (valueTable = new int[elementSize * 2]), 0, elementSize);
	}
	keyTable[elementSize] = key;
	valueTable[elementSize] = value;
	elementSize++;
	return value;
}
/**
 * Puts the specified element into the hashtable, using the specified
 * key.  The element may be retrieved by doing a get() with the same key.
 * 
 * @param key <CODE>double</CODE> the specified key in the hashtable
 * @param value <CODE>int</CODE> the specified element
 * @return int value
 */
public int putIfAbsent(double key, int value) {
	if (key == 0.0) {
		for (int i = 0, max = elementSize; i < max; i++) {
			if (keyTable[i] == 0.0) {

			}
		}
	}
	return -1;
}
/**
 * Puts the specified element into the hashtable, using the specified
 * key.  The element may be retrieved by doing a get() with the same key.
 * 
 * @param key <CODE>double</CODE> the specified key in the hashtable
 * @param value <CODE>int</CODE> the specified element
 * @return int value
 */
public int put(double key, int value) {
	if (elementSize == keyTable.length) {
		// resize
		System.arraycopy(keyTable, 0, (keyTable = new double[elementSize * 2]), 0, elementSize);

	keyTable[elementSize] = key;
	valueTable[elementSize] = value;
	elementSize++;
	return -value; // negative when added, assumes value is > 0
}
/**
 * Converts to a rather lengthy String.




	}
	return false;
}
/**
 * Puts the specified element into the hashtable, using the specified
 * key.  The element may be retrieved by doing a get() with the same key.
 * 
 * @param key <CODE>float</CODE> the specified key in the hashtable
 * @param value <CODE>int</CODE> the specified element
 * @return int value
 */
public int put(float key, int value) {
	if (elementSize == keyTable.length) {
		// resize
		System.arraycopy(keyTable, 0, (keyTable = new float[elementSize * 2]), 0, elementSize);
		System.arraycopy(valueTable, 0, (valueTable = new int[elementSize * 2]), 0, elementSize);
	}
	keyTable[elementSize] = key;
	valueTable[elementSize] = value;
	elementSize++;
	return value;
}
/**
 * Puts the specified element into the hashtable, using the specified
 * key.  The element may be retrieved by doing a get() with the same key.
 * 
 * @param key <CODE>float</CODE> the specified key in the hashtable
 * @param value <CODE>int</CODE> the specified element
 * @return int value
 */
public int putIfAbsent(float key, int value) {
	if (key == 0.0f) {
		for (int i = 0, max = elementSize; i < max; i++) {
			if (keyTable[i] == 0.0f) {

			}
		}
	}
	return -1;
}
/**
 * Puts the specified element into the hashtable, using the specified
 * key.  The element may be retrieved by doing a get() with the same key.
 * 
 * @param key <CODE>float</CODE> the specified key in the hashtable
 * @param value <CODE>int</CODE> the specified element
 * @return int value
 */
public int put(float key, int value) {
	if (elementSize == keyTable.length) {
		// resize
		System.arraycopy(keyTable, 0, (keyTable = new float[elementSize * 2]), 0, elementSize);

	keyTable[elementSize] = key;
	valueTable[elementSize] = value;
	elementSize++;
	return -value; // negative when added, assumes value is > 0
}
/**
 * Converts to a rather lengthy String.




	}
	return false;
}
/** Gets the object associated with the specified key in the
 * hashtable.
 * @param key <CODE>double</CODE> the specified key
 * @return int the element for the key or -1 if the key is not
 *  defined in the hash table.
 */
public int get(int key) {
	int index = hash(key);
	while ((keyTable[index] != 0) || ((keyTable[index] == 0) &&(valueTable[index] != 0))) {
		if (keyTable[index] == key)
			return valueTable[index];
		index = (index + 1) % keyTable.length;
	}
	return -1;
}
/**
 * Return a hashcode for the value of the key parameter.
 * @param key int

	return value;
}
/**
 * Puts the specified element into the hashtable if absent, using the specified
 * key.  The element may be retrieved by doing a get() with the same key.
 * 
 * @param key <CODE>int</CODE> the specified key in the hashtable
 * @param value <CODE>int</CODE> the specified element
 * @return int value
 */
public int putIfAbsent(int key, int value) {
	int index = hash(key);
	while ((keyTable[index] != 0) || ((keyTable[index] == 0) && (valueTable[index] != 0))) {
		if (keyTable[index] == key)
			return valueTable[index];
		index = (index + 1) % keyTable.length;
	}
	keyTable[index] = key;
	valueTable[index] = value;

	// assumes the threshold is never equal to the size of the table
	if (++elementSize > threshold) {
		rehash();
	}
	return -value; // negative when added, assumes value is > 0
}
/**
 * Rehashes the content of the table into a bigger table.
 * This method is called automatically when the hashtable's
 * size exceeds the threshold.




	}
	return false;
}
/** Gets the object associated with the specified key in the
 * hashtable.
 * @param key <CODE>long</CODE> the specified key
 * @return int the element for the key or -1 if the key is not
 *  defined in the hash table.
 */
public int get(long key) {
	int index = hash(key);
	while ((keyTable[index] != 0) || ((keyTable[index] == 0) &&(valueTable[index] != 0))) {
		if (keyTable[index] == key)
			return valueTable[index];
		index = (index + 1) % keyTable.length;
	}
	return -1;
}
/**
 * Return a hashcode for the value of the key parameter.
 * @param key long

	return value;
}
/**
 * Puts the specified element into the hashtable, using the specified
 * key.  The element may be retrieved by doing a get() with the same key.
 * 
 * @param key <CODE>long</CODE> the specified key in the hashtable
 * @param value <CODE>int</CODE> the specified element
 * @return int value
 */
public int putIfAbsent(long key, int value) {
	int index = hash(key);
	while ((keyTable[index] != 0) || ((keyTable[index] == 0) && (valueTable[index] != 0))) {
		if (keyTable[index] == key)
			return valueTable[index];
		index = (index + 1) % keyTable.length;
	}
	keyTable[index] = key;
	valueTable[index] = value;

	// assumes the threshold is never equal to the size of the table
	if (++elementSize > threshold) {
		rehash();
	}
	return -value; // negative when added, assumes value is > 0
}
/**
 * Rehashes the content of the table into a bigger table.
 * This method is called automatically when the hashtable's
 * size exceeds the threshold.

Lines 2174-2180 Link Here

(-)model/org/eclipse/jdt/internal/core/util/Util.java (-1 lines)
2174	if (includeReturnType) {	2174	if (includeReturnType) {
2175	char[] rts = Signature.getReturnType(methodSignature);	2175	char[] rts = Signature.getReturnType(methodSignature);
2176	appendTypeSignature(rts, 0 , buffer, compact);	2176	appendTypeSignature(rts, 0 , buffer, compact);
2177	buffer.append(' ');
2178	}	2177	}
2179	}	2178	}
2180	return String.valueOf(buffer);	2179	return String.valueOf(buffer);

Return to bug 104704

Lines 77-91 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/codegen/CharArrayCache.java (-3 / +28 lines)
77	return -1;	77	return -1;
78	}	78	}
79	private int hashCodeChar(char[] val) {	79	private int hashCodeChar(char[] val) {
80	int length = val.length;	80	final int length = val.length;
81	int hash = 0;	81	int hash = 0;
82	int n = 2; // number of characters skipped	82	final int n = 3; // number of characters skipped
83	for (int i = 0; i < length; i += n) {	83	for (int i = 0; i < length; i += n) {
84	hash += val[i];	84	hash += val[i];
85	}	85	}
86	return (hash & 0x7FFFFFFF) % keyTable.length;	86	return (hash & 0x7FFFFFFF) % keyTable.length;
87	}	87	}
88	/**	88	/**
		89	* Puts the specified element into the hashtable if it wasn't there already,
		90	* using the specified key. The element may be retrieved by doing a get() with the same key.
		91	* The key and the element cannot be null.
		92	*
		93	* @param key the given key in the hashtable
		94	* @param value the given value
		95	* @return int the old value of the key, or -value if it did not have one.
		96	*/
		97	public int putIfAbsent(char[] key, int value) {
		98	int index = hashCodeChar(key);
		99	while (keyTable[index] != null) {
		100	if (CharOperation.equals(keyTable[index], key))
		101	return valueTable[index];
		102	index = (index + 1) % keyTable.length;
		103	}
		104	keyTable[index] = key;
		105	valueTable[index] = value;
		106
		107	// assumes the threshold is never equal to the size of the table
		108	if (++elementSize > threshold)
		109	rehash();
		110	return -value; // negative when added (value is assumed to be > 0)
		111	}
		112
		113	/**
89	* Puts the specified element into the hashtable, using the specified	114	* Puts the specified element into the hashtable, using the specified
90	* key. The element may be retrieved by doing a get() with the same key.	115	* key. The element may be retrieved by doing a get() with the same key.
91	* The key and the element cannot be null.	116	* The key and the element cannot be null.
Lines 94-100 Link Here
94	* @param value <CODE>int</CODE> the specified element	119	* @param value <CODE>int</CODE> the specified element
95	* @return int the old value of the key, or -1 if it did not have one.	120	* @return int the old value of the key, or -1 if it did not have one.
96	*/	121	*/
97	public int put(char[] key, int value) {	122	private int put(char[] key, int value) {
98	int index = hashCodeChar(key);	123	int index = hashCodeChar(key);
99	while (keyTable[index] != null) {	124	while (keyTable[index] != null) {
100	if (CharOperation.equals(keyTable[index], key))	125	if (CharOperation.equals(keyTable[index], key))

Lines 69-81 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/codegen/DoubleCache.java (-18 / +28 lines)
69	}	69	}
70	return false;	70	return false;
71	}	71	}
72	/** Gets the object associated with the specified key in the	72	/**
73	* hashtable.	73	* Puts the specified element into the hashtable, using the specified
74	* @param key <CODE>double</CODE> the specified key	74	* key. The element may be retrieved by doing a get() with the same key.
75	* @return int the element for the key or -1 if the key is not	75	*
76	* defined in the hash table.	76	* @param key <CODE>double</CODE> the specified key in the hashtable
		77	* @param value <CODE>int</CODE> the specified element
		78	* @return int value
77	*/	79	*/
78	public int get(double key) {	80	public int put(double key, int value) {
		81	if (elementSize == keyTable.length) {
		82	// resize
		83	System.arraycopy(keyTable, 0, (keyTable = new double[elementSize * 2]), 0, elementSize);
		84	System.arraycopy(valueTable, 0, (valueTable = new int[elementSize * 2]), 0, elementSize);
		85	}
		86	keyTable[elementSize] = key;
		87	valueTable[elementSize] = value;
		88	elementSize++;
		89	return value;
		90	}
		91	/**
		92	* Puts the specified element into the hashtable, using the specified
		93	* key. The element may be retrieved by doing a get() with the same key.
		94	*
		95	* @param key <CODE>double</CODE> the specified key in the hashtable
		96	* @param value <CODE>int</CODE> the specified element
		97	* @return int value
		98	*/
		99	public int putIfAbsent(double key, int value) {
79	if (key == 0.0) {	100	if (key == 0.0) {
80	for (int i = 0, max = elementSize; i < max; i++) {	101	for (int i = 0, max = elementSize; i < max; i++) {
81	if (keyTable[i] == 0.0) {	102	if (keyTable[i] == 0.0) {
Lines 94-110 Link Here
94	}	115	}
95	}	116	}
96	}	117	}
97	return -1;
98	}
99	/**
100	* Puts the specified element into the hashtable, using the specified
101	* key. The element may be retrieved by doing a get() with the same key.
102	*
103	* @param key <CODE>double</CODE> the specified key in the hashtable
104	* @param value <CODE>int</CODE> the specified element
105	* @return int value
106	*/
107	public int put(double key, int value) {
108	if (elementSize == keyTable.length) {	118	if (elementSize == keyTable.length) {
109	// resize	119	// resize
110	System.arraycopy(keyTable, 0, (keyTable = new double[elementSize * 2]), 0, elementSize);	120	System.arraycopy(keyTable, 0, (keyTable = new double[elementSize * 2]), 0, elementSize);
Lines 113-119 Link Here
113	keyTable[elementSize] = key;	123	keyTable[elementSize] = key;
114	valueTable[elementSize] = value;	124	valueTable[elementSize] = value;
115	elementSize++;	125	elementSize++;
116	return value;	126	return -value; // negative when added, assumes value is > 0
117	}	127	}
118	/**	128	/**
119	* Converts to a rather lengthy String.	129	* Converts to a rather lengthy String.