Attachment #112663 for bug #247292




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

public class CodeStream {
	public static final boolean DEBUG = false;

	// It will be responsible for the following items.
	// -> Tracking Max Stack.

	static LocalVariableBinding[] noLocals = new LocalVariableBinding[LOCALS_INCREMENT];
	static LocalVariableBinding[] noVisibleLocals = new LocalVariableBinding[LOCALS_INCREMENT];
	public static final CompilationResult RESTART_IN_WIDE_MODE = new CompilationResult((char[])null, 0, 0, 0);
	
	 * This methods searches for an existing entry inside the pcToSourceMap table with a pc equals to @pc.
	 * If there is an existing entry it returns -1 (no insertion required).
	 * Otherwise it returns the index where the entry for the pc has to be inserted.
	 * This is based on the fact that the pcToSourceMap table is sorted according to the pc.
	 *
	 * @param pcToSourceMap the given pcToSourceMap array
	 * @param length the given length
	 * @param pc the given pc
	 * @return int
	 */
	public static int insertionIndex(int[] pcToSourceMap, int length, int pc) {
		int g = 0;
		int d = length - 2;
		int m = 0;
		while (g <= d) {
			m = (g + d) / 2;
			// we search only on even indexes
			if ((m & 1) != 0) // faster than ((m % 2) != 0)
				m--;
			int currentPC = pcToSourceMap[m];
			if (pc < currentPC) {
				d = m - 2;
			} else
				if (pc > currentPC) {
					g = m + 2;
				} else {
					return -1;
				}
		}
		if (pc < pcToSourceMap[m])
			return m;
		return m + 2;
	}
	public static final void sort(int[] tab, int lo0, int hi0, int[] result) {
		int lo = lo0;
		int hi = hi0;
		int mid;
		if (hi0 > lo0) {
			/* Arbitrarily establishing partition element as the midpoint of
			  * the array.
			  */
			mid = tab[lo0 + (hi0 - lo0) / 2];
			// loop through the array until indices cross
			while (lo <= hi) {
				/* find the first element that is greater than or equal to
				 * the partition element starting from the left Index.
				 */
				while ((lo < hi0) && (tab[lo] < mid))
					++lo;
				/* find an element that is smaller than or equal to
				 * the partition element starting from the right Index.
				 */
				while ((hi > lo0) && (tab[hi] > mid))
					--hi;
				// if the indexes have not crossed, swap
				if (lo <= hi) {
					swap(tab, lo, hi, result);
					++lo;
					--hi;
				}
			}
			/* If the right index has not reached the left side of array
			  * must now sort the left partition.
			  */
			if (lo0 < hi)
				sort(tab, lo0, hi, result);
			/* If the left index has not reached the right side of array
			  * must now sort the right partition.
			  */
			if (lo < hi0)
				sort(tab, lo, hi0, result);
		}
	}
	private static final void swap(int a[], int i, int j, int result[]) {
		int T;
		T = a[i];
		a[i] = a[j];
		a[j] = T;
		T = result[j];
		result[j] = result[i];
		result[i] = T;
	}
	public int allLocalsCounter;
	public byte[] bCodeStream;
	public ClassFile classFile; // The current classfile it is associated to.

	public BranchLabel[] labels = new BranchLabel[LABELS_INCREMENT];
	public int lastEntryPC; // last entry recorded
	public int lastAbruptCompletion; // position of last instruction which abrupts completion: goto/return/athrow

	public int[] lineSeparatorPositions;
	// line number of the body start and the body end
	public int lineNumberStart;
	public int lineNumberEnd;

	public int lineNumberEnd;
	public LocalVariableBinding[] locals = new LocalVariableBinding[LOCALS_INCREMENT];
	public int maxFieldCount;

	public int maxLocals;
	public AbstractMethodDeclaration methodDeclaration;
	public int[] pcToSourceMap = new int[24];
	public int pcToSourceMapSize;
	public int position; // So when first set can be incremented
	public boolean preserveUnusedLocals;

	public int stackDepth; // Use Ints to keep from using extra bc when adding

	public int stackMax; // Use Ints to keep from using extra bc when adding
	public int startingClassFileOffset; // I need to keep the starting point inside the byte array

	// target level to manage different code generation between different target levels
	protected long targetLevel;

	public LocalVariableBinding[] visibleLocals = new LocalVariableBinding[LOCALS_INCREMENT];
		
	int visibleLocalsCount;
	
	// to handle goto_w
	public boolean wideMode = false;	
	
public CodeStream(ClassFile givenClassFile) {
	this.targetLevel = givenClassFile.targetJDK;
	this.generateAttributes = givenClassFile.produceAttributes;

		this.lineSeparatorPositions = givenClassFile.referenceBinding.scope.referenceCompilationUnit().compilationResult.getLineSeparatorPositions();
	}
}
/**
 * This methods searches for an existing entry inside the pcToSourceMap table with a pc equals to @pc.
 * If there is an existing entry it returns -1 (no insertion required).
 * Otherwise it returns the index where the entry for the pc has to be inserted.
 * This is based on the fact that the pcToSourceMap table is sorted according to the pc.
 *
 * @param pcToSourceMap the given pcToSourceMap array
 * @param length the given length
 * @param pc the given pc
 * @return int
 */
public static int insertionIndex(int[] pcToSourceMap, int length, int pc) {
	int g = 0;
	int d = length - 2;
	int m = 0;
	while (g <= d) {
		m = (g + d) / 2;
		// we search only on even indexes
		if ((m & 1) != 0) // faster than ((m % 2) != 0)
			m--;
		int currentPC = pcToSourceMap[m];
		if (pc < currentPC) {
			d = m - 2;
		} else
			if (pc > currentPC) {
				g = m + 2;
			} else {
				return -1;
			}
	}
	if (pc < pcToSourceMap[m])
		return m;
	return m + 2;
}
public static final void sort(int[] tab, int lo0, int hi0, int[] result) {
	int lo = lo0;
	int hi = hi0;
	int mid;
	if (hi0 > lo0) {
		/* Arbitrarily establishing partition element as the midpoint of
		  * the array.
		  */
		mid = tab[lo0 + (hi0 - lo0) / 2];
		// loop through the array until indices cross
		while (lo <= hi) {
			/* find the first element that is greater than or equal to
			 * the partition element starting from the left Index.
			 */
			while ((lo < hi0) && (tab[lo] < mid))
				++lo;
			/* find an element that is smaller than or equal to
			 * the partition element starting from the right Index.
			 */
			while ((hi > lo0) && (tab[hi] > mid))
				--hi;
			// if the indexes have not crossed, swap
			if (lo <= hi) {
				swap(tab, lo, hi, result);
				++lo;
				--hi;
			}
		}
		/* If the right index has not reached the left side of array
		  * must now sort the left partition.
		  */
		if (lo0 < hi)
			sort(tab, lo0, hi, result);
		/* If the left index has not reached the right side of array
		  * must now sort the right partition.
		  */
		if (lo < hi0)
			sort(tab, lo, hi0, result);
	}
}


private static final void swap(int a[], int i, int j, int result[]) {
	int T;
	T = a[i];
	a[i] = a[j];
	a[j] = T;
	T = result[j];
	result[j] = result[i];
	result[i] = T;
}

public void aaload() {
	if (DEBUG) System.out.println(this.position + "\t\taaload"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_aaload;
}

public void aastore() {
	if (DEBUG) System.out.println(this.position + "\t\taastore"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 3;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_aastore;
}

public void aconst_null() {
	if (DEBUG) System.out.println(this.position + "\t\taconst_null"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_aconst_null;
}

public void addDefinitelyAssignedVariables(Scope scope, int initStateIndex) {
	// Required to fix 1PR0XVS: LFRE:WINNT - Compiler: variable table for method appears incorrect
	if ((this.generateAttributes & (ClassFileConstants.ATTR_VARS

		}
	}
}

public void addLabel(BranchLabel aLabel) {
	if (this.countLabels == this.labels.length)
		System.arraycopy(this.labels, 0, this.labels = new BranchLabel[this.countLabels + LABELS_INCREMENT], 0, this.countLabels);
	this.labels[this.countLabels++] = aLabel;
}

public void addVariable(LocalVariableBinding localBinding) {
	/* do nothing */
}

public void addVisibleLocalVariable(LocalVariableBinding localBinding) {
	if ((this.generateAttributes & (ClassFileConstants.ATTR_VARS
			| ClassFileConstants.ATTR_STACK_MAP_TABLE

	this.visibleLocals[this.visibleLocalsCount++] = localBinding;
}

public void addVariable(LocalVariableBinding localBinding) {
	/* do nothing */
}
public void aload(int iArg) {
	if (DEBUG) System.out.println(this.position + "\t\taload:"+iArg); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax)

		this.bCodeStream[this.classFileOffset++] = (byte) iArg;
	}
}

public void aload_0() {
	if (DEBUG) System.out.println(this.position + "\t\taload_0"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_aload_0;
}

public void aload_1() {
	if (DEBUG) System.out.println(this.position + "\t\taload_1"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_aload_1;
}

public void aload_2() {
	if (DEBUG) System.out.println(this.position + "\t\taload_2"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_aload_2;
}

public void aload_3() {
	if (DEBUG) System.out.println(this.position + "\t\taload_3"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_aload_3;
}

public void anewarray(TypeBinding typeBinding) {
	if (DEBUG) System.out.println(this.position + "\t\tanewarray: " + typeBinding); //$NON-NLS-1$
	this.countLabels = 0;
	if (this.classFileOffset + 2 >= this.bCodeStream.length) {
		resizeByteArray();

	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_anewarray;
	writeUnsignedShort(this.constantPool.literalIndexForType(typeBinding));
}

public void areturn() {
	if (DEBUG) System.out.println(this.position + "\t\tareturn"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	// the stackDepth should be equal to 0

	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_areturn;
	this.lastAbruptCompletion = this.position;
}

public void arrayAt(int typeBindingID) {
	switch (typeBindingID) {
		case TypeIds.T_int :

			aaload();
	}
}

public void arrayAtPut(int elementTypeID, boolean valueRequired) {
	switch (elementTypeID) {
		case TypeIds.T_int :

			aastore();
	}
}

public void arraylength() {
	if (DEBUG) System.out.println(this.position + "\t\tarraylength"); //$NON-NLS-1$
	this.countLabels = 0;
	if (this.classFileOffset >= this.bCodeStream.length) {
		resizeByteArray();

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_arraylength;
}

public void astore(int iArg) {
	if (DEBUG) System.out.println(this.position + "\t\tastore:"+iArg); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.maxLocals <= iArg) {

		this.bCodeStream[this.classFileOffset++] = (byte) iArg;
	}
}

public void astore_0() {
	if (DEBUG) System.out.println(this.position + "\t\tastore_0"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.maxLocals == 0) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_astore_0;
}

public void astore_1() {
	if (DEBUG) System.out.println(this.position + "\t\tastore_1"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.maxLocals <= 1) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_astore_1;
}

public void astore_2() {
	if (DEBUG) System.out.println(this.position + "\t\tastore_2"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.maxLocals <= 2) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_astore_2;
}

public void astore_3() {
	if (DEBUG) System.out.println(this.position + "\t\tastore_3"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.maxLocals <= 3) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_astore_3;
}

public void athrow() {
	if (DEBUG) System.out.println(this.position + "\t\tathrow"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_athrow;
	this.lastAbruptCompletion = this.position;
}

public void baload() {
	if (DEBUG) System.out.println(this.position + "\t\tbaload"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_baload;
}

public void bastore() {
	if (DEBUG) System.out.println(this.position + "\t\tbastore"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 3;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_bastore;
}

public void bipush(byte b) {
	if (DEBUG) System.out.println(this.position + "\t\tbipush "+b); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax)

	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_bipush;
	this.bCodeStream[this.classFileOffset++] = b;
}

public void caload() {
	if (DEBUG) System.out.println(this.position + "\t\tcaload"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_caload;
}

public void castore() {
	if (DEBUG) System.out.println(this.position + "\t\tcastore"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 3;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_castore;
}

public void checkcast(int baseId) {
	this.countLabels = 0;
	if (this.classFileOffset + 2 >= this.bCodeStream.length) {

			writeUnsignedShort(this.constantPool.literalIndexForType(ConstantPool.JavaLangBooleanConstantPoolName));
	}
}

public void checkcast(TypeBinding typeBinding) {
	if (DEBUG) System.out.println(this.position + "\t\tcheckcast:"+typeBinding.debugName()); //$NON-NLS-1$
	this.countLabels = 0;
	if (this.classFileOffset + 2 >= this.bCodeStream.length) {
		resizeByteArray();

	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_checkcast;
	writeUnsignedShort(this.constantPool.literalIndexForType(typeBinding));
}

public void d2f() {
	if (DEBUG) System.out.println(this.position + "\t\td2f"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_d2f;
}

public void d2i() {
	if (DEBUG) System.out.println(this.position + "\t\td2i"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_d2i;
}

public void d2l() {
	if (DEBUG) System.out.println(this.position + "\t\td2l"); //$NON-NLS-1$
	this.countLabels = 0;
	if (this.classFileOffset >= this.bCodeStream.length) {
		resizeByteArray();

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_d2l;
}

public void dadd() {
	if (DEBUG) System.out.println(this.position + "\t\tdadd"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_dadd;
}

public void daload() {
	if (DEBUG) System.out.println(this.position + "\t\tdaload"); //$NON-NLS-1$
	this.countLabels = 0;
	if (this.classFileOffset >= this.bCodeStream.length) {
		resizeByteArray();

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_daload;
}

public void dastore() {
	if (DEBUG) System.out.println(this.position + "\t\tdastore"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 4;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_dastore;
}

public void dcmpg() {
	if (DEBUG) System.out.println(this.position + "\t\tdcmpg"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 3;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_dcmpg;
}

public void dcmpl() {
	if (DEBUG) System.out.println(this.position + "\t\tdcmpl"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 3;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_dcmpl;
}

public void dconst_0() {
	if (DEBUG) System.out.println(this.position + "\t\tdconst_0"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth += 2;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_dconst_0;
}

public void dconst_1() {
	if (DEBUG) System.out.println(this.position + "\t\tdconst_1"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth += 2;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_dconst_1;
}

public void ddiv() {
	if (DEBUG) System.out.println(this.position + "\t\tddiv"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_ddiv;
}

public void decrStackSize(int offset) {
	this.stackDepth -= offset;
}

public void dload(int iArg) {
	if (DEBUG) System.out.println(this.position + "\t\tdload:"+iArg); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth += 2;
	if (this.stackDepth > this.stackMax)

		this.bCodeStream[this.classFileOffset++] = (byte) iArg;
	}
}

public void dload_0() {
	if (DEBUG) System.out.println(this.position + "\t\tdload_0"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth += 2;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_dload_0;
}

public void dload_1() {
	if (DEBUG) System.out.println(this.position + "\t\tdload_1"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth += 2;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_dload_1;
}

public void dload_2() {
	if (DEBUG) System.out.println(this.position + "\t\tdload_2"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth += 2;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_dload_2;
}

public void dload_3() {
	if (DEBUG) System.out.println(this.position + "\t\tdload_3"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth += 2;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_dload_3;
}

public void dmul() {
	if (DEBUG) System.out.println(this.position + "\t\tdmul"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_dmul;
}

public void dneg() {
	if (DEBUG) System.out.println(this.position + "\t\tdneg"); //$NON-NLS-1$
	this.countLabels = 0;
	if (this.classFileOffset >= this.bCodeStream.length) {
		resizeByteArray();

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_dneg;
}

public void drem() {
	if (DEBUG) System.out.println(this.position + "\t\tdrem"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_drem;
}

public void dreturn() {
	if (DEBUG) System.out.println(this.position + "\t\tdreturn"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	// the stackDepth should be equal to 0

	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_dreturn;
	this.lastAbruptCompletion = this.position;
}

public void dstore(int iArg) {
	if (DEBUG) System.out.println(this.position + "\t\tdstore:"+iArg); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.maxLocals <= iArg + 1) {

		this.bCodeStream[this.classFileOffset++] = (byte) iArg;
	}
}

public void dstore_0() {
	if (DEBUG) System.out.println(this.position + "\t\tdstore_0"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.maxLocals < 2) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_dstore_0;
}

public void dstore_1() {
	if (DEBUG) System.out.println(this.position + "\t\tdstore_1"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.maxLocals < 3) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_dstore_1;
}

public void dstore_2() {
	if (DEBUG) System.out.println(this.position + "\t\tdstore_2"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.maxLocals < 4) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_dstore_2;
}

public void dstore_3() {
	if (DEBUG) System.out.println(this.position + "\t\tdstore_3"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.maxLocals < 5) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_dstore_3;
}

public void dsub() {
	if (DEBUG) System.out.println(this.position + "\t\tdsub"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_dsub;
}

public void dup() {
	if (DEBUG) System.out.println(this.position + "\t\tdup"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_dup;
}

public void dup_x1() {
	if (DEBUG) System.out.println(this.position + "\t\tdup_x1"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_dup_x1;
}

public void dup_x2() {
	if (DEBUG) System.out.println(this.position + "\t\tdup_x2"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_dup_x2;
}

public void dup2() {
	if (DEBUG) System.out.println(this.position + "\t\tdup2"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth += 2;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_dup2;
}

public void dup2_x1() {
	if (DEBUG) System.out.println(this.position + "\t\tdup2_x1"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth += 2;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_dup2_x1;
}

public void dup2_x2() {
	if (DEBUG) System.out.println(this.position + "\t\tdup2_x2"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth += 2;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_dup2_x2;
}

public void exitUserScope(BlockScope currentScope) {
	// mark all the scope's locals as losing their definite assignment

	if ((this.generateAttributes & (ClassFileConstants.ATTR_VARS
			| ClassFileConstants.ATTR_STACK_MAP_TABLE
			| ClassFileConstants.ATTR_STACK_MAP)) == 0)

		this.visibleLocals[index--] = null; // this variable is no longer visible afterwards
	}
}

public void exitUserScope(BlockScope currentScope, LocalVariableBinding binding) {
	// mark all the scope's locals as losing their definite assignment
	if ((this.generateAttributes & (ClassFileConstants.ATTR_VARS

		this.visibleLocals[index--] = null; // this variable is no longer visible afterwards
	}
}

public void f2d() {
	if (DEBUG) System.out.println(this.position + "\t\tf2d"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_f2d;
}

public void f2i() {
	if (DEBUG) System.out.println(this.position + "\t\tf2i"); //$NON-NLS-1$
	this.countLabels = 0;
	if (this.classFileOffset >= this.bCodeStream.length) {
		resizeByteArray();

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_f2i;
}

public void f2l() {
	if (DEBUG) System.out.println(this.position + "\t\tf2l"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_f2l;
}

public void fadd() {
	if (DEBUG) System.out.println(this.position + "\t\tfadd"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_fadd;
}

public void faload() {
	if (DEBUG) System.out.println(this.position + "\t\tfaload"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_faload;
}

public void fastore() {
	if (DEBUG) System.out.println(this.position + "\t\tfaload"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 3;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_fastore;
}

public void fcmpg() {
	if (DEBUG) System.out.println(this.position + "\t\tfcmpg"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_fcmpg;
}

public void fcmpl() {
	if (DEBUG) System.out.println(this.position + "\t\tfcmpl"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_fcmpl;
}

public void fconst_0() {
	if (DEBUG) System.out.println(this.position + "\t\tfconst_0"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_fconst_0;
}

public void fconst_1() {
	if (DEBUG) System.out.println(this.position + "\t\tfconst_1"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_fconst_1;
}

public void fconst_2() {
	if (DEBUG) System.out.println(this.position + "\t\tfconst_2"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_fconst_2;
}

public void fdiv() {
	if (DEBUG) System.out.println(this.position + "\t\tfdiv"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_fdiv;
}

public void fload(int iArg) {
	if (DEBUG) System.out.println(this.position + "\t\tfload:"+iArg); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.maxLocals <= iArg) {

		this.bCodeStream[this.classFileOffset++] = (byte) iArg;
	}
}

public void fload_0() {
	if (DEBUG) System.out.println(this.position + "\t\tfload_0"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.maxLocals == 0) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_fload_0;
}

public void fload_1() {
	if (DEBUG) System.out.println(this.position + "\t\tfload_1"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.maxLocals <= 1) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_fload_1;
}

public void fload_2() {
	if (DEBUG) System.out.println(this.position + "\t\tfload_2"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.maxLocals <= 2) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_fload_2;
}

public void fload_3() {
	if (DEBUG) System.out.println(this.position + "\t\tfload_3"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.maxLocals <= 3) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_fload_3;
}

public void fmul() {
	if (DEBUG) System.out.println(this.position + "\t\tfmul"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_fmul;
}

public void fneg() {
	if (DEBUG) System.out.println(this.position + "\t\tfneg"); //$NON-NLS-1$
	this.countLabels = 0;
	if (this.classFileOffset >= this.bCodeStream.length) {
		resizeByteArray();

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_fneg;
}

public void frem() {
	if (DEBUG) System.out.println(this.position + "\t\tfrem"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_frem;
}

public void freturn() {
	if (DEBUG) System.out.println(this.position + "\t\tfreturn"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	// the stackDepth should be equal to 0

	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_freturn;
	this.lastAbruptCompletion = this.position;
}

public void fstore(int iArg) {
	if (DEBUG) System.out.println(this.position + "\t\tfstore:"+iArg); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.maxLocals <= iArg) {

		this.bCodeStream[this.classFileOffset++] = (byte) iArg;
	}
}

public void fstore_0() {
	if (DEBUG) System.out.println(this.position + "\t\tfstore_0"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.maxLocals == 0) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_fstore_0;
}

public void fstore_1() {
	if (DEBUG) System.out.println(this.position + "\t\tfstore_1"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.maxLocals <= 1) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_fstore_1;
}

public void fstore_2() {
	if (DEBUG) System.out.println(this.position + "\t\tfstore_2"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.maxLocals <= 2) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_fstore_2;
}

public void fstore_3() {
	if (DEBUG) System.out.println(this.position + "\t\tfstore_3"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.maxLocals <= 3) {

}

public void fsub() {
	if (DEBUG) System.out.println(this.position + "\t\tfsub"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_fsub;
}

public void generateBoxingConversion(int unboxedTypeID) {
    switch (unboxedTypeID) {
        case TypeIds.T_byte :
            if (this.targetLevel >= ClassFileConstants.JDK1_5) {
    			if (DEBUG) System.out.println(this.position + "\t\tinvokestatic java.lang.Byte.valueOf(byte)"); //$NON-NLS-1$
               // invokestatic: Byte.valueOf(byte)
                invoke(
                    Opcodes.OPC_invokestatic,
                    1, // receiverAndArgsSize
                    1, // return type size
                    ConstantPool.JavaLangByteConstantPoolName,
                    ConstantPool.ValueOf,
                    ConstantPool.byteByteSignature);
            } else {
               // new Byte( byte )
    			if (DEBUG) System.out.println(this.position + "\t\tinvokespecial java.lang.Byte(byte)"); //$NON-NLS-1$
                newWrapperFor(unboxedTypeID);
                dup_x1();
                swap();
                invoke(
                    Opcodes.OPC_invokespecial,
                    2, // receiverAndArgsSize
                    0, // return type size
                    ConstantPool.JavaLangByteConstantPoolName,
                    ConstantPool.Init,

        case TypeIds.T_short :
            if ( this.targetLevel >= ClassFileConstants.JDK1_5 ) {
                // invokestatic: Short.valueOf(short)
    			if (DEBUG) System.out.println(this.position + "\t\tinvokestatic java.lang.Short.valueOf(short)"); //$NON-NLS-1$
                invoke(
                    Opcodes.OPC_invokestatic,
                    1, // receiverAndArgsSize
                    1, // return type size
                    ConstantPool.JavaLangShortConstantPoolName,
                    ConstantPool.ValueOf,
                    ConstantPool.shortShortSignature);
            } else {
                // new Short(short)
            	if (DEBUG) System.out.println(this.position + "\t\tinvokespecial java.lang.Short(short)"); //$NON-NLS-1$
            	newWrapperFor(unboxedTypeID);
                dup_x1();
                swap();
                invoke(
                    Opcodes.OPC_invokespecial,
                    2, // receiverAndArgsSize
                    0, // return type size
                    ConstantPool.JavaLangShortConstantPoolName,
                    ConstantPool.Init,

        case TypeIds.T_char :
            if ( this.targetLevel >= ClassFileConstants.JDK1_5 ) {
                // invokestatic: Character.valueOf(char)
            	if (DEBUG) System.out.println(this.position + "\t\tinvokestatic java.lang.Character.valueOf(char)"); //$NON-NLS-1$
                invoke(
                    Opcodes.OPC_invokestatic,
                    1, // receiverAndArgsSize
                    1, // return type size
                    ConstantPool.JavaLangCharacterConstantPoolName,
                    ConstantPool.ValueOf,
                    ConstantPool.charCharacterSignature);
            } else {
                // new Char( char )
            	if (DEBUG) System.out.println(this.position + "\t\tinvokespecial java.lang.Character(char)"); //$NON-NLS-1$
                newWrapperFor(unboxedTypeID);
                dup_x1();
                swap();
                invoke(
                    Opcodes.OPC_invokespecial,
                    2, // receiverAndArgsSize
                    0, // return type size
                    ConstantPool.JavaLangCharacterConstantPoolName,
                    ConstantPool.Init,

        case TypeIds.T_int :
            if (this.targetLevel >= ClassFileConstants.JDK1_5) {
                // invokestatic: Integer.valueOf(int)
            	if (DEBUG) System.out.println(this.position + "\t\tinvokestatic java.lang.Integer.valueOf(int)"); //$NON-NLS-1$
                invoke(
                    Opcodes.OPC_invokestatic,
                    1, // receiverAndArgsSize
                    1, // return type size
                    ConstantPool.JavaLangIntegerConstantPoolName,
                    ConstantPool.ValueOf,
                    ConstantPool.IntIntegerSignature);
            } else {
                // new Integer(int)
            	if (DEBUG) System.out.println(this.position + "\t\tinvokespecial java.lang.Integer(int)"); //$NON-NLS-1$
                newWrapperFor(unboxedTypeID);
                dup_x1();
                swap();
                invoke(
                    Opcodes.OPC_invokespecial,
                    2, // receiverAndArgsSize
                    0, // return type size
                    ConstantPool.JavaLangIntegerConstantPoolName,
                    ConstantPool.Init,

        case TypeIds.T_long :
            if (this.targetLevel >= ClassFileConstants.JDK1_5) {
                // invokestatic: Long.valueOf(long)
            	if (DEBUG) System.out.println(this.position + "\t\tinvokestatic java.lang.Long.valueOf(long)"); //$NON-NLS-1$
                invoke(
                    Opcodes.OPC_invokestatic,
                    2, // receiverAndArgsSize
                    1, // return type size
                    ConstantPool.JavaLangLongConstantPoolName,
                    ConstantPool.ValueOf,
                    ConstantPool.longLongSignature);
            } else {
                // new Long( long )
            	if (DEBUG) System.out.println(this.position + "\t\tinvokespecial java.lang.Long(long)"); //$NON-NLS-1$
                newWrapperFor(unboxedTypeID);
                dup_x2();
                dup_x2();
                pop();
                invoke(
                    Opcodes.OPC_invokespecial,
                    3, // receiverAndArgsSize
                    0, // return type size
                    ConstantPool.JavaLangLongConstantPoolName,
                    ConstantPool.Init,

        case TypeIds.T_float :
            if ( this.targetLevel >= ClassFileConstants.JDK1_5 ) {
                // invokestatic: Float.valueOf(float)
            	if (DEBUG) System.out.println(this.position + "\t\tinvokestatic java.lang.Float.valueOf(float)"); //$NON-NLS-1$
                invoke(
                    Opcodes.OPC_invokestatic,
                    1, // receiverAndArgsSize
                    1, // return type size
                    ConstantPool.JavaLangFloatConstantPoolName,
                    ConstantPool.ValueOf,
                    ConstantPool.floatFloatSignature);
            } else {
                // new Float(float)
            	if (DEBUG) System.out.println(this.position + "\t\tinvokespecial java.lang.Float(float)"); //$NON-NLS-1$
                newWrapperFor(unboxedTypeID);
                dup_x1();
                swap();
                invoke(
                    Opcodes.OPC_invokespecial,
                    2, // receiverAndArgsSize
                    0, // return type size
                    ConstantPool.JavaLangFloatConstantPoolName,
                    ConstantPool.Init,

        case TypeIds.T_double :
            if ( this.targetLevel >= ClassFileConstants.JDK1_5 ) {
                // invokestatic: Double.valueOf(double)
            	if (DEBUG) System.out.println(this.position + "\t\tinvokestatic java.lang.Double.valueOf(double)"); //$NON-NLS-1$
                invoke(
                    Opcodes.OPC_invokestatic,
                    3, // receiverAndArgsSize
                    1, // return type size
                    ConstantPool.JavaLangDoubleConstantPoolName,
                    ConstantPool.ValueOf,
                    ConstantPool.doubleDoubleSignature);
            } else {
                // new Double( double )
            	if (DEBUG) System.out.println(this.position + "\t\tinvokespecial java.lang.Double(double)"); //$NON-NLS-1$
            	newWrapperFor(unboxedTypeID);
                dup_x2();
                dup_x2();


                invoke(
                    Opcodes.OPC_invokespecial,
                    3, // receiverAndArgsSize
                    0, // return type size
                    ConstantPool.JavaLangDoubleConstantPoolName,
                    ConstantPool.Init,

        case TypeIds.T_boolean :
            if ( this.targetLevel >= ClassFileConstants.JDK1_5 ) {
                // invokestatic: Boolean.valueOf(boolean)
            	if (DEBUG) System.out.println(this.position + "\t\tinvokestatic java.lang.Boolean.valueOf(boolean)"); //$NON-NLS-1$
                invoke(
                    Opcodes.OPC_invokestatic,
                    1, // receiverAndArgsSize
                    1, // return type size
                    ConstantPool.JavaLangBooleanConstantPoolName,
                    ConstantPool.ValueOf,
                    ConstantPool.booleanBooleanSignature);
            } else {
                // new Boolean(boolean)
            	if (DEBUG) System.out.println(this.position + "\t\tinvokespecial java.lang.Boolean(boolean)"); //$NON-NLS-1$
                newWrapperFor(unboxedTypeID);
                dup_x1();
                swap();
                invoke(
                    Opcodes.OPC_invokespecial,
                    2, // receiverAndArgsSize
                    0, // return type size
                    ConstantPool.JavaLangBooleanConstantPoolName,
                    ConstantPool.Init,

            }
    }
}

/**
 * Macro for building a class descriptor object
 */

		getTYPE(accessedType.id);
		return;
	}

	if (this.targetLevel >= ClassFileConstants.JDK1_5) {
		// generation using the new ldc_w bytecode
		this.ldc(accessedType);

		this.stackDepth = savedStackDepth;
	}
}

/**
 * This method generates the code attribute bytecode
 */

	invokeJavaLangErrorConstructor();
	athrow();
}

public void generateConstant(Constant constant, int implicitConversionCode) {
	int targetTypeID = (implicitConversionCode & TypeIds.IMPLICIT_CONVERSION_MASK) >> 4;
	if (targetTypeID == 0) targetTypeID = constant.typeID(); // use default constant type

		generateBoxingConversion(targetTypeID);
	}
}

public void generateEmulatedReadAccessForField(FieldBinding fieldBinding) {
	generateEmulationForField(fieldBinding);
	// swap  the field with the receiver

		this.checkcast(fieldBinding.type);
	}
}

public void generateEmulatedWriteAccessForField(FieldBinding fieldBinding) {
	invokeJavaLangReflectFieldSetter(fieldBinding.type.id);
}

public void generateEmulationForConstructor(Scope scope, MethodBinding methodBinding) {
	// leave a java.lang.reflect.Field object on the stack
	this.ldc(String.valueOf(methodBinding.declaringClass.constantPoolName()).replace('/', '.'));

	iconst_1();
	invokeAccessibleObjectSetAccessible();
}

public void generateEmulationForField(FieldBinding fieldBinding) {
	// leave a java.lang.reflect.Field object on the stack
	this.ldc(String.valueOf(fieldBinding.declaringClass.constantPoolName()).replace('/', '.'));

	iconst_1();
	invokeAccessibleObjectSetAccessible();
}

public void generateEmulationForMethod(Scope scope, MethodBinding methodBinding) {
	// leave a java.lang.reflect.Field object on the stack
	this.ldc(String.valueOf(methodBinding.declaringClass.constantPoolName()).replace('/', '.'));

	iconst_1();
	invokeAccessibleObjectSetAccessible();
}

private void generateFieldAccess(byte opcode, int returnTypeSize, char[] declaringClass, char[] name, char[] signature) {
	this.countLabels = 0;
	switch(opcode) {

	this.bCodeStream[this.classFileOffset++] = opcode;
	writeUnsignedShort(this.constantPool.literalIndexForField(declaringClass, name, signature));
}

private void generateFieldAccess(byte opcode, int returnTypeSize, ReferenceBinding binding, char[] name, TypeBinding type) {
	if (binding.isNestedType()) {
		this.classFile.recordInnerClasses(binding);

	}
	this.generateFieldAccess(opcode, returnTypeSize, binding.constantPoolName(), name, type.signature());
}

/**
 * Generates the sequence of instructions which will perform the conversion of the expression
 * on the stack into a different type (e.g. long l = someInt; --> i2l must be inserted).

		generateBoxingConversion(typeId);
	}
}

public void generateInlinedValue(boolean inlinedValue) {
	if (inlinedValue)
		iconst_1();

			this.ldc(inlinedValue);
	}
}

public void generateInlinedValue(double inlinedValue) {
	if (inlinedValue == 0.0) {
		if (Double.doubleToLongBits(inlinedValue) != 0L)

	}
	this.ldc2_w(inlinedValue);
}

public void generateInlinedValue(float inlinedValue) {
	if (inlinedValue == 0.0f) {
		if (Float.floatToIntBits(inlinedValue) != 0)

	}
	this.ldc(inlinedValue);
}

public void generateInlinedValue(int inlinedValue) {
	switch (inlinedValue) {
		case -1 :

			this.ldc(inlinedValue);
	}
}

public void generateInlinedValue(long inlinedValue) {
	if (inlinedValue == 0) {
		lconst_0();

	}
	this.ldc2_w(inlinedValue);
}

public void generateInlinedValue(short inlinedValue) {
	switch (inlinedValue) {
		case -1 :

			sipush(inlinedValue);
	}
}

public void generateOuterAccess(Object[] mappingSequence, ASTNode invocationSite, Binding target, Scope scope) {
	if (mappingSequence == null) {
		if (target instanceof LocalVariableBinding) {

			FieldBinding fieldBinding = (FieldBinding) mappingSequence[i];
			getfield(fieldBinding);
		} else {
			invoke(Opcodes.OPC_invokestatic, (MethodBinding) mappingSequence[i], null /* default declaringClass */);
		}
	}
}
public void generateReturnBytecode(Expression expression) {

public void generateReturnBytecode(Expression expression) {
	if (expression == null) {
		return_();
	} else {

		}
	}
}

/**
 * The equivalent code performs a string conversion:
 *

	this.recordPositionsFrom(pc, oper2.sourceStart);
	invokeStringConcatenationToString();
}

/**
 * @param accessBinding the access method binding to generate
 */
public void generateSyntheticBodyForConstructorAccess(SyntheticMethodBinding accessBinding) {

	initializeMaxLocals(accessBinding);

	MethodBinding constructorBinding = accessBinding.targetMethod;
	TypeBinding[] parameters = constructorBinding.parameters;
	int length = parameters.length;

				resolvedPosition++;
		}
	}
	invoke(Opcodes.OPC_invokespecial, constructorBinding, null /* default declaringClass */);
	return_();
}

//static X valueOf(String name) {
// return (X) Enum.valueOf(X.class, name);
//}

	this.checkcast(declaringClass);
	areturn();
}

//static X[] values() {
// X[] values;
// int length;

	aload_2();
	areturn();
}

public void generateSyntheticBodyForFieldReadAccess(SyntheticMethodBinding accessBinding) {
	initializeMaxLocals(accessBinding);
	FieldBinding fieldBinding = accessBinding.targetReadField;

			areturn();
	}
}

public void generateSyntheticBodyForFieldWriteAccess(SyntheticMethodBinding accessBinding) {
	initializeMaxLocals(accessBinding);
	FieldBinding fieldBinding = accessBinding.targetWriteField;

	}
	return_();
}
public void generateSyntheticBodyForMethodAccess(SyntheticMethodBinding accessMethod) {

public void generateSyntheticBodyForMethodAccess(SyntheticMethodBinding accessMethod) {
	initializeMaxLocals(accessMethod);
	MethodBinding targetMethod = accessMethod.targetMethod;
	TypeBinding[] parameters = targetMethod.parameters;

			resolvedPosition++;
	}
	if (targetMethod.isStatic())
		invoke(Opcodes.OPC_invokestatic, targetMethod, null /* default declaringClass */);
	else {
		if (targetMethod.isConstructor()
			|| targetMethod.isPrivate()
			// qualified super "X.super.foo()" targets methods from superclass
			|| accessMethod.purpose == SyntheticMethodBinding.SuperMethodAccess){
			invoke(Opcodes.OPC_invokespecial, targetMethod, null /* default declaringClass */);
		} else {
			if (targetMethod.declaringClass.isInterface()) { // interface or annotation type
				invoke(Opcodes.OPC_invokeinterface, targetMethod, null /* default declaringClass */);
			} else {
				invoke(Opcodes.OPC_invokevirtual, targetMethod, accessMethod.declaringClass);
			}
		}
	}

			areturn();
	}
}

public void generateSyntheticBodyForSwitchTable(SyntheticMethodBinding methodBinding) {
	ClassScope scope = ((SourceTypeBinding)methodBinding.declaringClass).scope;
	initializeMaxLocals(methodBinding);
	final BranchLabel nullLabel = new BranchLabel(this);
	FieldBinding syntheticFieldBinding = methodBinding.targetReadField;

	getstatic(syntheticFieldBinding);
	dup();
	ifnull(nullLabel);

	areturn();
	removeVariable(localVariableBinding);
}

/**
 * Code responsible to generate the suitable code to supply values for the synthetic enclosing
 * instance arguments of a constructor invocation of a nested type.
 */
public void generateSyntheticEnclosingInstanceValues(BlockScope currentScope, ReferenceBinding targetType, Expression enclosingInstance, ASTNode invocationSite) {
		BlockScope currentScope,
		ReferenceBinding targetType,
		Expression enclosingInstance,
		ASTNode invocationSite) {

	// supplying enclosing instance for the anonymous type's superclass
	ReferenceBinding checkedTargetType = targetType.isAnonymousType() ? (ReferenceBinding)targetType.superclass().erasure() : targetType;
	boolean hasExtraEnclosingInstance = enclosingInstance != null;

		}
	}
}

/**
 * Code responsible to generate the suitable code to supply values for the synthetic outer local
 * variable arguments of a constructor invocation of a nested type.
 * (bug 26122) - synthetic values for outer locals must be passed after user arguments, e.g. new X(i = 1){}
 */
public void generateSyntheticOuterArgumentValues(BlockScope currentScope, ReferenceBinding targetType, ASTNode invocationSite) {

	// generate the synthetic outer arguments then
	SyntheticArgumentBinding syntheticArguments[];
	if ((syntheticArguments = targetType.syntheticOuterLocalVariables()) != null) {

		}
	}
}

public void generateUnboxingConversion(int unboxedTypeID) {
	switch (unboxedTypeID) {
		case TypeIds.T_byte :
			// invokevirtual: byteValue()
			invoke(
					Opcodes.OPC_invokevirtual,
					1, // receiverAndArgsSize
					1, // return type size
					ConstantPool.JavaLangByteConstantPoolName,
					ConstantPool.BYTEVALUE_BYTE_METHOD_NAME,

			// invokevirtual: shortValue()
			invoke(
					Opcodes.OPC_invokevirtual,
					1, // receiverAndArgsSize
					1, // return type size
					ConstantPool.JavaLangShortConstantPoolName,
					ConstantPool.SHORTVALUE_SHORT_METHOD_NAME,

			// invokevirtual: charValue()
			invoke(
					Opcodes.OPC_invokevirtual,
					1, // receiverAndArgsSize
					1, // return type size
					ConstantPool.JavaLangCharacterConstantPoolName,
					ConstantPool.CHARVALUE_CHARACTER_METHOD_NAME,

			// invokevirtual: intValue()
			invoke(
					Opcodes.OPC_invokevirtual,
					1, // receiverAndArgsSize
					1, // return type size
					ConstantPool.JavaLangIntegerConstantPoolName,
					ConstantPool.INTVALUE_INTEGER_METHOD_NAME,

			// invokevirtual: longValue()
			invoke(
					Opcodes.OPC_invokevirtual,
					1, // receiverAndArgsSize
					2, // return type size
					ConstantPool.JavaLangLongConstantPoolName,
					ConstantPool.LONGVALUE_LONG_METHOD_NAME,

			// invokevirtual: floatValue()
			invoke(
					Opcodes.OPC_invokevirtual,
					1, // receiverAndArgsSize
					1, // return type size
					ConstantPool.JavaLangFloatConstantPoolName,
					ConstantPool.FLOATVALUE_FLOAT_METHOD_NAME,

			// invokevirtual: doubleValue()
			invoke(
					Opcodes.OPC_invokevirtual,
					1, // receiverAndArgsSize
					2, // return type size
					ConstantPool.JavaLangDoubleConstantPoolName,
					ConstantPool.DOUBLEVALUE_DOUBLE_METHOD_NAME,

			// invokevirtual: booleanValue()
			invoke(
					Opcodes.OPC_invokevirtual,
					1, // receiverAndArgsSize
					1, // return type size
					ConstantPool.JavaLangBooleanConstantPoolName,
					ConstantPool.BOOLEANVALUE_BOOLEAN_METHOD_NAME,
					ConstantPool.BOOLEANVALUE_BOOLEAN_METHOD_SIGNATURE);
	}
}

/*
 * Wide conditional branch compare, improved by swapping comparison opcode
 *   ifeq WideTarget

		goto_w(wideTarget);
		intermediate.place();
}

public void getBaseTypeValue(int baseTypeID) {
	switch (baseTypeID) {
		case TypeIds.T_byte :
			// invokevirtual: byteValue()
			invoke(
					Opcodes.OPC_invokevirtual,
					1, // receiverAndArgsSize
					1, // return type size
					ConstantPool.JavaLangByteConstantPoolName,
					ConstantPool.BYTEVALUE_BYTE_METHOD_NAME,

			// invokevirtual: shortValue()
			invoke(
					Opcodes.OPC_invokevirtual,
					1, // receiverAndArgsSize
					1, // return type size
					ConstantPool.JavaLangShortConstantPoolName,
					ConstantPool.SHORTVALUE_SHORT_METHOD_NAME,

			// invokevirtual: charValue()
			invoke(
					Opcodes.OPC_invokevirtual,
					1, // receiverAndArgsSize
					1, // return type size
					ConstantPool.JavaLangCharacterConstantPoolName,
					ConstantPool.CHARVALUE_CHARACTER_METHOD_NAME,

			// invokevirtual: intValue()
			invoke(
					Opcodes.OPC_invokevirtual,
					1, // receiverAndArgsSize
					1, // return type size
					ConstantPool.JavaLangIntegerConstantPoolName,
					ConstantPool.INTVALUE_INTEGER_METHOD_NAME,

			// invokevirtual: longValue()
			invoke(
					Opcodes.OPC_invokevirtual,
					1, // receiverAndArgsSize
					2, // return type size
					ConstantPool.JavaLangLongConstantPoolName,
					ConstantPool.LONGVALUE_LONG_METHOD_NAME,

			// invokevirtual: floatValue()
			invoke(
					Opcodes.OPC_invokevirtual,
					1, // receiverAndArgsSize
					1, // return type size
					ConstantPool.JavaLangFloatConstantPoolName,
					ConstantPool.FLOATVALUE_FLOAT_METHOD_NAME,

			// invokevirtual: doubleValue()
			invoke(
					Opcodes.OPC_invokevirtual,
					1, // receiverAndArgsSize
					2, // return type size
					ConstantPool.JavaLangDoubleConstantPoolName,
					ConstantPool.DOUBLEVALUE_DOUBLE_METHOD_NAME,

			// invokevirtual: booleanValue()
			invoke(
					Opcodes.OPC_invokevirtual,
					1, // receiverAndArgsSize
					1, // return type size
					ConstantPool.JavaLangBooleanConstantPoolName,
					ConstantPool.BOOLEANVALUE_BOOLEAN_METHOD_NAME,
					ConstantPool.BOOLEANVALUE_BOOLEAN_METHOD_SIGNATURE);
	}
}

final public byte[] getContents() {
	byte[] contents;
	System.arraycopy(this.bCodeStream, 0, contents = new byte[this.position], 0, this.position);
	return contents;
}

public void getfield(FieldBinding fieldBinding) {
	if (DEBUG) System.out.println(this.position + "\t\tgetfield:"+fieldBinding); //$NON-NLS-1$
	int returnTypeSize = 1;
	if ((fieldBinding.type.id == TypeIds.T_double) || (fieldBinding.type.id == TypeIds.T_long)) {
		returnTypeSize = 2;

			fieldBinding.name,
			fieldBinding.type);
}

protected int getPosition() {
	return this.position;
}

public void getstatic(FieldBinding fieldBinding) {
	if (DEBUG) System.out.println(this.position + "\t\tgetstatic:"+fieldBinding); //$NON-NLS-1$
	int returnTypeSize = 1;
	if ((fieldBinding.type.id == TypeIds.T_double) || (fieldBinding.type.id == TypeIds.T_long)) {
		returnTypeSize = 2;

			fieldBinding.name,
			fieldBinding.type);
}

public void getTYPE(int baseTypeID) {
	this.countLabels = 0;
	switch (baseTypeID) {
		case TypeIds.T_byte :
			// getstatic: java.lang.Byte.TYPE
			if (DEBUG) System.out.println(this.position + "\t\tgetstatic: java.lang.Byte.TYPE"); //$NON-NLS-1$
			generateFieldAccess(
					Opcodes.OPC_getstatic,
					1,

			break;
		case TypeIds.T_short :
			// getstatic: java.lang.Short.TYPE
			if (DEBUG) System.out.println(this.position + "\t\tgetstatic: java.lang.Short.TYPE"); //$NON-NLS-1$
			generateFieldAccess(
					Opcodes.OPC_getstatic,
					1,

			break;
		case TypeIds.T_char :
			// getstatic: java.lang.Character.TYPE
			if (DEBUG) System.out.println(this.position + "\t\tgetstatic: java.lang.Character.TYPE"); //$NON-NLS-1$
			generateFieldAccess(
					Opcodes.OPC_getstatic,
					1,

			break;
		case TypeIds.T_int :
			// getstatic: java.lang.Integer.TYPE
			if (DEBUG) System.out.println(this.position + "\t\tgetstatic: java.lang.Integer.TYPE"); //$NON-NLS-1$
			generateFieldAccess(
					Opcodes.OPC_getstatic,
					1,

			break;
		case TypeIds.T_long :
			// getstatic: java.lang.Long.TYPE
			if (DEBUG) System.out.println(this.position + "\t\tgetstatic: java.lang.Long.TYPE"); //$NON-NLS-1$
			generateFieldAccess(
					Opcodes.OPC_getstatic,
					1,

			break;
		case TypeIds.T_float :
			// getstatic: java.lang.Float.TYPE
			if (DEBUG) System.out.println(this.position + "\t\tgetstatic: java.lang.Float.TYPE"); //$NON-NLS-1$
			generateFieldAccess(
					Opcodes.OPC_getstatic,
					1,

			break;
		case TypeIds.T_double :
			// getstatic: java.lang.Double.TYPE
			if (DEBUG) System.out.println(this.position + "\t\tgetstatic: java.lang.Double.TYPE"); //$NON-NLS-1$
			generateFieldAccess(
					Opcodes.OPC_getstatic,
					1,

			break;
		case TypeIds.T_boolean :
			// getstatic: java.lang.Boolean.TYPE
			if (DEBUG) System.out.println(this.position + "\t\tgetstatic: java.lang.Boolean.TYPE"); //$NON-NLS-1$
			generateFieldAccess(
					Opcodes.OPC_getstatic,
					1,

			break;
		case TypeIds.T_void :
			// getstatic: java.lang.Void.TYPE
			if (DEBUG) System.out.println(this.position + "\t\tgetstatic: java.lang.Void.TYPE"); //$NON-NLS-1$
			generateFieldAccess(
					Opcodes.OPC_getstatic,
					1,

			break;
	}
}

/**
 * We didn't call it goto, because there is a conflit with the goto keyword
 */

		goto_w(label);
		return;
	}
	if (DEBUG) System.out.println(this.position + "\t\tgoto:"+label); //$NON-NLS-1$
	if (this.classFileOffset >= this.bCodeStream.length) {
		resizeByteArray();
	}
	boolean chained = inlineForwardReferencesFromLabelsTargeting(label, this.position);
	if (DEBUG && chained) {
		if (DEBUG) {
			if (this.lastAbruptCompletion == this.position) {
				System.out.println("\t\t\t\t<branch chaining - goto eliminated : "+this.position+","+label+">");//$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$
			} else {
				System.out.println("\t\t\t\t<branch chaining - goto issued : "+this.position+","+label+">");//$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$
			}
		}
	}
	/*
	 Possible optimization for code such as:
	 public Object foo() {

	label.branch();
	this.lastAbruptCompletion = this.position;
}

public void goto_w(BranchLabel label) {
	if (DEBUG) System.out.println(this.position + "\t\tgotow:"+label); //$NON-NLS-1$
	if (this.classFileOffset >= this.bCodeStream.length) {
		resizeByteArray();
	}

	label.branchWide();
	this.lastAbruptCompletion = this.position;
}

public void i2b() {
	if (DEBUG) System.out.println(this.position + "\t\ti2b"); //$NON-NLS-1$
	this.countLabels = 0;
	if (this.classFileOffset >= this.bCodeStream.length) {
		resizeByteArray();

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_i2b;
}

public void i2c() {
	if (DEBUG) System.out.println(this.position + "\t\ti2c"); //$NON-NLS-1$
	this.countLabels = 0;
	if (this.classFileOffset >= this.bCodeStream.length) {
		resizeByteArray();

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_i2c;
}

public void i2d() {
	if (DEBUG) System.out.println(this.position + "\t\ti2d"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_i2d;
}

public void i2f() {
	if (DEBUG) System.out.println(this.position + "\t\ti2f"); //$NON-NLS-1$
	this.countLabels = 0;
	if (this.classFileOffset >= this.bCodeStream.length) {
		resizeByteArray();

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_i2f;
}

public void i2l() {
	if (DEBUG) System.out.println(this.position + "\t\ti2l"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_i2l;
}

public void i2s() {
	if (DEBUG) System.out.println(this.position + "\t\ti2s"); //$NON-NLS-1$
	this.countLabels = 0;
	if (this.classFileOffset >= this.bCodeStream.length) {
		resizeByteArray();

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_i2s;
}

public void iadd() {
	if (DEBUG) System.out.println(this.position + "\t\tiadd"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_iadd;
}

public void iaload() {
	if (DEBUG) System.out.println(this.position + "\t\tiaload"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_iaload;
}

public void iand() {
	if (DEBUG) System.out.println(this.position + "\t\tiand"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_iand;
}

public void iastore() {
	if (DEBUG) System.out.println(this.position + "\t\tiastore"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 3;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_iastore;
}

public void iconst_0() {
	if (DEBUG) System.out.println(this.position + "\t\ticonst_0"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_iconst_0;
}

public void iconst_1() {
	if (DEBUG) System.out.println(this.position + "\t\ticonst_1"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_iconst_1;
}

public void iconst_2() {
	if (DEBUG) System.out.println(this.position + "\t\ticonst_2"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax)

	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_iconst_2;
}
public void iconst_3() {
	if (DEBUG) System.out.println(this.position + "\t\ticonst_3"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_iconst_3;
}

public void iconst_4() {
	if (DEBUG) System.out.println(this.position + "\t\ticonst_4"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_iconst_4;
}

public void iconst_5() {
	if (DEBUG) System.out.println(this.position + "\t\ticonst_5"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_iconst_5;
}

public void iconst_m1() {
	if (DEBUG) System.out.println(this.position + "\t\ticonst_m1"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_iconst_m1;
}

public void idiv() {
	if (DEBUG) System.out.println(this.position + "\t\tidiv"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_idiv;
}

public void if_acmpeq(BranchLabel lbl) {
	if (DEBUG) System.out.println(this.position + "\t\tif_acmpeq:"+lbl); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth-=2;
	if (this.wideMode) {

		lbl.branch();
	}
}

public void if_acmpne(BranchLabel lbl) {
	if (DEBUG) System.out.println(this.position + "\t\tif_acmpne:"+lbl); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth-=2;
	if (this.wideMode) {

		lbl.branch();
	}
}

public void if_icmpeq(BranchLabel lbl) {
	if (DEBUG) System.out.println(this.position + "\t\tif_cmpeq:"+lbl); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.wideMode) {

		lbl.branch();
	}
}

public void if_icmpge(BranchLabel lbl) {
	if (DEBUG) System.out.println(this.position + "\t\tif_icmpge:"+lbl); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.wideMode) {

		lbl.branch();
	}
}

public void if_icmpgt(BranchLabel lbl) {
	if (DEBUG) System.out.println(this.position + "\t\tif_icmpgt:"+lbl); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.wideMode) {

		lbl.branch();
	}
}

public void if_icmple(BranchLabel lbl) {
	if (DEBUG) System.out.println(this.position + "\t\tif_icmple:"+lbl); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.wideMode) {

		lbl.branch();
	}
}

public void if_icmplt(BranchLabel lbl) {
	if (DEBUG) System.out.println(this.position + "\t\tif_icmplt:"+lbl); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.wideMode) {

		lbl.branch();
	}
}

public void if_icmpne(BranchLabel lbl) {
	if (DEBUG) System.out.println(this.position + "\t\tif_icmpne:"+lbl); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.wideMode) {

		lbl.branch();
	}
}

public void ifeq(BranchLabel lbl) {
	if (DEBUG) System.out.println(this.position + "\t\tifeq:"+lbl); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.wideMode) {

		lbl.branch();
	}
}

public void ifge(BranchLabel lbl) {
	if (DEBUG) System.out.println(this.position + "\t\tifge:"+lbl); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.wideMode) {

		lbl.branch();
	}
}

public void ifgt(BranchLabel lbl) {
	if (DEBUG) System.out.println(this.position + "\t\tifgt:"+lbl); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.wideMode) {

		lbl.branch();
	}
}

public void ifle(BranchLabel lbl) {
	if (DEBUG) System.out.println(this.position + "\t\tifle:"+lbl); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.wideMode) {

		lbl.branch();
	}
}

public void iflt(BranchLabel lbl) {
	if (DEBUG) System.out.println(this.position + "\t\tiflt:"+lbl); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.wideMode) {

		lbl.branch();
	}
}

public void ifne(BranchLabel lbl) {
	if (DEBUG) System.out.println(this.position + "\t\tifne:"+lbl); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.wideMode) {

		lbl.branch();
	}
}

public void ifnonnull(BranchLabel lbl) {
	if (DEBUG) System.out.println(this.position + "\t\tifnonnull:"+lbl); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.wideMode) {

		lbl.branch();
	}
}

public void ifnull(BranchLabel lbl) {
	if (DEBUG) System.out.println(this.position + "\t\tifnull:"+lbl); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.wideMode) {

		lbl.branch();
	}
}

final public void iinc(int index, int value) {
	if (DEBUG) System.out.println(this.position + "\t\tiinc:"+index+","+value); //$NON-NLS-1$ //$NON-NLS-2$
	this.countLabels = 0;
	if ((index > 255) || (value < -128 || value > 127)) { // have to widen
		if (this.classFileOffset + 3 >= this.bCodeStream.length) {

		this.bCodeStream[this.classFileOffset++] = (byte) value;
	}
}

public void iload(int iArg) {
	if (DEBUG) System.out.println(this.position + "\t\tiload:"+iArg); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.maxLocals <= iArg) {

		this.bCodeStream[this.classFileOffset++] = (byte) iArg;
	}
}

public void iload_0() {
	if (DEBUG) System.out.println(this.position + "\t\tiload_0"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.maxLocals <= 0) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_iload_0;
}

public void iload_1() {
	if (DEBUG) System.out.println(this.position + "\t\tiload_1"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.maxLocals <= 1) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_iload_1;
}

public void iload_2() {
	if (DEBUG) System.out.println(this.position + "\t\tiload_2"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.maxLocals <= 2) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_iload_2;
}

public void iload_3() {
	if (DEBUG) System.out.println(this.position + "\t\tiload_3"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.maxLocals <= 3) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_iload_3;
}

public void imul() {
	if (DEBUG) System.out.println(this.position + "\t\timul"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_imul;
}

public int indexOfSameLineEntrySincePC(int pc, int line) {
	for (int index = pc, max = this.pcToSourceMapSize; index < max; index+=2) {
		if (this.pcToSourceMap[index+1] == line)

	}
	return -1;
}

public void ineg() {
	if (DEBUG) System.out.println(this.position + "\t\tineg"); //$NON-NLS-1$
	this.countLabels = 0;
	if (this.classFileOffset >= this.bCodeStream.length) {
		resizeByteArray();

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_ineg;
}

 * Some placed labels might be branching to a goto bytecode which we can optimize better.
 */
public boolean inlineForwardReferencesFromLabelsTargeting(BranchLabel targetLabel, int gotoLocation) {
	if (targetLabel.delegate != null) return false; // already inlined
	int chaining = L_UNKNOWN;
	for (int i = this.countLabels - 1; i >= 0; i--) {
		BranchLabel currentLabel = this.labels[i];
		if (currentLabel.position != gotoLocation) break;
		if (currentLabel == targetLabel) {
			chaining |= L_CANNOT_OPTIMIZE; // recursive
			continue;
		}
		if (currentLabel.isStandardLabel()) {
			if (currentLabel.delegate != null) continue; // ignore since already inlined
			targetLabel.becomeDelegateFor(currentLabel);
			chaining |= L_OPTIMIZABLE; // optimizable, providing no vetoing
			continue;
		}
		// case label
		chaining |= L_CANNOT_OPTIMIZE;
	}
	return (chaining & (L_OPTIMIZABLE|L_CANNOT_OPTIMIZE)) == L_OPTIMIZABLE; // check was some standards, and no case/recursive
}
public void init(ClassFile targetClassFile) {
	this.classFile = targetClassFile;
	this.constantPool = targetClassFile.constantPool;

	this.maxLocals = 0;
	this.position = 0;
}

/**
 * @param methodBinding the given method binding to initialize the max locals
 */
public void initializeMaxLocals(MethodBinding methodBinding) {

	if (methodBinding == null) {
		this.maxLocals = 0;
		return;
	}

	this.maxLocals = methodBinding.isStatic() ? 0 : 1;

	// take into account enum constructor synthetic name+ordinal

		}
	}
}

/**
 * Some placed labels might be branching to a goto bytecode which we can optimize better.
 * instanceof keyword
 */
public boolean inlineForwardReferencesFromLabelsTargeting(BranchLabel targetLabel, int gotoLocation) {
	if (targetLabel.delegate != null) return false; // already inlined
	int chaining = L_UNKNOWN;
	for (int i = this.countLabels - 1; i >= 0; i--) {
		BranchLabel currentLabel = this.labels[i];
		if (currentLabel.position != gotoLocation) break;
		if (currentLabel == targetLabel) {
			chaining |= L_CANNOT_OPTIMIZE; // recursive
			continue;
		}
		if (currentLabel.isStandardLabel()) {
			if (currentLabel.delegate != null) continue; // ignore since already inlined
			targetLabel.becomeDelegateFor(currentLabel);
			chaining |= L_OPTIMIZABLE; // optimizable, providing no vetoing
			continue;
		}
		// case label
		chaining |= L_CANNOT_OPTIMIZE;
	}
	return (chaining & (L_OPTIMIZABLE|L_CANNOT_OPTIMIZE)) == L_OPTIMIZABLE; // check was some standards, and no case/recursive
}

/**
 * We didn't call it instanceof because there is a conflit with the
 * instanceof keyword
 */
public void instance_of(TypeBinding typeBinding) {
	this.countLabels = 0;
	if (this.classFileOffset + 2 >= this.bCodeStream.length) {
		resizeByteArray();
		case Opcodes.OPC_invokeinterface :
			if (this.classFileOffset + 4 >= this.bCodeStream.length) {
				resizeByteArray();
			}
			this.position +=3;
			this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_invokeinterface;
			writeUnsignedShort(this.constantPool.literalIndexForMethod(declaringClass, selector, signature, true));
			argCount++;
			this.bCodeStream[this.classFileOffset++] = (byte) argCount;
			this.bCodeStream[this.classFileOffset++] = 0;
			break;
		case Opcodes.OPC_invokevirtual :
		case Opcodes.OPC_invokespecial :
			if (this.classFileOffset + 2 >= this.bCodeStream.length) {
				resizeByteArray();
			}
			this.position++;
			this.bCodeStream[this.classFileOffset++] = (byte) opcode;
			writeUnsignedShort(this.constantPool.literalIndexForMethod(declaringClass, selector, signature, false));
			argCount++;
			break;
		case Opcodes.OPC_invokestatic :
			if (this.classFileOffset + 2 >= this.bCodeStream.length) {
				resizeByteArray();
			}
			this.position++;
			this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_invokestatic;
			writeUnsignedShort(this.constantPool.literalIndexForMethod(declaringClass, selector, signature, false));
	}
	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_instanceof;
	writeUnsignedShort(this.constantPool.literalIndexForType(typeBinding));
}

public void invoke(byte opcode, MethodBinding methodBinding, TypeBinding declaringClass) {
	if (declaringClass == null) declaringClass = methodBinding.declaringClass;
    if (declaringClass.isNestedType()) {
        this.classFile.recordInnerClasses(declaringClass);
    }
    // compute receiverAndArgsSize
    int receiverAndArgsSize;
    switch(opcode) {
    	case Opcodes.OPC_invokestatic :
    		receiverAndArgsSize = 0; // no receiver
    		break;
    	case Opcodes.OPC_invokeinterface :
    	case Opcodes.OPC_invokevirtual :
    		receiverAndArgsSize = 1; // receiver
    		break;
    	case Opcodes.OPC_invokespecial :
    		receiverAndArgsSize = 1; // receiver
    		if (methodBinding.isConstructor()) {
    			if (declaringClass.isNestedType()) {
        			ReferenceBinding nestedType = (ReferenceBinding) declaringClass;
    				// enclosing instances
    				TypeBinding[] syntheticArgumentTypes = nestedType.syntheticEnclosingInstanceTypes();
    				if (syntheticArgumentTypes != null) {
    					for (int i = 0, max = syntheticArgumentTypes.length; i < max; i++) {
    						switch (syntheticArgumentTypes[i].id)  {
    							case TypeIds.T_double :
    							case TypeIds.T_long :
	    							receiverAndArgsSize += 2;
									break;
    							default: 
	    							receiverAndArgsSize++;
    								break;
    						}
    					}
    				}
    				// outer local variables
    				SyntheticArgumentBinding[] syntheticArguments = nestedType.syntheticOuterLocalVariables();
    				if (syntheticArguments != null) {
    					for (int i = 0, max = syntheticArguments.length; i < max; i++) {
    						switch (syntheticArguments[i].id)  {
    							case TypeIds.T_double :
    							case TypeIds.T_long :
	    							receiverAndArgsSize += 2;
									break;
    							default: 
	    							receiverAndArgsSize++;
    								break;
    						}    						
    					}
    				}
    			}
    			if (declaringClass.isEnum()) {
    				// adding String (name) and int (ordinal)
    				receiverAndArgsSize += 2;
    			}
    		}    		
    		break;
    	default :
    		return; // should not occur
    		
    }
	for (int i = methodBinding.parameters.length - 1; i >= 0; i--) {
		switch (methodBinding.parameters[i].id) {
			case TypeIds.T_double :
			case TypeIds.T_long :
				receiverAndArgsSize += 2;
				break;
			default :
				receiverAndArgsSize ++;
				break;
		}
	}
	// compute return type size
	int returnTypeSize;
	switch (methodBinding.returnType.id) {
		case TypeIds.T_double :
		case TypeIds.T_long :
			returnTypeSize = 2;
			break;
		case TypeIds.T_void :
			returnTypeSize = 0;
			break;
		default :
			returnTypeSize = 1;
			break;
	}
	invoke(
			opcode, 
			receiverAndArgsSize, 
			returnTypeSize, 
			declaringClass.constantPoolName(), 
			methodBinding.selector, 
			methodBinding.signature(this.classFile));
}

protected void invoke(byte opcode, int receiverAndArgsSize, int returnTypeSize, char[] declaringClass, char[] selector, char[] signature) {
	this.countLabels = 0;
	if (opcode == Opcodes.OPC_invokeinterface) {
		// invokeinterface
		if (this.classFileOffset + 4 >= this.bCodeStream.length) {
			resizeByteArray();
		}
		this.position +=3;
		this.bCodeStream[this.classFileOffset++] = opcode;
		writeUnsignedShort(this.constantPool.literalIndexForMethod(declaringClass, selector, signature, true));
		this.bCodeStream[this.classFileOffset++] = (byte) receiverAndArgsSize;
		this.bCodeStream[this.classFileOffset++] = 0;
	} else {
		// invokespecial
		// invokestatic
		// invokevirtual
		if (this.classFileOffset + 2 >= this.bCodeStream.length) {
			resizeByteArray();
		}
		this.position++;
		this.bCodeStream[this.classFileOffset++] = opcode;
		writeUnsignedShort(this.constantPool.literalIndexForMethod(declaringClass, selector, signature, false));
	}
	this.stackDepth += returnTypeSize - receiverAndArgsSize;
	if (this.stackDepth > this.stackMax) {
		this.stackMax = this.stackDepth;
	}
}

protected void invokeAccessibleObjectSetAccessible() {
	// invokevirtual: java.lang.reflect.AccessibleObject.setAccessible(Z)V;
	invoke(
			Opcodes.OPC_invokevirtual,
			2, // receiverAndArgsSize
			0, // return type size
			ConstantPool.JAVALANGREFLECTACCESSIBLEOBJECT_CONSTANTPOOLNAME,
			ConstantPool.SETACCESSIBLE_NAME,
			ConstantPool.SETACCESSIBLE_SIGNATURE);
}

protected void invokeArrayNewInstance() {
	// invokestatic: java.lang.reflect.Array.newInstance(Ljava.lang.Class;int[])Ljava.lang.Object;
	invoke(
			Opcodes.OPC_invokestatic,
			2, // receiverAndArgsSize
			1, // return type size
			ConstantPool.JAVALANGREFLECTARRAY_CONSTANTPOOLNAME,
			ConstantPool.NewInstance,

}
public void invokeClassForName() {
	// invokestatic: java.lang.Class.forName(Ljava.lang.String;)Ljava.lang.Class;
	if (DEBUG) System.out.println(this.position + "\t\tinvokestatic: java.lang.Class.forName(Ljava.lang.String;)Ljava.lang.Class;"); //$NON-NLS-1$
	invoke(
		Opcodes.OPC_invokestatic,
		1, // receiverAndArgsSize
		1, // return type size
		ConstantPool.JavaLangClassConstantPoolName,
		ConstantPool.ForName,
		ConstantPool.ForNameSignature);
}

protected void invokeClassGetDeclaredConstructor() {
	// invokevirtual: java.lang.Class getDeclaredConstructor([Ljava.lang.Class)Ljava.lang.reflect.Constructor;
	invoke(
			Opcodes.OPC_invokevirtual,
			2, // receiverAndArgsSize
			1, // return type size
			ConstantPool.JavaLangClassConstantPoolName,
			ConstantPool.GETDECLAREDCONSTRUCTOR_NAME,
			ConstantPool.GETDECLAREDCONSTRUCTOR_SIGNATURE);
}

protected void invokeClassGetDeclaredField() {
	// invokevirtual: java.lang.Class.getDeclaredField(Ljava.lang.String)Ljava.lang.reflect.Field;
	invoke(
			Opcodes.OPC_invokevirtual,
			2, // receiverAndArgsSize
			1, // return type size
			ConstantPool.JavaLangClassConstantPoolName,
			ConstantPool.GETDECLAREDFIELD_NAME,
			ConstantPool.GETDECLAREDFIELD_SIGNATURE);
}

protected void invokeClassGetDeclaredMethod() {
	// invokevirtual: java.lang.Class getDeclaredMethod(Ljava.lang.String, [Ljava.lang.Class)Ljava.lang.reflect.Method;
	invoke(
			Opcodes.OPC_invokevirtual,
			3, // receiverAndArgsSize
			1, // return type size
			ConstantPool.JavaLangClassConstantPoolName,
			ConstantPool.GETDECLAREDMETHOD_NAME,
			ConstantPool.GETDECLAREDMETHOD_SIGNATURE);
}

public void invokeEnumOrdinal(char[] enumTypeConstantPoolName) {
	// invokevirtual: <enumConstantPoolName>.ordinal()
	if (DEBUG) System.out.println(this.position + "\t\tinvokevirtual: "+new String(enumTypeConstantPoolName)+".ordinal()"); //$NON-NLS-1$ //$NON-NLS-2$
	invoke(
			Opcodes.OPC_invokevirtual,
			1, // receiverAndArgsSize
			1, // return type size
			enumTypeConstantPoolName,
			ConstantPool.Ordinal,
			ConstantPool.OrdinalSignature);
}

public void invokeIterableIterator(TypeBinding iterableReceiverType) {
	// invokevirtual/interface: <iterableReceiverType>.iterator()
    if (iterableReceiverType.isNestedType()) {
        this.classFile.recordInnerClasses(iterableReceiverType);
    }	
	invoke(
			iterableReceiverType.isInterface() ? Opcodes.OPC_invokeinterface : Opcodes.OPC_invokevirtual,
			1, // receiverAndArgsSize
			1, // returnTypeSize
			iterableReceiverType.constantPoolName(), 
			ConstantPool.ITERATOR_NAME, 
			ConstantPool.ITERATOR_SIGNATURE);
			methodBinding.constantPoolDeclaringClass(),
			methodBinding.selector,
			methodBinding.signature(this.classFile),
			true));
	for (int i = methodBinding.parameters.length - 1; i >= 0; i--)
		if (((id = methodBinding.parameters[i].id) == TypeIds.T_double) || (id == TypeIds.T_long))
			argCount += 2;
		else
			argCount += 1;
	this.bCodeStream[this.classFileOffset++] = (byte) argCount;
	// Generate a  0 into the byte array. Like the array is already fill with 0, we just need to increment
	// the number of bytes.
	this.bCodeStream[this.classFileOffset++] = 0;
	if (((id = methodBinding.returnType.id) == TypeIds.T_double) || (id == TypeIds.T_long)) {
		this.stackDepth += (2 - argCount);
	} else {
		if (id == TypeIds.T_void) {
			this.stackDepth -= argCount;
		} else {
			this.stackDepth += (1 - argCount);
		}
	}
	if (this.stackDepth > this.stackMax) {
		this.stackMax = this.stackDepth;
	}
}

public void invokeJavaLangAssertionErrorConstructor(int typeBindingID) {
	// invokespecial: java.lang.AssertionError.<init>(typeBindingID)V
	int receiverAndArgsSize;
	char[] signature;
	char[] signature = null;
	switch (typeBindingID) {
		case TypeIds.T_int :
		case TypeIds.T_byte :
		case TypeIds.T_short :
			signature = ConstantPool.IntConstrSignature;
			receiverAndArgsSize = 2;
			break;
		case TypeIds.T_long :
			signature = ConstantPool.LongConstrSignature;
			receiverAndArgsSize = 3;
			break;
		case TypeIds.T_float :
			signature = ConstantPool.FloatConstrSignature;
			receiverAndArgsSize = 2;
			break;
		case TypeIds.T_double :
			signature = ConstantPool.DoubleConstrSignature;
			receiverAndArgsSize = 3;
			break;
		case TypeIds.T_char :
			signature = ConstantPool.CharConstrSignature;
			receiverAndArgsSize = 2;
			break;
		case TypeIds.T_boolean :
			signature = ConstantPool.BooleanConstrSignature;
			receiverAndArgsSize = 2;
			break;
		case TypeIds.T_JavaLangObject :
		case TypeIds.T_JavaLangString :
		case TypeIds.T_null :
			signature = ConstantPool.ObjectConstrSignature;
			receiverAndArgsSize = 2;
			break;
		default:
			return; // should not occur
	}
	invoke(
			Opcodes.OPC_invokespecial,
			receiverAndArgsSize,
			0, // return type size
			ConstantPool.JavaLangAssertionErrorConstantPoolName,
			ConstantPool.Init,
			signature);
}

public void invokeJavaLangAssertionErrorDefaultConstructor() {
	// invokespecial: java.lang.AssertionError.<init>()V
	if (DEBUG) System.out.println(this.position + "\t\tinvokespecial: java.lang.AssertionError.<init>()V"); //$NON-NLS-1$
	invoke(
			Opcodes.OPC_invokespecial,
			1, // receiverAndArgsSize
			0, // return type size
			ConstantPool.JavaLangAssertionErrorConstantPoolName,
			ConstantPool.Init,
			ConstantPool.DefaultConstructorSignature);
}

public void invokeJavaLangClassDesiredAssertionStatus() {
	// invokevirtual: java.lang.Class.desiredAssertionStatus()Z;
	if (DEBUG) System.out.println(this.position + "\t\tinvokevirtual: java.lang.Class.desiredAssertionStatus()Z;"); //$NON-NLS-1$
	invoke(
			Opcodes.OPC_invokevirtual,
			1, // receiverAndArgsSize
			1, // return type size
			ConstantPool.JavaLangClassConstantPoolName,
			ConstantPool.DesiredAssertionStatus,
			ConstantPool.DesiredAssertionStatusSignature);
}

public void invokeJavaLangEnumvalueOf(ReferenceBinding binding) {
	// invokestatic: java.lang.Enum.valueOf(Class,String)
	if (DEBUG) System.out.println(this.position + "\t\tinvokestatic: java.lang.Enum.valueOf(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;"); //$NON-NLS-1$
	invoke(
			Opcodes.OPC_invokestatic,
			2, // receiverAndArgsSize
			1, // return type size
			ConstantPool.JavaLangEnumConstantPoolName,
			ConstantPool.ValueOf,
			ConstantPool.ValueOfStringClassSignature);
}

public void invokeJavaLangEnumValues(TypeBinding enumBinding, ArrayBinding arrayBinding) {
	char[] signature = "()".toCharArray(); //$NON-NLS-1$
	signature = CharOperation.concat(signature, arrayBinding.constantPoolName());
	invoke(
			Opcodes.OPC_invokestatic, 
			0,  // receiverAndArgsSize
			1,  // return type size
			enumBinding.constantPoolName(), 
			TypeConstants.VALUES, 
			signature);
}

public void invokeJavaLangErrorConstructor() {
	// invokespecial: java.lang.Error<init>(Ljava.lang.String;)V
	if (DEBUG) System.out.println(this.position + "\t\tinvokespecial: java.lang.Error<init>(Ljava.lang.String;)V"); //$NON-NLS-1$
	invoke(
			Opcodes.OPC_invokespecial,
			2, // receiverAndArgsSize
			0, // return type size
			ConstantPool.JavaLangErrorConstantPoolName,
			ConstantPool.Init,
			ConstantPool.StringConstructorSignature);
}

public void invokeJavaLangReflectConstructorNewInstance() {
	// invokevirtual: java.lang.reflect.Constructor.newInstance([Ljava.lang.Object;)Ljava.lang.Object;
	invoke(
			Opcodes.OPC_invokevirtual,
			2, // receiverAndArgsSize
			1, // return type size
			ConstantPool.JavaLangReflectConstructorConstantPoolName,
			ConstantPool.NewInstance,
			ConstantPool.JavaLangReflectConstructorNewInstanceSignature);
}

protected void invokeJavaLangReflectFieldGetter(int typeID) {
	char[] selector;
	char[] signature;
	int returnTypeSize;
	switch (typeID) {
		case TypeIds.T_int :
			selector = ConstantPool.GET_INT_METHOD_NAME;
			signature = ConstantPool.GET_INT_METHOD_SIGNATURE;
			returnTypeSize = 1;
			break;
		case TypeIds.T_byte :
			selector = ConstantPool.GET_BYTE_METHOD_NAME;
			signature = ConstantPool.GET_BYTE_METHOD_SIGNATURE;
			returnTypeSize = 1;
			break;
		case TypeIds.T_short :
			selector = ConstantPool.GET_SHORT_METHOD_NAME;
			signature = ConstantPool.GET_SHORT_METHOD_SIGNATURE;
			returnTypeSize = 1;
			break;
		case TypeIds.T_long :
			selector = ConstantPool.GET_LONG_METHOD_NAME;

		case TypeIds.T_float :
			selector = ConstantPool.GET_FLOAT_METHOD_NAME;
			signature = ConstantPool.GET_FLOAT_METHOD_SIGNATURE;
			returnTypeSize = 1;
			break;
		case TypeIds.T_double :
			selector = ConstantPool.GET_DOUBLE_METHOD_NAME;

		case TypeIds.T_char :
			selector = ConstantPool.GET_CHAR_METHOD_NAME;
			signature = ConstantPool.GET_CHAR_METHOD_SIGNATURE;
			returnTypeSize = 1;
			break;
		case TypeIds.T_boolean :
			selector = ConstantPool.GET_BOOLEAN_METHOD_NAME;
			signature = ConstantPool.GET_BOOLEAN_METHOD_SIGNATURE;
			returnTypeSize = 1;
			break;
		default :
			selector = ConstantPool.GET_OBJECT_METHOD_NAME;
			signature = ConstantPool.GET_OBJECT_METHOD_SIGNATURE;
			returnTypeSize = 1;
			break;
	}
	invoke(
			Opcodes.OPC_invokevirtual,
			2, // receiverAndArgsSize
			returnTypeSize, // return type size
			ConstantPool.JAVALANGREFLECTFIELD_CONSTANTPOOLNAME,
			selector,
			signature);
}

protected void invokeJavaLangReflectFieldSetter(int typeID) {
	char[] selector;
	char[] signature;
	int receiverAndArgsSize;
	switch (typeID) {
		case TypeIds.T_int :
			selector = ConstantPool.SET_INT_METHOD_NAME;
			signature = ConstantPool.SET_INT_METHOD_SIGNATURE;
			receiverAndArgsSize = 3;
			break;
		case TypeIds.T_byte :
			selector = ConstantPool.SET_BYTE_METHOD_NAME;
			signature = ConstantPool.SET_BYTE_METHOD_SIGNATURE;
			receiverAndArgsSize = 3;
			break;
		case TypeIds.T_short :
			selector = ConstantPool.SET_SHORT_METHOD_NAME;
			signature = ConstantPool.SET_SHORT_METHOD_SIGNATURE;
			receiverAndArgsSize = 3;
			break;
		case TypeIds.T_long :
			selector = ConstantPool.SET_LONG_METHOD_NAME;
			signature = ConstantPool.SET_LONG_METHOD_SIGNATURE;
			receiverAndArgsSize = 4;
			break;
		case TypeIds.T_float :
			selector = ConstantPool.SET_FLOAT_METHOD_NAME;
			signature = ConstantPool.SET_FLOAT_METHOD_SIGNATURE;
			receiverAndArgsSize = 3;
			break;
		case TypeIds.T_double :
			selector = ConstantPool.SET_DOUBLE_METHOD_NAME;
			signature = ConstantPool.SET_DOUBLE_METHOD_SIGNATURE;
			receiverAndArgsSize = 4;
			break;
		case TypeIds.T_char :
			selector = ConstantPool.SET_CHAR_METHOD_NAME;
			signature = ConstantPool.SET_CHAR_METHOD_SIGNATURE;
			receiverAndArgsSize = 3;
			break;
		case TypeIds.T_boolean :
			selector = ConstantPool.SET_BOOLEAN_METHOD_NAME;
			signature = ConstantPool.SET_BOOLEAN_METHOD_SIGNATURE;
			receiverAndArgsSize = 3;
			break;
		default :
			selector = ConstantPool.SET_OBJECT_METHOD_NAME;
			signature = ConstantPool.SET_OBJECT_METHOD_SIGNATURE;
			receiverAndArgsSize = 3;
			break;
	}
	invoke(
			Opcodes.OPC_invokevirtual,
			receiverAndArgsSize,
			0, // return type size
			ConstantPool.JAVALANGREFLECTFIELD_CONSTANTPOOLNAME,
			selector,
			signature);
}

public void invokeJavaLangReflectMethodInvoke() {
	// invokevirtual: java.lang.reflect.Method.invoke(Ljava.lang.Object;[Ljava.lang.Object;)Ljava.lang.Object;
	invoke(
			Opcodes.OPC_invokevirtual,
			3, // receiverAndArgsSize
			1, // return type size
			ConstantPool.JAVALANGREFLECTMETHOD_CONSTANTPOOLNAME,
			ConstantPool.INVOKE_METHOD_METHOD_NAME,
			ConstantPool.INVOKE_METHOD_METHOD_SIGNATURE);
}

public void invokeJavaUtilIteratorHasNext() {
	// invokeinterface java.util.Iterator.hasNext()Z
	if (DEBUG) System.out.println(this.position + "\t\tinvokeinterface: java.util.Iterator.hasNext()Z"); //$NON-NLS-1$
	invoke(
			Opcodes.OPC_invokeinterface,
			1, // receiverAndArgsSize
			1, // return type size
			ConstantPool.JavaUtilIteratorConstantPoolName,
			ConstantPool.HasNext,
			ConstantPool.HasNextSignature);
}

public void invokeJavaUtilIteratorNext() {
	// invokeinterface java.util.Iterator.next()java.lang.Object
	if (DEBUG) System.out.println(this.position + "\t\tinvokeinterface: java.util.Iterator.next()java.lang.Object"); //$NON-NLS-1$
	invoke(
			Opcodes.OPC_invokeinterface,
			1, // receiverAndArgsSize
			1, // return type size
			ConstantPool.JavaUtilIteratorConstantPoolName,
			ConstantPool.Next,
			ConstantPool.NextSignature);
}

public void invokeNoClassDefFoundErrorStringConstructor() {
	// invokespecial: java.lang.NoClassDefFoundError.<init>(Ljava.lang.String;)V
	if (DEBUG) System.out.println(this.position + "\t\tinvokespecial: java.lang.NoClassDefFoundError.<init>(Ljava.lang.String;)V"); //$NON-NLS-1$
	invoke(
			Opcodes.OPC_invokespecial,
			2, // receiverAndArgsSize
			0, // return type size
			ConstantPool.JavaLangNoClassDefFoundErrorConstantPoolName,
			ConstantPool.Init,
			ConstantPool.StringConstructorSignature);
}

public void invokeObjectGetClass() {
	// invokevirtual: java.lang.Object.getClass()Ljava.lang.Class;
	if (DEBUG) System.out.println(this.position + "\t\tinvokevirtual: java.lang.Object.getClass()Ljava.lang.Class;"); //$NON-NLS-1$
	invoke(
			Opcodes.OPC_invokevirtual,
			1, // receiverAndArgsSize
			1, // return type size
			ConstantPool.JavaLangObjectConstantPoolName,
			ConstantPool.GetClass,
			ConstantPool.GetClassSignature);
}

	if (DEBUG) System.out.println(this.position + "\t\tinvokespecial:"+methodBinding); //$NON-NLS-1$
	this.countLabels = 0;
	// initialized to 1 to take into account this immediately
	int argCount = 1;
	int id;
	if (this.classFileOffset + 2 >= this.bCodeStream.length) {
		resizeByteArray();
	}
	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_invokespecial;
	writeUnsignedShort(
		this.constantPool.literalIndexForMethod(
			methodBinding.constantPoolDeclaringClass(),
			methodBinding.selector,
			methodBinding.signature(this.classFile),
			false));
	if (methodBinding.isConstructor()) {
		final ReferenceBinding declaringClass = methodBinding.declaringClass;
		if (declaringClass.isNestedType()) {
			// enclosing instances
			TypeBinding[] syntheticArgumentTypes = declaringClass.syntheticEnclosingInstanceTypes();
			if (syntheticArgumentTypes != null) {
				for (int i = 0, max = syntheticArgumentTypes.length; i < max; i++) {
					if (((id = syntheticArgumentTypes[i].id) == TypeIds.T_double) || (id == TypeIds.T_long)) {
						argCount += 2;
					} else {
						argCount++;
					}
				}
			}
			// outer local variables
			SyntheticArgumentBinding[] syntheticArguments = declaringClass.syntheticOuterLocalVariables();
			if (syntheticArguments != null) {
				for (int i = 0, max = syntheticArguments.length; i < max; i++) {
					if (((id = syntheticArguments[i].type.id) == TypeIds.T_double) || (id == TypeIds.T_long)) {
						argCount += 2;
					} else {
						argCount++;
					}
				}
			}
		}
		if (declaringClass.isEnum()) {
			// adding String and int
			argCount += 2;
		}
	}
	for (int i = methodBinding.parameters.length - 1; i >= 0; i--)
		if (((id = methodBinding.parameters[i].id) == TypeIds.T_double) || (id == TypeIds.T_long))
			argCount += 2;
		else
			argCount++;
	if (((id = methodBinding.returnType.id) == TypeIds.T_double) || (id == TypeIds.T_long))
		this.stackDepth += (2 - argCount);
	else
		if (id == TypeIds.T_void)
			this.stackDepth -= argCount;
		else
			this.stackDepth += (1 - argCount);
	if (this.stackDepth > this.stackMax)
		this.stackMax = this.stackDepth;
}
public void invokestatic(MethodBinding methodBinding) {
	if (DEBUG) System.out.println(this.position + "\t\tinvokestatic:"+methodBinding); //$NON-NLS-1$
	// initialized to 0 to take into account that there is no this for
	// a static method
	this.countLabels = 0;
	int argCount = 0;
	int id;
	if (this.classFileOffset + 2 >= this.bCodeStream.length) {
		resizeByteArray();
	}
	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_invokestatic;
	writeUnsignedShort(
		this.constantPool.literalIndexForMethod(
			methodBinding.constantPoolDeclaringClass(),
			methodBinding.selector,
			methodBinding.signature(this.classFile),
			false));
	for (int i = methodBinding.parameters.length - 1; i >= 0; i--)
		if (((id = methodBinding.parameters[i].id) == TypeIds.T_double) || (id == TypeIds.T_long))
			argCount += 2;
		else
			argCount += 1;
	if (((id = methodBinding.returnType.id) == TypeIds.T_double) || (id == TypeIds.T_long))
		this.stackDepth += (2 - argCount);
	else
		if (id == TypeIds.T_void)
			this.stackDepth -= argCount;
		else
			this.stackDepth += (1 - argCount);
	if (this.stackDepth > this.stackMax)
		this.stackMax = this.stackDepth;
}
/**
 * The equivalent code performs a string conversion of the TOS
 * @param typeID <CODE>int</CODE>
 */
public void invokeStringConcatenationAppendForType(int typeID) {
	int receiverAndArgsSize;
		if (this.targetLevel >= ClassFileConstants.JDK1_5) {
			System.out.println(this.position + "\t\tinvokevirtual: java.lang.StringBuilder.append(...)"); //$NON-NLS-1$
		} else {
			System.out.println(this.position + "\t\tinvokevirtual: java.lang.StringBuffer.append(...)"); //$NON-NLS-1$
		}
	}
	int argCount = 1;
	int returnType = 1;
	char[] declaringClass = null;
	char[] selector = ConstantPool.Append;
	char[] signature = null;

				declaringClass = ConstantPool.JavaLangStringBufferConstantPoolName;
				signature = ConstantPool.StringBufferAppendIntSignature;
			}
			receiverAndArgsSize = 2;
			break;
		case TypeIds.T_long :
			if (this.targetLevel >= ClassFileConstants.JDK1_5) {

				declaringClass = ConstantPool.JavaLangStringBufferConstantPoolName;
				signature = ConstantPool.StringBufferAppendLongSignature;
			}
			receiverAndArgsSize = 3;
			break;
		case TypeIds.T_float :
			if (this.targetLevel >= ClassFileConstants.JDK1_5) {

				declaringClass = ConstantPool.JavaLangStringBufferConstantPoolName;
				signature = ConstantPool.StringBufferAppendFloatSignature;
			}
			receiverAndArgsSize = 2;
			break;
		case TypeIds.T_double :
			if (this.targetLevel >= ClassFileConstants.JDK1_5) {

				declaringClass = ConstantPool.JavaLangStringBufferConstantPoolName;
				signature = ConstantPool.StringBufferAppendDoubleSignature;
			}
			receiverAndArgsSize = 3;
			break;
		case TypeIds.T_char :
			if (this.targetLevel >= ClassFileConstants.JDK1_5) {

				declaringClass = ConstantPool.JavaLangStringBufferConstantPoolName;
				signature = ConstantPool.StringBufferAppendCharSignature;
			}
			receiverAndArgsSize = 2;
			break;
		case TypeIds.T_boolean :
			if (this.targetLevel >= ClassFileConstants.JDK1_5) {

				declaringClass = ConstantPool.JavaLangStringBufferConstantPoolName;
				signature = ConstantPool.StringBufferAppendBooleanSignature;
			}
			receiverAndArgsSize = 2;
			break;
		case TypeIds.T_JavaLangString :
		case TypeIds.T_JavaLangObject :
		case TypeIds.T_null :
			if (this.targetLevel >= ClassFileConstants.JDK1_5) {
				declaringClass = ConstantPool.JavaLangStringBuilderConstantPoolName;
				signature = ConstantPool.StringBuilderAppendStringSignature;
			} else {
				declaringClass = ConstantPool.JavaLangStringBufferConstantPoolName;
				signature = ConstantPool.StringBufferAppendStringSignature;
			}
			receiverAndArgsSize = 2;
			break;
		default :
			if (this.targetLevel >= ClassFileConstants.JDK1_5) {
				declaringClass = ConstantPool.JavaLangStringBuilderConstantPoolName;
				signature = ConstantPool.StringBuilderAppendObjectSignature;
			} else {
				declaringClass = ConstantPool.JavaLangStringBufferConstantPoolName;
				signature = ConstantPool.StringBufferAppendObjectSignature;
			}
			receiverAndArgsSize = 2;
			break;
	}
	invoke(
			Opcodes.OPC_invokevirtual,
			receiverAndArgsSize,
			1, // return type size
			declaringClass,
			selector,
			signature);
}

public void invokeStringConcatenationDefaultConstructor() {
	// invokespecial: java.lang.StringBuffer.<init>()V
	// or invokespecial: java.lang.StringBuilder.<init>()V
	char[] declaringClass;
	if (this.targetLevel < ClassFileConstants.JDK1_5) {
		declaringClass = ConstantPool.JavaLangStringBufferConstantPoolName;
	} else {
		}
	}
	char[] declaringClass = ConstantPool.JavaLangStringBufferConstantPoolName;
	if (this.targetLevel >= ClassFileConstants.JDK1_5) {
		declaringClass = ConstantPool.JavaLangStringBuilderConstantPoolName;
	}
	invoke(
			Opcodes.OPC_invokespecial,
			1, // receiverAndArgsSize
			0, // return type size
			declaringClass,
			ConstantPool.Init,
			ConstantPool.DefaultConstructorSignature);
}

public void invokeStringConcatenationStringConstructor() {
	// invokespecial: java.lang.StringBuffer.<init>(java.lang.String)V
	// or invokespecial: java.lang.StringBuilder.<init>(java.lang.String)V
	char[] declaringClass;
	if (this.targetLevel < ClassFileConstants.JDK1_5) {
		// invokespecial: java.lang.StringBuffer.<init>()V
		declaringClass = ConstantPool.JavaLangStringBufferConstantPoolName;
	} else {
		// invokespecial: java.lang.StringStringBuilder.<init>(java.langString)V
	if (this.targetLevel >= ClassFileConstants.JDK1_5) {
		declaringClass = ConstantPool.JavaLangStringBuilderConstantPoolName;
	}
	invoke(
			Opcodes.OPC_invokespecial,
			2, // receiverAndArgsSize
			0, // return type size
			declaringClass,
			ConstantPool.Init,
			ConstantPool.StringConstructorSignature);
}

public void invokeStringConcatenationToString() {
	// invokespecial: java.lang.StringBuffer.toString()java.lang.String
	// or invokespecial: java.lang.StringBuilder.toString()java.lang.String
	char[] declaringClass;
	if (this.targetLevel < ClassFileConstants.JDK1_5) {
		// invokespecial: java.lang.StringBuffer.<init>()V
		declaringClass = ConstantPool.JavaLangStringBufferConstantPoolName;
	} else {
		// invokespecial: java.lang.StringStringBuilder.<init>(java.langString)V
	if (this.targetLevel >= ClassFileConstants.JDK1_5) {
		declaringClass = ConstantPool.JavaLangStringBuilderConstantPoolName;
	}	
	invoke(
			Opcodes.OPC_invokevirtual,
			1, // receiverAndArgsSize
			1, // return type size
			declaringClass,
			ConstantPool.ToString,
			ConstantPool.ToStringSignature);
}

public void invokeStringIntern() {
	// invokevirtual: java.lang.String.intern()
	if (DEBUG) System.out.println(this.position + "\t\tinvokevirtual: java.lang.String.intern()"); //$NON-NLS-1$
	invoke(
			Opcodes.OPC_invokevirtual,
			1, // receiverAndArgsSize
			1, // return type size
			ConstantPool.JavaLangStringConstantPoolName,
			ConstantPool.Intern,
			ConstantPool.InternSignature);
}

public void invokeStringValueOf(int typeID) {
	// invokestatic: java.lang.String.valueOf(argumentType)
	char[] signature;
	int receiverAndArgsSize;
	char[] signature = null;
	switch (typeID) {
		case TypeIds.T_int :
		case TypeIds.T_byte :
		case TypeIds.T_short :
			signature = ConstantPool.ValueOfIntSignature;
			receiverAndArgsSize = 1;
			break;
		case TypeIds.T_long :
			signature = ConstantPool.ValueOfLongSignature;
			receiverAndArgsSize = 2;
			break;
		case TypeIds.T_float :
			signature = ConstantPool.ValueOfFloatSignature;
			receiverAndArgsSize = 1;
			break;
		case TypeIds.T_double :
			signature = ConstantPool.ValueOfDoubleSignature;
			receiverAndArgsSize = 2;
			break;
		case TypeIds.T_char :
			signature = ConstantPool.ValueOfCharSignature;
			receiverAndArgsSize = 1;
			break;
		case TypeIds.T_boolean :
			signature = ConstantPool.ValueOfBooleanSignature;
			receiverAndArgsSize = 1;
			break;
		case TypeIds.T_JavaLangObject :
		case TypeIds.T_JavaLangString :
		case TypeIds.T_null :
		case TypeIds.T_undefined :
			signature = ConstantPool.ValueOfObjectSignature;
			receiverAndArgsSize = 1;
			break;
		default :
			return; // should not occur
	}
	invoke(
			Opcodes.OPC_invokestatic,
			receiverAndArgsSize, // receiverAndArgsSize
			1, // return type size
			ConstantPool.JavaLangStringConstantPoolName,
			ConstantPool.ValueOf,
			signature);
}

public void invokeSystemArraycopy() {
	// invokestatic #21 <Method java/lang/System.arraycopy(Ljava/lang/Object;ILjava/lang/Object;II)V>
	if (DEBUG) System.out.println(this.position + "\t\tinvokevirtual: java.lang.System.arraycopy(Ljava/lang/Object;ILjava/lang/Object;II)V"); //$NON-NLS-1$
	invoke(
			Opcodes.OPC_invokestatic,
			5, // receiverAndArgsSize
			0, // return type size
			ConstantPool.JavaLangSystemConstantPoolName,
			ConstantPool.ArrayCopy,
			ConstantPool.ArrayCopySignature);
}

public void invokeThrowableGetMessage() {
	// invokevirtual: java.lang.Throwable.getMessage()Ljava.lang.String;
	if (DEBUG) System.out.println(this.position + "\t\tinvokevirtual: java.lang.Throwable.getMessage()Ljava.lang.String;"); //$NON-NLS-1$
	invoke(
			Opcodes.OPC_invokevirtual,
			1, // receiverAndArgsSize
			1, // return type size
			ConstantPool.JavaLangThrowableConstantPoolName,
			ConstantPool.GetMessage,
			ConstantPool.GetMessageSignature);
}

	if (DEBUG) System.out.println(this.position + "\t\tinvokevirtual:"+methodBinding); //$NON-NLS-1$
	this.countLabels = 0;
	// initialized to 1 to take into account this  immediately
	int argCount = 1;
	int id;
	if (this.classFileOffset + 2 >= this.bCodeStream.length) {
		resizeByteArray();
	}
	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_invokevirtual;
	writeUnsignedShort(
		this.constantPool.literalIndexForMethod(
			methodBinding.constantPoolDeclaringClass(),
			methodBinding.selector,
			methodBinding.signature(this.classFile),
			false));
	for (int i = methodBinding.parameters.length - 1; i >= 0; i--)
		if (((id = methodBinding.parameters[i].id) == TypeIds.T_double) || (id == TypeIds.T_long))
			argCount += 2;
		else
			argCount++;
	if (((id = methodBinding.returnType.id) == TypeIds.T_double) || (id == TypeIds.T_long))
		this.stackDepth += (2 - argCount);
	else
		if (id == TypeIds.T_void)
			this.stackDepth -= argCount;
		else
			this.stackDepth += (1 - argCount);
	if (this.stackDepth > this.stackMax)
		this.stackMax = this.stackDepth;
}
public void ior() {
	if (DEBUG) System.out.println(this.position + "\t\tior"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_ior;
}

public void irem() {
	if (DEBUG) System.out.println(this.position + "\t\tirem"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_irem;
}

public void ireturn() {
	if (DEBUG) System.out.println(this.position + "\t\tireturn"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	// the stackDepth should be equal to 0

	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_ireturn;
	this.lastAbruptCompletion = this.position;
}

public boolean isDefinitelyAssigned(Scope scope, int initStateIndex, LocalVariableBinding local) {
	// Mirror of UnconditionalFlowInfo.isDefinitelyAssigned(..)
	if ((local.tagBits & TagBits.IsArgument) != 0) {

		return false; // if not enough room in vector, then not initialized
	return ((extraInits[vectorIndex]) & (1L << (localPosition % UnconditionalFlowInfo.BitCacheSize))) != 0;
}

public void ishl() {
	if (DEBUG) System.out.println(this.position + "\t\tishl"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_ishl;
}

public void ishr() {
	if (DEBUG) System.out.println(this.position + "\t\tishr"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_ishr;
}

public void istore(int iArg) {
	if (DEBUG) System.out.println(this.position + "\t\tistore:"+iArg); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.maxLocals <= iArg) {

		this.bCodeStream[this.classFileOffset++] = (byte) iArg;
	}
}

public void istore_0() {
	if (DEBUG) System.out.println(this.position + "\t\tistore_0"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.maxLocals == 0) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_istore_0;
}

public void istore_1() {
	if (DEBUG) System.out.println(this.position + "\t\tistore_1"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.maxLocals <= 1) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_istore_1;
}

public void istore_2() {
	if (DEBUG) System.out.println(this.position + "\t\tistore_2"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.maxLocals <= 2) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_istore_2;
}

public void istore_3() {
	if (DEBUG) System.out.println(this.position + "\t\tistore_3"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.maxLocals <= 3) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_istore_3;
}

public void isub() {
	if (DEBUG) System.out.println(this.position + "\t\tisub"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_isub;
}

public void iushr() {
	if (DEBUG) System.out.println(this.position + "\t\tiushr"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_iushr;
}

public void ixor() {
	if (DEBUG) System.out.println(this.position + "\t\tixor"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_ixor;
}

final public void jsr(BranchLabel lbl) {
	if (this.wideMode) {
		jsr_w(lbl);
		return;
	}
	if (DEBUG) System.out.println(this.position + "\t\tjsr"+lbl); //$NON-NLS-1$
	this.countLabels = 0;
	if (this.classFileOffset >= this.bCodeStream.length) {
		resizeByteArray();

	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_jsr;
	lbl.branch();
}

final public void jsr_w(BranchLabel lbl) {
	if (DEBUG) System.out.println(this.position + "\t\tjsr_w"+lbl); //$NON-NLS-1$
	this.countLabels = 0;
	if (this.classFileOffset >= this.bCodeStream.length) {
		resizeByteArray();

	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_jsr_w;
	lbl.branchWide();
}

public void l2d() {
	if (DEBUG) System.out.println(this.position + "\t\tl2d"); //$NON-NLS-1$
	this.countLabels = 0;
	if (this.classFileOffset >= this.bCodeStream.length) {
		resizeByteArray();

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_l2d;
}

public void l2f() {
	if (DEBUG) System.out.println(this.position + "\t\tl2f"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_l2f;
}

public void l2i() {
	if (DEBUG) System.out.println(this.position + "\t\tl2i"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_l2i;
}

public void ladd() {
	if (DEBUG) System.out.println(this.position + "\t\tladd"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_ladd;
}

public void laload() {
	if (DEBUG) System.out.println(this.position + "\t\tlaload"); //$NON-NLS-1$
	this.countLabels = 0;
	if (this.classFileOffset >= this.bCodeStream.length) {
		resizeByteArray();

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_laload;
}

public void land() {
	if (DEBUG) System.out.println(this.position + "\t\tland"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_land;
}

public void lastore() {
	if (DEBUG) System.out.println(this.position + "\t\tlastore"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 4;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_lastore;
}

public void lcmp() {
	if (DEBUG) System.out.println(this.position + "\t\tlcmp"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 3;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_lcmp;
}

public void lconst_0() {
	if (DEBUG) System.out.println(this.position + "\t\tlconst_0"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth += 2;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_lconst_0;
}

public void lconst_1() {
	if (DEBUG) System.out.println(this.position + "\t\tlconst_1"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth += 2;
	if (this.stackDepth > this.stackMax)

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_lconst_1;
}

public void ldc(float constant) {
	this.countLabels = 0;
	int index = this.constantPool.literalIndex(constant);

	if (this.stackDepth > this.stackMax)
		this.stackMax = this.stackDepth;
	if (index > 255) {
		if (DEBUG) System.out.println(this.position + "\t\tldc_w:"+constant); //$NON-NLS-1$
		// Generate a ldc_w
		if (this.classFileOffset + 2 >= this.bCodeStream.length) {
			resizeByteArray();

		this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_ldc_w;
		writeUnsignedShort(index);
	} else {
		if (DEBUG) System.out.println(this.position + "\t\tldc:"+constant); //$NON-NLS-1$
		// Generate a ldc
		if (this.classFileOffset + 1 >= this.bCodeStream.length) {
			resizeByteArray();

		this.bCodeStream[this.classFileOffset++] = (byte) index;
	}
}

public void ldc(int constant) {
	this.countLabels = 0;
	int index = this.constantPool.literalIndex(constant);

	if (this.stackDepth > this.stackMax)
		this.stackMax = this.stackDepth;
	if (index > 255) {
		if (DEBUG) System.out.println(this.position + "\t\tldc_w:"+constant); //$NON-NLS-1$
		// Generate a ldc_w
		if (this.classFileOffset + 2 >= this.bCodeStream.length) {
			resizeByteArray();

		this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_ldc_w;
		writeUnsignedShort(index);
	} else {
		if (DEBUG) System.out.println(this.position + "\t\tldc:"+constant); //$NON-NLS-1$
		// Generate a ldc
		if (this.classFileOffset + 1 >= this.bCodeStream.length) {
			resizeByteArray();

		this.bCodeStream[this.classFileOffset++] = (byte) index;
	}
}

public void ldc(String constant) {
	this.countLabels = 0;
	int currentCodeStreamPosition = this.position;

		invokeStringIntern();
	}
}

public void ldc(TypeBinding typeBinding) {
	this.countLabels = 0;
	int index = this.constantPool.literalIndexForType(typeBinding);

	if (this.stackDepth > this.stackMax)
		this.stackMax = this.stackDepth;
	if (index > 255) {
		if (DEBUG) System.out.println(this.position + "\t\tldc_w:"+ typeBinding); //$NON-NLS-1$
		// Generate a ldc_w
		if (this.classFileOffset + 2 >= this.bCodeStream.length) {
			resizeByteArray();

		this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_ldc_w;
		writeUnsignedShort(index);
	} else {
		if (DEBUG) System.out.println(this.position + "\t\tldw:"+ typeBinding); //$NON-NLS-1$
		// Generate a ldc
		if (this.classFileOffset + 1 >= this.bCodeStream.length) {
			resizeByteArray();

		this.bCodeStream[this.classFileOffset++] = (byte) index;
	}
}

public void ldc2_w(double constant) {
	if (DEBUG) System.out.println(this.position + "\t\tldc2_w:"+constant); //$NON-NLS-1$
	this.countLabels = 0;
	int index = this.constantPool.literalIndex(constant);
	this.stackDepth += 2;

	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_ldc2_w;
	writeUnsignedShort(index);
}

public void ldc2_w(long constant) {
	if (DEBUG) System.out.println(this.position + "\t\tldc2_w:"+constant); //$NON-NLS-1$
	this.countLabels = 0;
	int index = this.constantPool.literalIndex(constant);
	this.stackDepth += 2;

	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_ldc2_w;
	writeUnsignedShort(index);
}

public void ldcForIndex(int index, char[] constant) {
	this.stackDepth++;
	if (this.stackDepth > this.stackMax) {

	}
	if (index > 255) {
		// Generate a ldc_w
		if (DEBUG) System.out.println(this.position + "\t\tldc_w:"+ new String(constant)); //$NON-NLS-1$
		if (this.classFileOffset + 2 >= this.bCodeStream.length) {
			resizeByteArray();
		}

		writeUnsignedShort(index);
	} else {
		// Generate a ldc
		if (DEBUG) System.out.println(this.position + "\t\tldc:"+ new String(constant)); //$NON-NLS-1$
		if (this.classFileOffset + 1 >= this.bCodeStream.length) {
			resizeByteArray();
		}

		this.bCodeStream[this.classFileOffset++] = (byte) index;
	}
}

public void ldiv() {
	if (DEBUG) System.out.println(this.position + "\t\tldiv"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_ldiv;
}

public void lload(int iArg) {
	if (DEBUG) System.out.println(this.position + "\t\tlload:"+iArg); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth += 2;
	if (this.maxLocals <= iArg + 1) {

		this.bCodeStream[this.classFileOffset++] = (byte) iArg;
	}
}

public void lload_0() {
	if (DEBUG) System.out.println(this.position + "\t\tlload_0"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth += 2;
	if (this.maxLocals < 2) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_lload_0;
}

public void lload_1() {
	if (DEBUG) System.out.println(this.position + "\t\tlload_1"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth += 2;
	if (this.maxLocals < 3) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_lload_1;
}

public void lload_2() {
	if (DEBUG) System.out.println(this.position + "\t\tlload_2"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth += 2;
	if (this.maxLocals < 4) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_lload_2;
}

public void lload_3() {
	if (DEBUG) System.out.println(this.position + "\t\tlload_3"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth += 2;
	if (this.maxLocals < 5) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_lload_3;
}

public void lmul() {
	if (DEBUG) System.out.println(this.position + "\t\tlmul"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_lmul;
}

public void lneg() {
	if (DEBUG) System.out.println(this.position + "\t\tlneg"); //$NON-NLS-1$
	this.countLabels = 0;
	if (this.classFileOffset >= this.bCodeStream.length) {
		resizeByteArray();

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_lneg;
}

public final void load(LocalVariableBinding localBinding) {
	load(localBinding.type, localBinding.resolvedPosition);
}

public final void load(TypeBinding typeBinding, int resolvedPosition) {
	this.countLabels = 0;
	// Using dedicated int bytecode

			}
	}
}

public void lookupswitch(CaseLabel defaultLabel, int[] keys, int[] sortedIndexes, CaseLabel[] casesLabel) {
	if (DEBUG) System.out.println(this.position + "\t\tlookupswitch"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	int length = keys.length;

		casesLabel[sortedIndexes[i]].branch();
	}
}

public void lor() {
	if (DEBUG) System.out.println(this.position + "\t\tlor"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_lor;
}

public void lrem() {
	if (DEBUG) System.out.println(this.position + "\t\tlrem"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_lrem;
}

public void lreturn() {
	if (DEBUG) System.out.println(this.position + "\t\tlreturn"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	// the stackDepth should be equal to 0

	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_lreturn;
	this.lastAbruptCompletion = this.position;
}

public void lshl() {
	if (DEBUG) System.out.println(this.position + "\t\tlshl"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_lshl;
}

public void lshr() {
	if (DEBUG) System.out.println(this.position + "\t\tlshr"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_lshr;
}

public void lstore(int iArg) {
	if (DEBUG) System.out.println(this.position + "\t\tlstore:"+iArg); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.maxLocals <= iArg + 1) {

		this.bCodeStream[this.classFileOffset++] = (byte) iArg;
	}
}

public void lstore_0() {
	if (DEBUG) System.out.println(this.position + "\t\tlstore_0"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.maxLocals < 2) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_lstore_0;
}

public void lstore_1() {
	if (DEBUG) System.out.println(this.position + "\t\tlstore_1"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.maxLocals < 3) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_lstore_1;
}

public void lstore_2() {
	if (DEBUG) System.out.println(this.position + "\t\tlstore_2"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.maxLocals < 4) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_lstore_2;
}

public void lstore_3() {
	if (DEBUG) System.out.println(this.position + "\t\tlstore_3"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.maxLocals < 5) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_lstore_3;
}

public void lsub() {
	if (DEBUG) System.out.println(this.position + "\t\tlsub"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_lsub;
}

public void lushr() {
	if (DEBUG) System.out.println(this.position + "\t\tlushr"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_lushr;
}

public void lxor() {
	if (DEBUG) System.out.println(this.position + "\t\tlxor"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_lxor;
}

public void monitorenter() {
	if (DEBUG) System.out.println(this.position + "\t\tmonitorenter"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_monitorenter;
}

public void monitorexit() {
	if (DEBUG) System.out.println(this.position + "\t\tmonitorexit"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_monitorexit;
}

public void multianewarray(TypeBinding typeBinding, int dimensions) {
	if (DEBUG) System.out.println(this.position + "\t\tmultinewarray:"+typeBinding+","+dimensions); //$NON-NLS-1$ //$NON-NLS-2$
	this.countLabels = 0;
	this.stackDepth += (1 - dimensions);
	if (this.classFileOffset + 3 >= this.bCodeStream.length) {

	writeUnsignedShort(this.constantPool.literalIndexForType(typeBinding));
	this.bCodeStream[this.classFileOffset++] = (byte) dimensions;
}

// We didn't call it new, because there is a conflit with the new keyword
public void new_(TypeBinding typeBinding) {
	if (DEBUG) System.out.println(this.position + "\t\tnew:"+typeBinding.debugName()); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax)

	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_new;
	writeUnsignedShort(this.constantPool.literalIndexForType(typeBinding));
}

public void newarray(int array_Type) {
	if (DEBUG) System.out.println(this.position + "\t\tnewarray:"+array_Type); //$NON-NLS-1$
	this.countLabels = 0;
	if (this.classFileOffset + 1 >= this.bCodeStream.length) {
		resizeByteArray();

	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_newarray;
	this.bCodeStream[this.classFileOffset++] = (byte) array_Type;
}

public void newArray(ArrayBinding arrayBinding) {
	TypeBinding component = arrayBinding.elementsType();
	switch (component.id) {

			anewarray(component);
	}
}

public void newJavaLangAssertionError() {
	// new: java.lang.AssertionError
	if (DEBUG) System.out.println(this.position + "\t\tnew: java.lang.AssertionError"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax)

	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_new;
	writeUnsignedShort(this.constantPool.literalIndexForType(ConstantPool.JavaLangAssertionErrorConstantPoolName));
}

public void newJavaLangError() {
	// new: java.lang.Error
	if (DEBUG) System.out.println(this.position + "\t\tnew: java.lang.Error"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax)

	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_new;
	writeUnsignedShort(this.constantPool.literalIndexForType(ConstantPool.JavaLangErrorConstantPoolName));
}

public void newNoClassDefFoundError() {
	// new: java.lang.NoClassDefFoundError
	if (DEBUG) System.out.println(this.position + "\t\tnew: java.lang.NoClassDefFoundError"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax)

	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_new;
	writeUnsignedShort(this.constantPool.literalIndexForType(ConstantPool.JavaLangNoClassDefFoundErrorConstantPoolName));
}

public void newStringContatenation() {
	// new: java.lang.StringBuffer
	// new: java.lang.StringBuilder
	if (DEBUG) {
		if (this.targetLevel >= ClassFileConstants.JDK1_5) {
			System.out.println(this.position + "\t\tnew: java.lang.StringBuilder"); //$NON-NLS-1$
		} else {
			System.out.println(this.position + "\t\tnew: java.lang.StringBuffer"); //$NON-NLS-1$
		}
	}
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax) {

		writeUnsignedShort(this.constantPool.literalIndexForType(ConstantPool.JavaLangStringBufferConstantPoolName));
	}
}

public void newWrapperFor(int typeID) {
	this.countLabels = 0;
	this.stackDepth++;

	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_new;
	switch (typeID) {
		case TypeIds.T_int : // new: java.lang.Integer
			if (DEBUG) System.out.println(this.position + "\t\tnew: java.lang.Integer"); //$NON-NLS-1$
			writeUnsignedShort(this.constantPool.literalIndexForType(ConstantPool.JavaLangIntegerConstantPoolName));
			break;
		case TypeIds.T_boolean : // new: java.lang.Boolean
			if (DEBUG) System.out.println(this.position + "\t\tnew: java.lang.Boolean"); //$NON-NLS-1$
			writeUnsignedShort(this.constantPool.literalIndexForType(ConstantPool.JavaLangBooleanConstantPoolName));
			break;
		case TypeIds.T_byte : // new: java.lang.Byte
			if (DEBUG) System.out.println(this.position + "\t\tnew: java.lang.Byte"); //$NON-NLS-1$
			writeUnsignedShort(this.constantPool.literalIndexForType(ConstantPool.JavaLangByteConstantPoolName));
			break;
		case TypeIds.T_char : // new: java.lang.Character
			if (DEBUG) System.out.println(this.position + "\t\tnew: java.lang.Character"); //$NON-NLS-1$
			writeUnsignedShort(this.constantPool.literalIndexForType(ConstantPool.JavaLangCharacterConstantPoolName));
			break;
		case TypeIds.T_float : // new: java.lang.Float
			if (DEBUG) System.out.println(this.position + "\t\tnew: java.lang.Float"); //$NON-NLS-1$
			writeUnsignedShort(this.constantPool.literalIndexForType(ConstantPool.JavaLangFloatConstantPoolName));
			break;
		case TypeIds.T_double : // new: java.lang.Double
			if (DEBUG) System.out.println(this.position + "\t\tnew: java.lang.Double"); //$NON-NLS-1$
			writeUnsignedShort(this.constantPool.literalIndexForType(ConstantPool.JavaLangDoubleConstantPoolName));
			break;
		case TypeIds.T_short : // new: java.lang.Short
			if (DEBUG) System.out.println(this.position + "\t\tnew: java.lang.Short"); //$NON-NLS-1$
			writeUnsignedShort(this.constantPool.literalIndexForType(ConstantPool.JavaLangShortConstantPoolName));
			break;
		case TypeIds.T_long : // new: java.lang.Long
			if (DEBUG) System.out.println(this.position + "\t\tnew: java.lang.Long"); //$NON-NLS-1$
			writeUnsignedShort(this.constantPool.literalIndexForType(ConstantPool.JavaLangLongConstantPoolName));
			break;
		case TypeIds.T_void : // new: java.lang.Void
			if (DEBUG) System.out.println(this.position + "\t\tnew: java.lang.Void"); //$NON-NLS-1$
			writeUnsignedShort(this.constantPool.literalIndexForType(ConstantPool.JavaLangVoidConstantPoolName));
	}
}

public void nop() {
	if (DEBUG) System.out.println(this.position + "\t\tnop"); //$NON-NLS-1$
	this.countLabels = 0;
	if (this.classFileOffset >= this.bCodeStream.length) {
		resizeByteArray();

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_nop;
}

public void optimizeBranch(int oldPosition, BranchLabel lbl) {
	for (int i = 0; i < this.countLabels; i++) {
		BranchLabel label = this.labels[i];

		}
	}
}

public void pop() {
	if (DEBUG) System.out.println(this.position + "\t\tpop"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_pop;
}

public void pop2() {
	if (DEBUG) System.out.println(this.position + "\t\tpop2"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 2;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_pop2;
}

	if (++this.stackDepth > this.stackMax)
		this.stackMax = this.stackDepth;
}
public void pushExceptionOnStack(TypeBinding binding) {
	this.stackDepth = 1;
	if (this.stackDepth > this.stackMax)
		this.stackMax = this.stackDepth;
}

public void pushOnStack(TypeBinding binding) {
	if (++this.stackDepth > this.stackMax)
		this.stackMax = this.stackDepth;
}

public void putfield(FieldBinding fieldBinding) {
	if (DEBUG) System.out.println(this.position + "\t\tputfield:"+fieldBinding); //$NON-NLS-1$
	int returnTypeSize = 1;
	if ((fieldBinding.type.id == TypeIds.T_double) || (fieldBinding.type.id == TypeIds.T_long)) {
		returnTypeSize = 2;

			fieldBinding.name,
			fieldBinding.type);
}

public void putstatic(FieldBinding fieldBinding) {
	if (DEBUG) System.out.println(this.position + "\t\tputstatic:"+fieldBinding); //$NON-NLS-1$
	int returnTypeSize = 1;
	if ((fieldBinding.type.id == TypeIds.T_double) || (fieldBinding.type.id == TypeIds.T_long)) {
		returnTypeSize = 2;

			fieldBinding.name,
			fieldBinding.type);
}

public void record(LocalVariableBinding local) {
	if ((this.generateAttributes & (ClassFileConstants.ATTR_VARS
			| ClassFileConstants.ATTR_STACK_MAP_TABLE

public void recordExpressionType(TypeBinding typeBinding) {
	// nothing to do
}

public void recordPositionsFrom(int startPC, int sourcePos) {
	this.recordPositionsFrom(startPC, sourcePos, false);
}
public void recordPositionsFrom(int startPC, int sourcePos, boolean widen) {

public void recordPositionsFrom(int startPC, int sourcePos, boolean widen) {
	/* Record positions in the table, only if nothing has
	 * already been recorded. Since we output them on the way
	 * up (children first for more specific info)
	 * The pcToSourceMap table is always sorted.
	 */

	if ((this.generateAttributes & ClassFileConstants.ATTR_LINES) == 0
			|| sourcePos == 0
			|| (startPC == this.position && !widen))

		this.lastEntryPC = this.position;
	}
}

/**
 * @param anExceptionLabel org.eclipse.jdt.internal.compiler.codegen.ExceptionLabel
 */

	// no need to resize. So just add the new exception label
	this.exceptionLabels[this.exceptionLabelsCounter++] = anExceptionLabel;
}

public void removeNotDefinitelyAssignedVariables(Scope scope, int initStateIndex) {
	// given some flow info, make sure we did not loose some variables initialization
	// if this happens, then we must update their pc entries to reflect it in debug attributes

		}
	}
}

/**
 * Remove all entries in pcToSourceMap table that are beyond this.position
 */

		}
	}
}

/**
 * @param referenceMethod org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration
 * @param targetClassFile org.eclipse.jdt.internal.compiler.codegen.ClassFile

	this.preserveUnusedLocals = referenceMethod.scope.compilerOptions().preserveAllLocalVariables;
	initializeMaxLocals(referenceMethod.binding);
}

public void reset(ClassFile givenClassFile) {
	this.targetLevel = givenClassFile.targetJDK;
	int produceAttributes = givenClassFile.produceAttributes;

		this.lineSeparatorPositions = null;
	}
}

/**
 * @param targetClassFile The given classfile to reset the code stream
 */

	init(targetClassFile);
	initializeMaxLocals(null);
}

public void resetInWideMode() {
	this.wideMode = true;
}

private final void resizeByteArray() {
	int length = this.bCodeStream.length;
	int requiredSize = length + length;

	}
	System.arraycopy(this.bCodeStream, 0, this.bCodeStream = new byte[requiredSize], 0, length);
}

final public void ret(int index) {
	if (DEBUG) System.out.println(this.position + "\t\tret:"+index); //$NON-NLS-1$
	this.countLabels = 0;
	if (index > 255) { // Widen
		if (this.classFileOffset + 3 >= this.bCodeStream.length) {

		this.bCodeStream[this.classFileOffset++] = (byte) index;
	}
}

public void return_() {
	if (DEBUG) System.out.println(this.position + "\t\treturn"); //$NON-NLS-1$
	this.countLabels = 0;
	// the stackDepth should be equal to 0
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_return;
	this.lastAbruptCompletion = this.position;
}

public void saload() {
	if (DEBUG) System.out.println(this.position + "\t\tsaload"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_saload;
}

public void sastore() {
	if (DEBUG) System.out.println(this.position + "\t\tsastore"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth -= 3;
	if (this.classFileOffset >= this.bCodeStream.length) {

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_sastore;
}

/**
 * @param operatorConstant int
 * @param type_ID int

}

public void sipush(int s) {
	if (DEBUG) System.out.println(this.position + "\t\tsipush:"+s); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth++;
	if (this.stackDepth > this.stackMax)

	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_sipush;
	writeSignedShort(s);
}

public void store(LocalVariableBinding localBinding, boolean valueRequired) {
	int localPosition = localBinding.resolvedPosition;
	// Using dedicated int bytecode

			}
	}
}

public void swap() {
	if (DEBUG) System.out.println(this.position + "\t\tswap"); //$NON-NLS-1$
	this.countLabels = 0;
	if (this.classFileOffset >= this.bCodeStream.length) {
		resizeByteArray();

	this.position++;
	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_swap;
}

public void tableswitch(CaseLabel defaultLabel, int low, int high, int[] keys, int[] sortedIndexes, CaseLabel[] casesLabel) {
	if (DEBUG) System.out.println(this.position + "\t\ttableswitch"); //$NON-NLS-1$
	this.countLabels = 0;
	this.stackDepth--;
	int length = casesLabel.length;

		i++;
	}
}

public void throwAnyException(LocalVariableBinding anyExceptionVariable) {
	this.load(anyExceptionVariable);
	athrow();
}

public String toString() {
	StringBuffer buffer = new StringBuffer("( position:"); //$NON-NLS-1$
	buffer.append(this.position);

	buffer.append(")"); //$NON-NLS-1$
	return buffer.toString();
}

/**
 * Note: it will walk the locals table and extend the end range for all matching ones, no matter if
 * visible or not.

		}
	}
}

protected void writePosition(BranchLabel label) {
	int offset = label.position - this.position + 1;
	if (Math.abs(offset) > 0x7FFF && !this.wideMode) {

		this.writePosition(label, forwardRefs[i]);
	}
}

protected void writePosition(BranchLabel label, int forwardReference) {
	final int offset = label.position - forwardReference + 1;
	if (Math.abs(offset) > 0x7FFF && !this.wideMode) {

		this.writeSignedShort(forwardReference, offset);
	}
}

/**
 * Write a signed 16 bits value into the byte array
 * @param value the signed short

	this.bCodeStream[this.classFileOffset++] = (byte) (value >> 8);
	this.bCodeStream[this.classFileOffset++] = (byte) value;
}

private final void writeSignedShort(int pos, int value) {
	int currentOffset = this.startingClassFileOffset + pos;
	if (currentOffset + 1 >= this.bCodeStream.length) {

	this.bCodeStream[currentOffset] = (byte) (value >> 8);
	this.bCodeStream[currentOffset + 1] = (byte) value;
}

protected final void writeSignedWord(int value) {
	// we keep the resize in here because it is used outside the code stream
	if (this.classFileOffset + 3 >= this.bCodeStream.length) {

	this.bCodeStream[this.classFileOffset++] = (byte) ((value & 0xFF00) >> 8);
	this.bCodeStream[this.classFileOffset++] = (byte) (value & 0xFF);
}

protected void writeSignedWord(int pos, int value) {
	int currentOffset = this.startingClassFileOffset + pos;
	if (currentOffset + 3 >= this.bCodeStream.length) {

	this.bCodeStream[currentOffset++] = (byte) ((value & 0xFF00) >> 8);
	this.bCodeStream[currentOffset++] = (byte) (value & 0xFF);
}

/**
 * Write a unsigned 16 bits value into the byte array
 * @param value the unsigned short

	this.bCodeStream[this.classFileOffset++] = (byte) (value >>> 8);
	this.bCodeStream[this.classFileOffset++] = (byte) value;
}

protected void writeWidePosition(BranchLabel label) {
	int labelPos = label.position;
	int offset = labelPos - this.position + 1;

		this.writeSignedWord(forward, offset);
	}
}
public void resetInWideMode() {
	this.wideMode = true;
}
}

Lines 27-33 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/codegen/ExceptionLabel.java (-1 lines)
27	public void place() {	27	public void place() {
28	// register the handler inside the codeStream then normal place	28	// register the handler inside the codeStream then normal place
29	this.codeStream.registerExceptionHandler(this);	29	this.codeStream.registerExceptionHandler(this);
30	if (CodeStream.DEBUG) System.out.println("\t\t\t\t<place at: "+this.codeStream.position+" - "+ this); //$NON-NLS-1$ //$NON-NLS-2$
31	this.position = this.codeStream.getPosition();	30	this.position = this.codeStream.getPosition();
32	}	31	}
33		32

Lines 120-125 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/codegen/ConstantPool.java (-4 / +6 lines)
120	public static final char[] HasNextSignature = "()Z".toCharArray();//$NON-NLS-1$	120	public static final char[] HasNextSignature = "()Z".toCharArray();//$NON-NLS-1$
121	public static final char[] Init = "<init>".toCharArray(); //$NON-NLS-1$	121	public static final char[] Init = "<init>".toCharArray(); //$NON-NLS-1$
122	public static final char[] IntConstrSignature = "(I)V".toCharArray(); //$NON-NLS-1$	122	public static final char[] IntConstrSignature = "(I)V".toCharArray(); //$NON-NLS-1$
		123	public static final char[] ITERATOR_NAME = "iterator".toCharArray(); //$NON-NLS-1$
		124	public static final char[] ITERATOR_SIGNATURE = "()Ljava/util/Iterator;".toCharArray(); //$NON-NLS-1$
123	public static final char[] Intern = "intern".toCharArray(); //$NON-NLS-1$	125	public static final char[] Intern = "intern".toCharArray(); //$NON-NLS-1$
124	public static final char[] InternSignature = GetMessageSignature;	126	public static final char[] InternSignature = GetMessageSignature;
125	public static final char[] IntIntegerSignature = "(I)Ljava/lang/Integer;".toCharArray(); //$NON-NLS-1$	127	public static final char[] IntIntegerSignature = "(I)Ljava/lang/Integer;".toCharArray(); //$NON-NLS-1$
Lines 685-695 Link Here
685	}	687	}
686	return index;	688	return index;
687	}	689	}
688	public int literalIndexForMethod(TypeBinding binding, char[] selector, char[] signature, boolean isInterface) {	690	public int literalIndexForMethod(TypeBinding declaringClass, char[] selector, char[] signature, boolean isInterface) {
689	if (binding.isNestedType()) {	691	if (declaringClass.isNestedType()) {
690	this.classFile.recordInnerClasses(binding);	692	this.classFile.recordInnerClasses(declaringClass);
691	}	693	}
692	return this.literalIndexForMethod(binding.constantPoolName(), selector, signature, isInterface);	694	return this.literalIndexForMethod(declaringClass.constantPoolName(), selector, signature, isInterface);
693	}	695	}
694	public int literalIndexForNameAndType(char[] name, char[] signature) {	696	public int literalIndexForNameAndType(char[] name, char[] signature) {
695	int index;	697	int index;

Lines 181-187 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/codegen/BranchLabel.java (-1 lines)
181	* Place the label. If we have forward references resolve them.	181	* Place the label. If we have forward references resolve them.
182	*/	182	*/
183	public void place() { // Currently lacking wide support.	183	public void place() { // Currently lacking wide support.
184	if (CodeStream.DEBUG) System.out.println("\t\t\t\t<place at: "+this.codeStream.position+" - "+ this); //$NON-NLS-1$ //$NON-NLS-2$
185	// if ((this.tagBits & USED) == 0 && this.forwardReferenceCount == 0) {	184	// if ((this.tagBits & USED) == 0 && this.forwardReferenceCount == 0) {
186	// return;	185	// return;
187	// }	186	// }

Lines 44-50 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/Reference.java (-2 / +2 lines)
44	if (syntheticWriteAccessor == null) {	44	if (syntheticWriteAccessor == null) {
45	codeStream.putstatic(fieldBinding);	45	codeStream.putstatic(fieldBinding);
46	} else {	46	} else {
47	codeStream.invokestatic(syntheticWriteAccessor);	47	codeStream.invoke(Opcodes.OPC_invokestatic, syntheticWriteAccessor, null /* default declaringClass */);
48	}	48	}
49	} else { // Stack: [owner][new field value] ---> [new field value][owner][new field value]	49	} else { // Stack: [owner][new field value] ---> [new field value][owner][new field value]
50	if (valueRequired) {	50	if (valueRequired) {
Lines 57-63 Link Here
57	if (syntheticWriteAccessor == null) {	57	if (syntheticWriteAccessor == null) {
58	codeStream.putfield(fieldBinding);	58	codeStream.putfield(fieldBinding);
59	} else {	59	} else {
60	codeStream.invokestatic(syntheticWriteAccessor);	60	codeStream.invoke(Opcodes.OPC_invokestatic, syntheticWriteAccessor, null /* default declaringClass */);
61	}	61	}
62	}	62	}
63	codeStream.recordPositionsFrom(pc, this.sourceStart);	63	codeStream.recordPositionsFrom(pc, this.sourceStart);




import org.eclipse.jdt.internal.compiler.ASTVisitor;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
import org.eclipse.jdt.internal.compiler.codegen.Opcodes;
import org.eclipse.jdt.internal.compiler.flow.FlowContext;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;

					if ((this.syntheticAccessors == null) || (this.syntheticAccessors[SingleNameReference.READ] == null)) {
						codeStream.getstatic(fieldBinding);
					} else {
						codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);
					}
				} else {
					if (!valueRequired

					if ((this.syntheticAccessors == null) || (this.syntheticAccessors[SingleNameReference.READ] == null)) {
						codeStream.getfield(fieldBinding);
					} else {
						codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);
					}
				}
				break;

				if ((this.syntheticAccessors == null) || (this.syntheticAccessors[SingleNameReference.READ] == null)) {
					codeStream.getstatic(fieldBinding);
				} else {
					codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);
				}
			} else {
				if ((this.bits & ASTNode.DepthMASK) != 0) {

				if ((this.syntheticAccessors == null) || (this.syntheticAccessors[SingleNameReference.READ] == null)) {
					codeStream.getfield(fieldBinding);
				} else {
					codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);
				}
			}
			break;

				if ((this.syntheticAccessors == null) || (this.syntheticAccessors[SingleNameReference.READ] == null)) {
					codeStream.getstatic(fieldBinding);
				} else {
					codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);
				}
			} else {
				if ((this.bits & ASTNode.DepthMASK) != 0) {

				if ((this.syntheticAccessors == null) || (this.syntheticAccessors[SingleNameReference.READ] == null)) {
					codeStream.getfield(fieldBinding);
				} else {
					codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);
				}
			}
			TypeBinding operandType;




import org.eclipse.jdt.internal.compiler.ASTVisitor;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
import org.eclipse.jdt.internal.compiler.codegen.Opcodes;
import org.eclipse.jdt.internal.compiler.flow.FlowContext;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.impl.Constant;


		// invoke constructor
		if (this.syntheticAccessor == null) {
			codeStream.invoke(Opcodes.OPC_invokespecial, this.codegenBinding, null /* default declaringClass */);
		} else {
			// synthetic accessor got some extra arguments appended to its signature, which need values
			for (int i = 0,

				i++) {
				codeStream.aconst_null();
			}
			codeStream.invoke(Opcodes.OPC_invokespecial, this.syntheticAccessor, null /* default declaringClass */);
		}
		if (valueRequired) {
			codeStream.generateImplicitConversion(this.implicitConversion);

Lines 156-162 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/SwitchStatement.java (-1 / +1 lines)
156	if (resolvedType.isEnum()) {	156	if (resolvedType.isEnum()) {
157	if (needSwitch) {	157	if (needSwitch) {
158	// go through the translation table	158	// go through the translation table
159	codeStream.invokestatic(this.synthetic);	159	codeStream.invoke(Opcodes.OPC_invokestatic, this.synthetic, null /* default declaringClass */);
160	this.expression.generateCode(currentScope, codeStream, true);	160	this.expression.generateCode(currentScope, codeStream, true);
161	// get enum constant ordinal()	161	// get enum constant ordinal()
162	codeStream.invokeEnumOrdinal(resolvedType.constantPoolName());	162	codeStream.invokeEnumOrdinal(resolvedType.constantPoolName());

Lines 115-121 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/AllocationExpression.java (-2 / +2 lines)
115	}	115	}
116	// invoke constructor	116	// invoke constructor
117	if (this.syntheticAccessor == null) {	117	if (this.syntheticAccessor == null) {
118	codeStream.invokespecial(this.codegenBinding);	118	codeStream.invoke(Opcodes.OPC_invokespecial, this.codegenBinding, null /* default declaringClass */);
119	} else {	119	} else {
120	// synthetic accessor got some extra arguments appended to its signature, which need values	120	// synthetic accessor got some extra arguments appended to its signature, which need values
121	for (int i = 0,	121	for (int i = 0,
Lines 124-130 Link Here
124	i++) {	124	i++) {
125	codeStream.aconst_null();	125	codeStream.aconst_null();
126	}	126	}
127	codeStream.invokespecial(this.syntheticAccessor);	127	codeStream.invoke(Opcodes.OPC_invokespecial, this.syntheticAccessor, null /* default declaringClass */);
128	}	128	}
129	if (valueRequired) {	129	if (valueRequired) {
130	codeStream.generateImplicitConversion(this.implicitConversion);	130	codeStream.generateImplicitConversion(this.implicitConversion);





import org.eclipse.jdt.internal.compiler.ASTVisitor;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
import org.eclipse.jdt.internal.compiler.codegen.BranchLabel;
import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
import org.eclipse.jdt.internal.compiler.flow.FlowContext;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.flow.LoopingFlowContext;

import org.eclipse.jdt.internal.compiler.lookup.Binding;
import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
import org.eclipse.jdt.internal.compiler.lookup.LocalVariableBinding;
import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
import org.eclipse.jdt.internal.compiler.lookup.ParameterizedTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;


	int postCollectionInitStateIndex = -1;
	int mergedInitStateIndex = -1;
	
	public ForeachStatement(
		LocalDeclaration elementVariable,
		int start) {

			case GENERIC_ITERABLE :
				this.collection.generateCode(this.scope, codeStream, true);
				// declaringClass.iterator();
				codeStream.invokeIterableIterator(this.iteratorReceiverType);
					new MethodBinding(
							ClassFileConstants.AccPublic,
							"iterator".toCharArray(),//$NON-NLS-1$
							this.scope.getJavaUtilIterator(),
							Binding.NO_PARAMETERS,
							Binding.NO_EXCEPTIONS,
							(ReferenceBinding) this.iteratorReceiverType.erasure());
				if (this.iteratorReceiverType.isInterface()) {
					codeStream.invokeinterface(iteratorMethodBinding);
				} else {
					codeStream.invokevirtual(iteratorMethodBinding);
				}
				codeStream.store(this.indexVariable, false);
				codeStream.addVariable(this.indexVariable);
				break;




import org.eclipse.jdt.internal.compiler.ASTVisitor;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
import org.eclipse.jdt.internal.compiler.codegen.Opcodes;
import org.eclipse.jdt.internal.compiler.flow.FlowContext;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.lookup.Binding;

					i++) {
					codeStream.aconst_null();
				}
				codeStream.invoke(Opcodes.OPC_invokespecial, this.syntheticAccessor, null /* default declaringClass */);
			} else {
				codeStream.invoke(Opcodes.OPC_invokespecial, this.codegenBinding, null /* default declaringClass */);
			}
			codeStream.recordPositionsFrom(pc, this.sourceStart);
		} finally {




import org.eclipse.jdt.internal.compiler.ASTVisitor;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
import org.eclipse.jdt.internal.compiler.codegen.Opcodes;
import org.eclipse.jdt.internal.compiler.flow.FlowContext;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;

					codeStream.getfield(this.codegenBinding);
				}
			} else {
				codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[FieldReference.READ], null /* default declaringClass */);
			}
			// required cast must occur even if no value is required
			if (this.genericCast != null) codeStream.checkcast(this.genericCast);

					if (accessor == null) {
						codeStream.getstatic(this.codegenBinding);
					} else {
						codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
					}
					switch (this.codegenBinding.type.id) {
						case T_long :

		if (this.syntheticAccessors == null || this.syntheticAccessors[FieldReference.READ] == null) {
			codeStream.getstatic(this.codegenBinding);
		} else {
			codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[FieldReference.READ], null /* default declaringClass */);
		}
	} else {
		codeStream.dup();
		if (this.syntheticAccessors == null || this.syntheticAccessors[FieldReference.READ] == null) {
			codeStream.getfield(this.codegenBinding);
		} else {
			codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[FieldReference.READ], null /* default declaringClass */);
		}
	}
	int operationTypeID;

		if (this.syntheticAccessors == null || this.syntheticAccessors[FieldReference.READ] == null) {
			codeStream.getstatic(this.codegenBinding);
		} else {
			codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[FieldReference.READ], null /* default declaringClass */);
		}
	} else {
		codeStream.dup();
		if (this.syntheticAccessors == null || this.syntheticAccessors[FieldReference.READ] == null) {
			codeStream.getfield(this.codegenBinding);
		} else {
			codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[FieldReference.READ], null /* default declaringClass */);
		}
	}
	TypeBinding operandType;




import org.eclipse.jdt.internal.compiler.ASTVisitor;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
import org.eclipse.jdt.internal.compiler.codegen.Opcodes;
import org.eclipse.jdt.internal.compiler.flow.FlowContext;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;

import org.eclipse.jdt.internal.compiler.lookup.SourceTypeBinding;
import org.eclipse.jdt.internal.compiler.lookup.TagBits;
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.problem.ProblemSeverities;


	    		? compileTimeType  // unboxing: checkcast before conversion
	    		: runtimeTimeType;
	        this.valueCast = originalType.genericCast(targetType);
		} 	else if (this.binding == scope.environment().arrayClone
				&& runtimeTimeType.id != TypeIds.T_JavaLangObject
				&& scope.compilerOptions().sourceLevel >= ClassFileConstants.JDK1_5) {
					// from 1.5 source level on, array#clone() resolves to array type, but codegen to #clone()Object - thus require extra inserted cast
						&& CharOperation.equals(this.binding.selector, TypeConstants.CLONE)) {
					// from 1.5 compliant mode on, array#clone() resolves to array type, but codegen to #clone()Object - thus require extra inserted cast
			this.valueCast = runtimeTimeType;
		}
        if (this.valueCast instanceof ReferenceBinding) {

	}
	// generate arguments
	generateArguments(this.binding, this.arguments, currentScope, codeStream);

	// actual message invocation
	if (this.syntheticAccessor == null){
		TypeBinding constantPoolDeclaringClass = getConstantPoolDeclaringClass(currentScope);
		if (isStatic){
			codeStream.invoke(Opcodes.OPC_invokestatic, this.codegenBinding, constantPoolDeclaringClass);
		} else if( (this.receiver.isSuper()) || this.codegenBinding.isPrivate()){
			codeStream.invoke(Opcodes.OPC_invokespecial, this.codegenBinding, constantPoolDeclaringClass);
		} else {
			if (constantPoolDeclaringClass.isInterface()) { // interface or annotation type
				codeStream.invoke(Opcodes.OPC_invokeinterface, this.codegenBinding, constantPoolDeclaringClass);
			} else {
				codeStream.invoke(Opcodes.OPC_invokevirtual, this.codegenBinding, constantPoolDeclaringClass);
					codeStream.invokeinterface(this.codegenBinding);
				} else {
					codeStream.invokevirtual(this.codegenBinding);
				}
			}
		}
	} else {
		codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessor, null /* default declaringClass */);
	}
	// required cast must occur even if no value is required
	if (this.valueCast != null) codeStream.checkcast(this.valueCast);

	}
	codeStream.recordPositionsFrom(pc, (int)(this.nameSourcePosition >>> 32)); // highlight selector
}

/**
 * @see org.eclipse.jdt.internal.compiler.lookup.InvocationSite#genericTypeArguments()
 */

	return this.genericTypeArguments;
}

protected TypeBinding getConstantPoolDeclaringClass(BlockScope currentScope) {
	// constantpool declaringClass
	TypeBinding constantPoolDeclaringClass = this.codegenBinding.declaringClass;
	// Post 1.4.0 target, array clone() invocations are qualified with array type
	// This is handled in array type #clone method binding resolution (see Scope and UpdatedMethodBinding)
	if (this.codegenBinding == currentScope.environment().arrayClone) {
		CompilerOptions options = currentScope.compilerOptions();
		if (options.sourceLevel > ClassFileConstants.JDK1_4 ) {
			constantPoolDeclaringClass = this.actualReceiverType.erasure();
		}
	} else {
		// if the binding declaring class is not visible, need special action
		// for runtime compatibility on 1.2 VMs : change the declaring class of the binding
		// NOTE: from target 1.2 on, method's declaring class is touched if any different from receiver type
		// and not from Object or implicit static method call.
		if (constantPoolDeclaringClass != this.actualReceiverType && this.receiverGenericCast == null && !this.actualReceiverType.isArrayType()) {
			CompilerOptions options = currentScope.compilerOptions();
			if ((options.targetJDK >= ClassFileConstants.JDK1_2
						&& (options.complianceLevel >= ClassFileConstants.JDK1_4 || !(this.receiver.isImplicitThis() && this.codegenBinding.isStatic()))
						&& this.binding.declaringClass.id != TypeIds.T_JavaLangObject) // no change for Object methods
					|| !this.binding.declaringClass.canBeSeenBy(currentScope)) {
				constantPoolDeclaringClass = this.actualReceiverType.erasure();
			}
		}				
	}
	return constantPoolDeclaringClass;
}

public boolean isSuperAccess() {
	return this.receiver.isSuper();
}

			return;
		}
	}

	// if the binding declaring class is not visible, need special action
	// for runtime compatibility on 1.2 VMs : change the declaring class of the binding
	// NOTE: from target 1.2 on, method's declaring class is touched if any different from receiver type
	// and not from Object or implicit static method call.
	if (this.binding.declaringClass != this.actualReceiverType
			&& this.receiverGenericCast == null
			&& !this.actualReceiverType.isArrayType()) {
		CompilerOptions options = currentScope.compilerOptions();
		if ((options.targetJDK >= ClassFileConstants.JDK1_2
				&& (options.complianceLevel >= ClassFileConstants.JDK1_4 || !(this.receiver.isImplicitThis() && this.codegenBinding.isStatic()))
				&& this.binding.declaringClass.id != TypeIds.T_JavaLangObject) // no change for Object methods
			|| !this.binding.declaringClass.canBeSeenBy(currentScope)) {

			this.codegenBinding = currentScope.enclosingSourceType().getUpdatedMethodBinding(
			        										this.codegenBinding, (ReferenceBinding) this.actualReceiverType.erasure());
		}
		// Post 1.4.0 target, array clone() invocations are qualified with array type
		// This is handled in array type #clone method binding resolution (see Scope and UpdatedMethodBinding)
	}
}
public int nullStatus(FlowInfo flowInfo) {
	return FlowInfo.UNKNOWN;

	if (isMethodUseDeprecated(this.binding, scope, true))
		scope.problemReporter().deprecatedMethod(this.binding, this);

	// from 1.5 source level on, array#clone() returns the array type (but binding still shows Object)
	if (this.binding == scope.environment().arrayClone && compilerOptions.sourceLevel >= ClassFileConstants.JDK1_5) {
			&& this.binding.parameters == Binding.NO_PARAMETERS
			&& compilerOptions.complianceLevel >= ClassFileConstants.JDK1_5
			&& CharOperation.equals(this.binding.selector, TypeConstants.CLONE)) {
		this.resolvedType = this.actualReceiverType;
	} else {
		TypeBinding returnType = this.binding.returnType;




import org.eclipse.jdt.internal.compiler.ASTVisitor;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
import org.eclipse.jdt.internal.compiler.codegen.Opcodes;
import org.eclipse.jdt.internal.compiler.flow.FlowContext;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;

								codeStream.getfield(lastFieldBinding);
							}
						} else {
							codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
						}
						if (requiredGenericCast != null) codeStream.checkcast(requiredGenericCast);
						if (valueRequired) {

		if (accessor == null) {
			codeStream.getstatic(lastFieldBinding);
		} else {
			codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
		}
	} else {
		codeStream.dup();
		if (accessor == null) {
			codeStream.getfield(lastFieldBinding);
		} else {
			codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
		}
	}
	// the last field access is a write access

		if (accessor == null) {
			codeStream.getstatic(lastFieldBinding);
		} else {
			codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
		}
	} else {
		codeStream.dup();
		if (accessor == null) {
			codeStream.getfield(lastFieldBinding);
		} else {
			codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
		}
	}
	TypeBinding requiredGenericCast = getGenericCast(this.otherCodegenBindings == null ? 0 : this.otherCodegenBindings.length);

								codeStream.getfield(lastFieldBinding);
							}
						} else {
							codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
						}
						if (lastGenericCast != null) codeStream.checkcast(lastGenericCast);
						if (!needValue) codeStream.pop();

									if (accessor == null) {
										codeStream.getstatic(lastFieldBinding);
									} else {
										codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
									}
									codeStream.pop();
								}

Lines 14-19 Link Here

(-)eval/org/eclipse/jdt/internal/eval/CodeSnippetReturnStatement.java (-1 / +2 lines)
14	import org.eclipse.jdt.internal.compiler.ast.ReturnStatement;	14	import org.eclipse.jdt.internal.compiler.ast.ReturnStatement;
15	import org.eclipse.jdt.internal.compiler.ast.TryStatement;	15	import org.eclipse.jdt.internal.compiler.ast.TryStatement;
16	import org.eclipse.jdt.internal.compiler.codegen.CodeStream;	16	import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
		17	import org.eclipse.jdt.internal.compiler.codegen.Opcodes;
17	import org.eclipse.jdt.internal.compiler.flow.FlowContext;	18	import org.eclipse.jdt.internal.compiler.flow.FlowContext;
18	import org.eclipse.jdt.internal.compiler.flow.FlowInfo;	19	import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
19	import org.eclipse.jdt.internal.compiler.impl.Constant;	20	import org.eclipse.jdt.internal.compiler.impl.Constant;
Lines 83-89 Link Here
83	}	84	}
84		85
85	// generate the invoke virtual to "setResult(Object,Class)"	86	// generate the invoke virtual to "setResult(Object,Class)"
86	codeStream.invokevirtual(this.setResultMethod);	87	codeStream.invoke(Opcodes.OPC_invokevirtual, this.setResultMethod, null /* default declaringClass */);
87	}	88	}
88	/**	89	/**
89	* @see org.eclipse.jdt.internal.compiler.lookup.InvocationSite#genericTypeArguments()	90	* @see org.eclipse.jdt.internal.compiler.lookup.InvocationSite#genericTypeArguments()




import org.eclipse.jdt.internal.compiler.ast.QualifiedNameReference;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
import org.eclipse.jdt.internal.compiler.codegen.Opcodes;
import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.impl.Constant;

			if (accessor == null) {
				codeStream.getstatic(lastFieldBinding);
			} else {
				codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
			}
		} else {
			codeStream.dup();
			if (accessor == null) {
				codeStream.getfield(lastFieldBinding);
			} else {
				codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
			}
		}


Lines 17-22 Link Here

(-)eval/org/eclipse/jdt/internal/eval/CodeSnippetMessageSend.java (-11 / +11 lines)
17	import org.eclipse.jdt.internal.compiler.ast.NameReference;	17	import org.eclipse.jdt.internal.compiler.ast.NameReference;
18	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;	18	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
19	import org.eclipse.jdt.internal.compiler.codegen.CodeStream;	19	import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
		20	import org.eclipse.jdt.internal.compiler.codegen.Opcodes;
20	import org.eclipse.jdt.internal.compiler.flow.FlowInfo;	21	import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
21	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;	22	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
22	import org.eclipse.jdt.internal.compiler.impl.Constant;	23	import org.eclipse.jdt.internal.compiler.impl.Constant;
Lines 32-38 Link Here
32	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;	33	import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
33	import org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding;	34	import org.eclipse.jdt.internal.compiler.lookup.TypeVariableBinding;
34		35
35	public class CodeSnippetMessageSend extends MessageSend implements ProblemReasons, EvaluationConstants {	36	public class CodeSnippetMessageSend extends MessageSend {
36	EvaluationContext evaluationContext;	37	EvaluationContext evaluationContext;
37	FieldBinding delegateThis;	38	FieldBinding delegateThis;
38	/**	39	/**
Lines 78-94 Link Here
78	// generate arguments	79	// generate arguments
79	generateArguments(this.binding, this.arguments, currentScope, codeStream);	80	generateArguments(this.binding, this.arguments, currentScope, codeStream);
80	// actual message invocation	81	// actual message invocation
		82	TypeBinding constantPoolDeclaringClass = getConstantPoolDeclaringClass(currentScope);
81	if (isStatic) {	83	if (isStatic) {
82	codeStream.invokestatic(this.codegenBinding);	84	codeStream.invoke(Opcodes.OPC_invokestatic, this.codegenBinding, constantPoolDeclaringClass);
		85	} else if( (this.receiver.isSuper()) \|\| this.codegenBinding.isPrivate()){
		86	codeStream.invoke(Opcodes.OPC_invokespecial, this.codegenBinding, constantPoolDeclaringClass);
83	} else {	87	} else {
84	if (this.receiver.isSuper()) {	88	if (constantPoolDeclaringClass.isInterface()) { // interface or annotation type
85	codeStream.invokespecial(this.codegenBinding);	89	codeStream.invoke(Opcodes.OPC_invokeinterface, this.codegenBinding, constantPoolDeclaringClass);
86	} else {	90	} else {
87	if (this.codegenBinding.declaringClass.isInterface()) {	91	codeStream.invoke(Opcodes.OPC_invokevirtual, this.codegenBinding, constantPoolDeclaringClass);
88	codeStream.invokeinterface(this.codegenBinding);
89	} else {
90	codeStream.invokevirtual(this.codegenBinding);
91	}
92	}	92	}
93	}	93	}
94	} else {	94	} else {
Lines 273-281 Link Here
273	: scope.getMethod(this.actualReceiverType, this.selector, argumentTypes, this);	273	: scope.getMethod(this.actualReceiverType, this.selector, argumentTypes, this);
274	if (!this.binding.isValidBinding()) {	274	if (!this.binding.isValidBinding()) {
275	if (this.binding instanceof ProblemMethodBinding	275	if (this.binding instanceof ProblemMethodBinding
276	&& ((ProblemMethodBinding) this.binding).problemId() == NotVisible) {	276	&& ((ProblemMethodBinding) this.binding).problemId() == ProblemReasons.NotVisible) {
277	if (this.evaluationContext.declaringTypeName != null) {	277	if (this.evaluationContext.declaringTypeName != null) {
278	this.delegateThis = scope.getField(scope.enclosingSourceType(), DELEGATE_THIS, this);	278	this.delegateThis = scope.getField(scope.enclosingSourceType(), EvaluationConstants.DELEGATE_THIS, this);
279	if (this.delegateThis == null){ // if not found then internal error, field should have been found	279	if (this.delegateThis == null){ // if not found then internal error, field should have been found
280	this.constant = Constant.NotAConstant;	280	this.constant = Constant.NotAConstant;
281	scope.problemReporter().invalidMethod(this, this.binding);	281	scope.problemReporter().invalidMethod(this, this.binding);

Lines 14-19 Link Here

(-)eval/org/eclipse/jdt/internal/eval/CodeSnippetAllocationExpression.java (-1 / +2 lines)
14	import org.eclipse.jdt.internal.compiler.ast.CastExpression;	14	import org.eclipse.jdt.internal.compiler.ast.CastExpression;
15	import org.eclipse.jdt.internal.compiler.ast.Expression;	15	import org.eclipse.jdt.internal.compiler.ast.Expression;
16	import org.eclipse.jdt.internal.compiler.codegen.CodeStream;	16	import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
		17	import org.eclipse.jdt.internal.compiler.codegen.Opcodes;
17	import org.eclipse.jdt.internal.compiler.flow.FlowInfo;	18	import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
18	import org.eclipse.jdt.internal.compiler.impl.Constant;	19	import org.eclipse.jdt.internal.compiler.impl.Constant;
19	import org.eclipse.jdt.internal.compiler.lookup.Binding;	20	import org.eclipse.jdt.internal.compiler.lookup.Binding;
Lines 73-79 Link Here
73	this);	74	this);
74	}	75	}
75	// invoke constructor	76	// invoke constructor
76	codeStream.invokespecial(this.codegenBinding);	77	codeStream.invoke(Opcodes.OPC_invokespecial, this.codegenBinding, null /* default declaringClass */);
77	} else {	78	} else {
78	// private emulation using reflect	79	// private emulation using reflect
79	codeStream.generateEmulationForConstructor(currentScope, this.codegenBinding);	80	codeStream.generateEmulationForConstructor(currentScope, this.codegenBinding);

Lines 271-277 Link Here

(-)eval/org/eclipse/jdt/internal/eval/CodeSnippetScope.java (-3 / +3 lines)
271	if (!((ReferenceBinding)leafType).canBeSeenBy(this)) {	271	if (!((ReferenceBinding)leafType).canBeSeenBy(this)) {
272	return new ProblemFieldBinding((ReferenceBinding)leafType, fieldName, ProblemReasons.ReceiverTypeNotVisible);	272	return new ProblemFieldBinding((ReferenceBinding)leafType, fieldName, ProblemReasons.ReceiverTypeNotVisible);
273	}	273	}
274	if (CharOperation.equals(fieldName, LENGTH))	274	if (CharOperation.equals(fieldName, TypeConstants.LENGTH))
275	return ArrayBinding.ArrayLength;	275	return ArrayBinding.ArrayLength;
276	return null;	276	return null;
277	}	277	}
Lines 371-378 Link Here
371	MethodBinding methodBinding = object.getExactMethod(selector, argumentTypes, null);	371	MethodBinding methodBinding = object.getExactMethod(selector, argumentTypes, null);
372	if (methodBinding != null) {	372	if (methodBinding != null) {
373	// handle the method clone() specially... cannot be protected or throw exceptions	373	// handle the method clone() specially... cannot be protected or throw exceptions
374	if (argumentTypes == Binding.NO_PARAMETERS && CharOperation.equals(selector, CLONE))	374	if (argumentTypes == Binding.NO_PARAMETERS && CharOperation.equals(selector, TypeConstants.CLONE))
375	return new MethodBinding((methodBinding.modifiers & ~ClassFileConstants.AccProtected) \| ClassFileConstants.AccPublic, CLONE, methodBinding.returnType, argumentTypes, null, object);	375	return new MethodBinding((methodBinding.modifiers & ~ClassFileConstants.AccProtected) \| ClassFileConstants.AccPublic, TypeConstants.CLONE, methodBinding.returnType, argumentTypes, null, object);
376	if (canBeSeenByForCodeSnippet(methodBinding, receiverType, invocationSite, this))	376	if (canBeSeenByForCodeSnippet(methodBinding, receiverType, invocationSite, this))
377	return methodBinding;	377	return methodBinding;
378	}	378	}




	return uniqueKey;
}

/*
 * Answer the declaring class to use in the constant pool
 * may not be a reference binding (see subtypes)
 */
public TypeBinding constantPoolDeclaringClass() {
	return this.declaringClass;
}

/* Answer the receiver's constant pool name.
*
* <init> for constructors




	int numberOfImports = numberOfStatements + 1;
	for (int i = 0; i < numberOfStatements; i++) {
		ImportReference importReference = this.referenceContext.imports[i];
		if (((importReference.bits & ASTNode.OnDemand) != 0) && CharOperation.equals(TypeConstants.JAVA_LANG, importReference.tokens) && !importReference.isStatic()) {
			numberOfImports--;
			break;
		}

	int numberOfImports = numberOfStatements + 1;
	for (int i = 0; i < numberOfStatements; i++) {
		ImportReference importReference = this.referenceContext.imports[i];
		if (((importReference.bits & ASTNode.OnDemand) != 0) && CharOperation.equals(TypeConstants.JAVA_LANG, importReference.tokens) && !importReference.isStatic()) {
			numberOfImports--;
			break;
		}

	// initialize the default imports if necessary... share the default java.lang.* import
	if (this.environment.defaultImports != null) return this.environment.defaultImports;

	Binding importBinding = this.environment.getTopLevelPackage(TypeConstants.JAVA);
	if (importBinding != null)
		importBinding = ((PackageBinding) importBinding).getTypeOrPackage(TypeConstants.JAVA_LANG[1]);

	if (importBinding == null || !importBinding.isValidBinding()) {
		// create a proxy for the missing BinaryType
		problemReporter().isClassPathCorrect(
				TypeConstants.JAVA_LANG_OBJECT,
			this.referenceContext,
			this.environment.missingClassFileLocation);
		BinaryTypeBinding missingObject = this.environment.createMissingType(null, TypeConstants.JAVA_LANG_OBJECT);
		importBinding = missingObject.fPackage;
	}

	return this.environment.defaultImports = new ImportBinding[] {new ImportBinding(TypeConstants.JAVA_LANG, true, importBinding, null)};
}
// NOT Public API
public final Binding getImport(char[][] compoundName, boolean onDemand, boolean isStaticImport) {




/*******************************************************************************
 * Copyright (c) 2000, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.lookup;

public class UpdatedMethodBinding extends MethodBinding {

	public TypeBinding updatedDeclaringClass;

	public UpdatedMethodBinding(TypeBinding updatedDeclaringClass, int modifiers, char[] selector, TypeBinding returnType, TypeBinding[] args, ReferenceBinding[] exceptions, ReferenceBinding declaringClass) {
		super(modifiers, selector, returnType, args, exceptions, declaringClass);
		this.updatedDeclaringClass = updatedDeclaringClass;
	}

	public TypeBinding constantPoolDeclaringClass() {
		return this.updatedDeclaringClass;
	}
}




	private final static int METHOD_EMUL = 0;
	private final static int FIELD_EMUL = 1;
	private final static int CLASS_LITERAL_EMUL = 2;
	/** @deprecated */
	private final static int RECEIVER_TYPE_EMUL = 3;

	private final static int MAX_SYNTHETICS = 4;

public ReferenceBinding[] memberTypes() {
	return this.memberTypes;
}
/** @deprecated */
public FieldBinding getUpdatedFieldBinding(FieldBinding targetField, ReferenceBinding newDeclaringClass) {
	if (this.synthetics == null)
		this.synthetics = new HashMap[MAX_SYNTHETICS];

	}
	return updatedField;
}
/** @deprecated */
public MethodBinding getUpdatedMethodBinding(MethodBinding targetMethod, ReferenceBinding newDeclaringClass) {
	if (this.synthetics == null)
		this.synthetics = new HashMap[MAX_SYNTHETICS];




import org.eclipse.jdt.internal.compiler.util.ObjectVector;
import org.eclipse.jdt.internal.compiler.util.SimpleSet;

public abstract class Scope {

	/* Scope kinds */
	public final static int BLOCK_SCOPE = 1;

			// special treatment for Object.getClass() in 1.5 mode (substitute parameterized return type)
			if (receiverType.isInterface() || exactMethod.canBeSeenBy(receiverType, invocationSite, this)) {
				if (argumentTypes == Binding.NO_PARAMETERS
				    && CharOperation.equals(selector, TypeConstants.GETCLASS)
				    && exactMethod.returnType.isParameterizedType()/*1.5*/) {
						return ParameterizedMethodBinding.instantiateGetClass(receiverType, exactMethod, this);
			    }

			if (leafType instanceof ReferenceBinding)
				if (!((ReferenceBinding) leafType).canBeSeenBy(this))
					return new ProblemFieldBinding((ReferenceBinding)leafType, fieldName, ProblemReasons.ReceiverTypeNotVisible);
			if (CharOperation.equals(fieldName, TypeConstants.LENGTH)) {
				if ((leafType.tagBits & TagBits.HasMissingType) != 0) {
					return new ProblemFieldBinding(ArrayBinding.ArrayLength, null, fieldName, ProblemReasons.NotFound);
				}

			if (argumentTypes == Binding.NO_PARAMETERS) {
			    switch (selector[0]) {
			        case 'c':
			            if (CharOperation.equals(selector, TypeConstants.CLONE)) {
			            	return environment().computeArrayClone(methodBinding);
								compilerOptions().targetJDK >= ClassFileConstants.JDK1_4 ? (TypeBinding)receiverType : (TypeBinding)object, // remember its array type for codegen purpose on target>=1.4.0
								(methodBinding.modifiers & ~ClassFileConstants.AccProtected) | ClassFileConstants.AccPublic,
								CLONE,
								methodBinding.returnType,
								argumentTypes,
								null,
								object);
			            }
			            break;
			        case 'g':
			            if (CharOperation.equals(selector, TypeConstants.GETCLASS) && methodBinding.returnType.isParameterizedType()/*1.5*/) {
							return ParameterizedMethodBinding.instantiateGetClass(receiverType, methodBinding, this);
			            }
			            break;

										}
										// special treatment for Object.getClass() in 1.5 mode (substitute parameterized return type)
										if (argumentTypes == Binding.NO_PARAMETERS
										    && CharOperation.equals(selector, TypeConstants.GETCLASS)
										    && methodBinding.returnType.isParameterizedType()/*1.5*/) {
												return ParameterizedMethodBinding.instantiateGetClass(receiverType, methodBinding, this);
										}


	public final ReferenceBinding getJavaIoSerializable() {
		CompilationUnitScope unitScope = compilationUnitScope();
		unitScope.recordQualifiedReference(TypeConstants.JAVA_IO_SERIALIZABLE);
		return unitScope.environment.getResolvedType(TypeConstants.JAVA_IO_SERIALIZABLE, this);
	}

	public final ReferenceBinding getJavaLangAnnotationAnnotation() {
		CompilationUnitScope unitScope = compilationUnitScope();
		unitScope.recordQualifiedReference(TypeConstants.JAVA_LANG_ANNOTATION_ANNOTATION);
		return unitScope.environment.getResolvedType(TypeConstants.JAVA_LANG_ANNOTATION_ANNOTATION, this);
	}

	public final ReferenceBinding getJavaLangAssertionError() {
		CompilationUnitScope unitScope = compilationUnitScope();
		unitScope.recordQualifiedReference(TypeConstants.JAVA_LANG_ASSERTIONERROR);
		return unitScope.environment.getResolvedType(TypeConstants.JAVA_LANG_ASSERTIONERROR, this);
	}

	public final ReferenceBinding getJavaLangClass() {
		CompilationUnitScope unitScope = compilationUnitScope();
		unitScope.recordQualifiedReference(TypeConstants.JAVA_LANG_CLASS);
		return unitScope.environment.getResolvedType(TypeConstants.JAVA_LANG_CLASS, this);
	}

	public final ReferenceBinding getJavaLangCloneable() {
		CompilationUnitScope unitScope = compilationUnitScope();
		unitScope.recordQualifiedReference(TypeConstants.JAVA_LANG_CLONEABLE);
		return unitScope.environment.getResolvedType(TypeConstants.JAVA_LANG_CLONEABLE, this);
	}
	public final ReferenceBinding getJavaLangEnum() {
		CompilationUnitScope unitScope = compilationUnitScope();
		unitScope.recordQualifiedReference(TypeConstants.JAVA_LANG_ENUM);
		return unitScope.environment.getResolvedType(TypeConstants.JAVA_LANG_ENUM, this);
	}

	public final ReferenceBinding getJavaLangIterable() {
		CompilationUnitScope unitScope = compilationUnitScope();
		unitScope.recordQualifiedReference(TypeConstants.JAVA_LANG_ITERABLE);
		return unitScope.environment.getResolvedType(TypeConstants.JAVA_LANG_ITERABLE, this);
	}
	public final ReferenceBinding getJavaLangObject() {
		CompilationUnitScope unitScope = compilationUnitScope();
		unitScope.recordQualifiedReference(TypeConstants.JAVA_LANG_OBJECT);
		return unitScope.environment.getResolvedType(TypeConstants.JAVA_LANG_OBJECT, this);
	}

	public final ReferenceBinding getJavaLangString() {
		CompilationUnitScope unitScope = compilationUnitScope();
		unitScope.recordQualifiedReference(TypeConstants.JAVA_LANG_STRING);
		return unitScope.environment.getResolvedType(TypeConstants.JAVA_LANG_STRING, this);
	}

	public final ReferenceBinding getJavaLangThrowable() {
		CompilationUnitScope unitScope = compilationUnitScope();
		unitScope.recordQualifiedReference(TypeConstants.JAVA_LANG_THROWABLE);
		return unitScope.environment.getResolvedType(TypeConstants.JAVA_LANG_THROWABLE, this);
	}
	public final ReferenceBinding getJavaUtilIterator() {
		CompilationUnitScope unitScope = compilationUnitScope();
		unitScope.recordQualifiedReference(TypeConstants.JAVA_UTIL_ITERATOR);
		return unitScope.environment.getResolvedType(TypeConstants.JAVA_UTIL_ITERATOR, this);
	}

	/* Answer the type binding corresponding to the typeName argument, relative to the enclosingType.


			// special treatment for Object.getClass() in 1.5 mode (substitute parameterized return type)
			if (argumentTypes == Binding.NO_PARAMETERS
			    && CharOperation.equals(selector, TypeConstants.GETCLASS)
			    && methodBinding.returnType.isParameterizedType()/*1.5*/) {
					return ParameterizedMethodBinding.instantiateGetClass(receiverType, methodBinding, this);
		    }

			case 0 : return TypeBinding.VOID;
			case 1 : return mecs[0];
			case 2 :
				if ((commonDim == 0 ? mecs[1].id : mecs[1].leafComponentType().id) == TypeIds.T_JavaLangObject) return mecs[0];
				if ((commonDim == 0 ? mecs[0].id : mecs[0].leafComponentType().id) == TypeIds.T_JavaLangObject) return mecs[1];
		}
		TypeBinding[] otherBounds = new TypeBinding[count - 1];
		int rank = 0;

			if (dim > 0) {
				leafType = typeToVisit.leafComponentType();
				switch(leafType.id) {
					case TypeIds.T_JavaLangObject:
						if (dim > 1) { // Object[][] supertype is Object[]
							TypeBinding elementType = ((ArrayBinding)typeToVisit).elementsType();
							if (!typesToVisit.contains(elementType)) {

							continue;
						}
						//$FALL-THROUGH$
					case TypeIds.T_byte:
					case TypeIds.T_short:
					case TypeIds.T_char:
					case TypeIds.T_boolean:
					case TypeIds.T_int:
					case TypeIds.T_long:
					case TypeIds.T_float:
					case TypeIds.T_double:
						TypeBinding superType = getJavaIoSerializable();
						if (!typesToVisit.contains(superType)) {
							typesToVisit.add(superType);

				TypeBinding erasedSuperType = erasedSuperTypes[j];
				if (erasedSuperType == null) continue nextSuperType;
				TypeBinding match;
				if (erasedSuperType == otherType || erasedSuperType.id == TypeIds.T_JavaLangObject && otherType.isInterface()) {
					match = erasedSuperType;
				} else {
					if (erasedSuperType.isArrayType()) {

					TypeBinding otherType = erasedSuperTypes[j];
					if (otherType == null) continue nextOtherType;
					if (erasedSuperType instanceof ReferenceBinding) {
						if (otherType.id == TypeIds.T_JavaLangObject && erasedSuperType.isInterface()) continue nextOtherType; // keep Object for an interface
						if (erasedSuperType.findSuperTypeOriginatingFrom(otherType) != null) {
							erasedSuperTypes[j] = null; // discard non minimal supertype
							remaining--;
						}
					} else if (erasedSuperType.isArrayType()) {
					if (otherType.isArrayType() // keep Object[...] for an interface array (same dimensions)
							&& otherType.leafComponentType().id == TypeIds.T_JavaLangObject
							&& otherType.dimensions() == erasedSuperType.dimensions()
							&& erasedSuperType.leafComponentType().isInterface()) continue nextOtherType;
						if (erasedSuperType.findSuperTypeOriginatingFrom(otherType) != null) {

Lines 62-67 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/LookupEnvironment.java (-1 / +15 lines)
62	private CompilationUnitDeclaration[] units = new CompilationUnitDeclaration[4];	62	private CompilationUnitDeclaration[] units = new CompilationUnitDeclaration[4];
63	private MethodVerifier verifier;	63	private MethodVerifier verifier;
64		64
		65	public MethodBinding arrayClone;
		66
65	final static int BUILD_FIELDS_AND_METHODS = 4;	67	final static int BUILD_FIELDS_AND_METHODS = 4;
66	final static int BUILD_TYPE_HIERARCHY = 1;	68	final static int BUILD_TYPE_HIERARCHY = 1;
67	final static int CHECK_AND_SET_IMPORTS = 2;	69	final static int CHECK_AND_SET_IMPORTS = 2;
Lines 251-257 Link Here
251	parsedUnit.scope.buildFieldsAndMethods();	253	parsedUnit.scope.buildFieldsAndMethods();
252	this.unitBeingCompleted = null;	254	this.unitBeingCompleted = null;
253	}	255	}
254		256	public MethodBinding computeArrayClone(MethodBinding objectClone) {
		257	if (this.arrayClone == null) {
		258	this.arrayClone = new MethodBinding(
		259	(objectClone.modifiers & ~ClassFileConstants.AccProtected) \| ClassFileConstants.AccPublic,
		260	TypeConstants.CLONE,
		261	objectClone.returnType,
		262	Binding.NO_PARAMETERS,
		263	Binding.NO_EXCEPTIONS, // no exception for array specific method
		264	(ReferenceBinding)objectClone.returnType);
		265	}
		266	return this.arrayClone;
		267
		268	}
255	public TypeBinding computeBoxingType(TypeBinding type) {	269	public TypeBinding computeBoxingType(TypeBinding type) {
256	TypeBinding boxedType;	270	TypeBinding boxedType;
257	switch (type.id) {	271	switch (type.id) {




	 * Compute the resolved positions for all the synthetic arguments
	 */
	final public void computeSyntheticArgumentSlotSizes() {

		int slotSize = 0;
		// insert enclosing instances first, followed by the outerLocals
		int enclosingInstancesCount = this.enclosingInstances == null ? 0 : this.enclosingInstances.length;

	/* Answer the receiver's enclosing type... null if the receiver is a top level type.
	*/
	public ReferenceBinding enclosingType() {

		return this.enclosingType;
	}

	/* Answer the synthetic argument for <actualOuterLocalVariable> or null if one does not exist.
	*/
	public SyntheticArgumentBinding getSyntheticArgument(LocalVariableBinding actualOuterLocalVariable) {

		if (this.outerLocalVariables == null) return null;		// is null if no outer local variables are known

		for (int i = this.outerLocalVariables.length; --i >= 0;)
			if (this.outerLocalVariables[i].actualOuterLocalVariable == actualOuterLocalVariable)
				return this.outerLocalVariables[i];

	public ReferenceBinding[] syntheticEnclosingInstanceTypes() {
		if (this.enclosingInstances == null)
			return null;

		int length = this.enclosingInstances.length;
		ReferenceBinding types[] = new ReferenceBinding[length];
		for (int i = 0; i < length; i++)

	/* Answer the synthetic argument for <targetEnclosingType> or null if one does not exist.
	*/
	public SyntheticArgumentBinding getSyntheticArgument(ReferenceBinding targetEnclosingType, boolean onlyExactMatch) {

		if (this.enclosingInstances == null) return null;		// is null if no enclosing instances are known

		// exact match
		for (int i = this.enclosingInstances.length; --i >= 0;)
			if (this.enclosingInstances[i].type == targetEnclosingType)




 *******************************************************************************/
package org.eclipse.jdt.core.tests.compiler.regression;
import java.io.File;
import java.util.Map;

import junit.framework.Test;


		"argument cannot be resolved\n" +
		"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=247307
// Check return type of array#clone()
public void test014() throws Exception {
	Map optionsMap = getCompilerOptions();
	CompilerOptions options = new CompilerOptions(optionsMap);
	if (options.complianceLevel > ClassFileConstants.JDK1_4) {
		// check that #clone() return type is changed ONLY from -source 1.5 only (independant from compliance level)
		optionsMap.put(CompilerOptions.OPTION_Source, CompilerOptions.VERSION_1_4);		
	}	
	this.runNegativeTest(
			new String[] {
				"X.java",
				"public class X {\n" + 
				"	void foo(long[] longs) throws Exception {\n" + 
				"		long[] other = longs.clone();\n" + 
				"	}\n" + 
				"}\n",
			},
			"----------\n" + 
			"1. ERROR in X.java (at line 3)\n" + 
			"	long[] other = longs.clone();\n" + 
			"	               ^^^^^^^^^^^^^\n" + 
			"Type mismatch: cannot convert from Object to long[]\n" + 
			"----------\n",
			null,
			true,
			optionsMap);
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=247307 - variation
//Check return type of array#clone()
public void test015() throws Exception {
	if ( new CompilerOptions(getCompilerOptions()).sourceLevel < ClassFileConstants.JDK1_5) {
		return;
	}
	this.runConformTest(
		new String[] {
			"X.java",
			"public class X {\n" + 
			"	void foo(long[] longs) throws Exception {\n" + 
			"		long[] other = longs.clone();\n" + 
			"	}\n" + 
			"}\n",
		},
		"");
}
//https:bugs.eclipse.org/bugs/show_bug.cgi?id=247307 - variation
//Check constant pool declaring class of array#clone()
public void test016() throws Exception {
	this.runConformTest(
			new String[] {
				"X.java",
				"public class X {\n" + 
				"	void foo(long[] longs) throws Exception {\n" + 
				"		Object other = longs.clone();\n" + 
				"	}\n" + 
				"}\n",
			},
			"");
	ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
	byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(new File(OUTPUT_DIR + File.separator  +"X.class"));
	String actualOutput =
		disassembler.disassemble(
			classFileBytes,
			"\n",
			ClassFileBytesDisassembler.DETAILED);

	String expectedOutput =	new CompilerOptions(getCompilerOptions()).sourceLevel <= ClassFileConstants.JDK1_4
		?	"  // Method descriptor #15 ([J)V\n" + 
			"  // Stack: 1, Locals: 3\n" + 
			"  void foo(long[] longs) throws java.lang.Exception;\n" + 
			"    0  aload_1 [longs]\n" + 
			"    1  invokevirtual java.lang.Object.clone() : java.lang.Object [19]\n" + 
			"    4  astore_2 [other]\n" + 
			"    5  return\n" + 
			"      Line numbers:\n" + 
			"        [pc: 0, line: 3]\n" + 
			"        [pc: 5, line: 4]\n"
		:	"  // Method descriptor #15 ([J)V\n" + 
			"  // Stack: 1, Locals: 3\n" + 
			"  void foo(long[] longs) throws java.lang.Exception;\n" + 
			"    0  aload_1 [longs]\n" + 
			"    1  invokevirtual long[].clone() : java.lang.Object [19]\n" + 
			"    4  astore_2 [other]\n" + 
			"    5  return\n" + 
			"      Line numbers:\n" + 
			"        [pc: 0, line: 3]\n" + 
			"        [pc: 5, line: 4]\n";

	int index = actualOutput.indexOf(expectedOutput);
	if (index == -1 || expectedOutput.length() == 0) {
		System.out.println(Util.displayString(actualOutput, 3));
	}
	if (index == -1) {
		assertEquals("unexpected bytecode sequence", expectedOutput, actualOutput);
	}		
	return;
}

//https://bugs.eclipse.org/bugs/show_bug.cgi?id=247307 - variation
//Check constant pool declaring class of array#clone()
public void test017() throws Exception {
	Map optionsMap = getCompilerOptions();
	CompilerOptions options = new CompilerOptions(optionsMap);
	if (options.complianceLevel > ClassFileConstants.JDK1_4) {
		// check that #clone() return type is changed ONLY from -source 1.5 only (independant from compliance level)
		optionsMap.put(CompilerOptions.OPTION_Source, CompilerOptions.VERSION_1_4);		
	}
	this.runConformTest(
			new String[] {
				"X.java",
				"public class X {\n" + 
				"	void foo(long[] longs) throws Exception {\n" + 
				"		Object other = longs.clone();\n" + 
				"	}\n" + 
				"}\n",
			},
			"",
			null,
			true,
			null,
			optionsMap,
			null);
	ClassFileBytesDisassembler disassembler = ToolFactory.createDefaultClassFileBytesDisassembler();
	byte[] classFileBytes = org.eclipse.jdt.internal.compiler.util.Util.getFileByteContent(new File(OUTPUT_DIR + File.separator  +"X.class"));
	String actualOutput =
		disassembler.disassemble(
			classFileBytes,
			"\n",
			ClassFileBytesDisassembler.DETAILED);

	String expectedOutput =
		"  // Method descriptor #15 ([J)V\n" + 
		"  // Stack: 1, Locals: 3\n" + 
		"  void foo(long[] longs) throws java.lang.Exception;\n" + 
		"    0  aload_1 [longs]\n" + 
		"    1  invokevirtual java.lang.Object.clone() : java.lang.Object [19]\n" + 
		"    4  astore_2 [other]\n" + 
		"    5  return\n" + 
		"      Line numbers:\n" + 
		"        [pc: 0, line: 3]\n" + 
		"        [pc: 5, line: 4]\n";

	int index = actualOutput.indexOf(expectedOutput);
	if (index == -1 || expectedOutput.length() == 0) {
		System.out.println(Util.displayString(actualOutput, 3));
	}
	if (index == -1) {
		assertEquals("unexpected bytecode sequence", expectedOutput, actualOutput);
	}		
}
}

Lines 1423-1430 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/Compliance_1_4.java (-2 / +3 lines)
1423	"\n",	1423	"\n",
1424	ClassFileBytesDisassembler.DETAILED);	1424	ClassFileBytesDisassembler.DETAILED);
1425		1425
1426	String expectedOutput =	1426	String expectedOutput = new CompilerOptions(getCompilerOptions()).sourceLevel <= ClassFileConstants.JDK1_4
1427	" 1 invokevirtual java.lang.String[].clone() : java.lang.Object [16]\n";	1427	? " 1 invokevirtual java.lang.Object.clone() : java.lang.Object [16]\n"
		1428	: " 1 invokevirtual java.lang.String[].clone() : java.lang.Object [16]\n";
1428		1429
1429	int index = actualOutput.indexOf(expectedOutput);	1430	int index = actualOutput.indexOf(expectedOutput);
1430	if (index == -1 \|\| expectedOutput.length() == 0) {	1431	if (index == -1 \|\| expectedOutput.length() == 0) {

Return to bug 247292

Lines 14-19 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/SingleNameReference.java (-6 / +7 lines)
14	import org.eclipse.jdt.internal.compiler.ASTVisitor;	14	import org.eclipse.jdt.internal.compiler.ASTVisitor;
15	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;	15	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
16	import org.eclipse.jdt.internal.compiler.codegen.CodeStream;	16	import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
		17	import org.eclipse.jdt.internal.compiler.codegen.Opcodes;
17	import org.eclipse.jdt.internal.compiler.flow.FlowContext;	18	import org.eclipse.jdt.internal.compiler.flow.FlowContext;
18	import org.eclipse.jdt.internal.compiler.flow.FlowInfo;	19	import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
19	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;	20	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
Lines 377-383 Link Here
377	if ((this.syntheticAccessors == null) \|\| (this.syntheticAccessors[SingleNameReference.READ] == null)) {	378	if ((this.syntheticAccessors == null) \|\| (this.syntheticAccessors[SingleNameReference.READ] == null)) {
378	codeStream.getstatic(fieldBinding);	379	codeStream.getstatic(fieldBinding);
379	} else {	380	} else {
380	codeStream.invokestatic(this.syntheticAccessors[SingleNameReference.READ]);	381	codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);
381	}	382	}
382	} else {	383	} else {
383	if (!valueRequired	384	if (!valueRequired
Lines 399-405 Link Here
399	if ((this.syntheticAccessors == null) \|\| (this.syntheticAccessors[SingleNameReference.READ] == null)) {	400	if ((this.syntheticAccessors == null) \|\| (this.syntheticAccessors[SingleNameReference.READ] == null)) {
400	codeStream.getfield(fieldBinding);	401	codeStream.getfield(fieldBinding);
401	} else {	402	} else {
402	codeStream.invokestatic(this.syntheticAccessors[SingleNameReference.READ]);	403	codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);
403	}	404	}
404	}	405	}
405	break;	406	break;
Lines 474-480 Link Here
474	if ((this.syntheticAccessors == null) \|\| (this.syntheticAccessors[SingleNameReference.READ] == null)) {	475	if ((this.syntheticAccessors == null) \|\| (this.syntheticAccessors[SingleNameReference.READ] == null)) {
475	codeStream.getstatic(fieldBinding);	476	codeStream.getstatic(fieldBinding);
476	} else {	477	} else {
477	codeStream.invokestatic(this.syntheticAccessors[SingleNameReference.READ]);	478	codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);
478	}	479	}
479	} else {	480	} else {
480	if ((this.bits & ASTNode.DepthMASK) != 0) {	481	if ((this.bits & ASTNode.DepthMASK) != 0) {
Lines 488-494 Link Here
488	if ((this.syntheticAccessors == null) \|\| (this.syntheticAccessors[SingleNameReference.READ] == null)) {	489	if ((this.syntheticAccessors == null) \|\| (this.syntheticAccessors[SingleNameReference.READ] == null)) {
489	codeStream.getfield(fieldBinding);	490	codeStream.getfield(fieldBinding);
490	} else {	491	} else {
491	codeStream.invokestatic(this.syntheticAccessors[SingleNameReference.READ]);	492	codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);
492	}	493	}
493	}	494	}
494	break;	495	break;
Lines 587-593 Link Here
587	if ((this.syntheticAccessors == null) \|\| (this.syntheticAccessors[SingleNameReference.READ] == null)) {	588	if ((this.syntheticAccessors == null) \|\| (this.syntheticAccessors[SingleNameReference.READ] == null)) {
588	codeStream.getstatic(fieldBinding);	589	codeStream.getstatic(fieldBinding);
589	} else {	590	} else {
590	codeStream.invokestatic(this.syntheticAccessors[SingleNameReference.READ]);	591	codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);
591	}	592	}
592	} else {	593	} else {
593	if ((this.bits & ASTNode.DepthMASK) != 0) {	594	if ((this.bits & ASTNode.DepthMASK) != 0) {
Lines 601-607 Link Here
601	if ((this.syntheticAccessors == null) \|\| (this.syntheticAccessors[SingleNameReference.READ] == null)) {	602	if ((this.syntheticAccessors == null) \|\| (this.syntheticAccessors[SingleNameReference.READ] == null)) {
602	codeStream.getfield(fieldBinding);	603	codeStream.getfield(fieldBinding);
603	} else {	604	} else {
604	codeStream.invokestatic(this.syntheticAccessors[SingleNameReference.READ]);	605	codeStream.invoke(Opcodes.OPC_invokestatic, this.syntheticAccessors[SingleNameReference.READ], null /* default declaringClass */);
605	}	606	}
606	}	607	}
607	TypeBinding operandType;	608	TypeBinding operandType;

Lines 14-19 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/ast/QualifiedNameReference.java (-7 / +8 lines)
14	import org.eclipse.jdt.internal.compiler.ASTVisitor;	14	import org.eclipse.jdt.internal.compiler.ASTVisitor;
15	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;	15	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
16	import org.eclipse.jdt.internal.compiler.codegen.CodeStream;	16	import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
		17	import org.eclipse.jdt.internal.compiler.codegen.Opcodes;
17	import org.eclipse.jdt.internal.compiler.flow.FlowContext;	18	import org.eclipse.jdt.internal.compiler.flow.FlowContext;
18	import org.eclipse.jdt.internal.compiler.flow.FlowInfo;	19	import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
19	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;	20	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
Lines 401-407 Link Here
401	codeStream.getfield(lastFieldBinding);	402	codeStream.getfield(lastFieldBinding);
402	}	403	}
403	} else {	404	} else {
404	codeStream.invokestatic(accessor);	405	codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
405	}	406	}
406	if (requiredGenericCast != null) codeStream.checkcast(requiredGenericCast);	407	if (requiredGenericCast != null) codeStream.checkcast(requiredGenericCast);
407	if (valueRequired) {	408	if (valueRequired) {
Lines 452-465 Link Here
452	if (accessor == null) {	453	if (accessor == null) {
453	codeStream.getstatic(lastFieldBinding);	454	codeStream.getstatic(lastFieldBinding);
454	} else {	455	} else {
455	codeStream.invokestatic(accessor);	456	codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
456	}	457	}
457	} else {	458	} else {
458	codeStream.dup();	459	codeStream.dup();
459	if (accessor == null) {	460	if (accessor == null) {
460	codeStream.getfield(lastFieldBinding);	461	codeStream.getfield(lastFieldBinding);
461	} else {	462	} else {
462	codeStream.invokestatic(accessor);	463	codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
463	}	464	}
464	}	465	}
465	// the last field access is a write access	466	// the last field access is a write access
Lines 501-514 Link Here
501	if (accessor == null) {	502	if (accessor == null) {
502	codeStream.getstatic(lastFieldBinding);	503	codeStream.getstatic(lastFieldBinding);
503	} else {	504	} else {
504	codeStream.invokestatic(accessor);	505	codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
505	}	506	}
506	} else {	507	} else {
507	codeStream.dup();	508	codeStream.dup();
508	if (accessor == null) {	509	if (accessor == null) {
509	codeStream.getfield(lastFieldBinding);	510	codeStream.getfield(lastFieldBinding);
510	} else {	511	} else {
511	codeStream.invokestatic(accessor);	512	codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
512	}	513	}
513	}	514	}
514	TypeBinding requiredGenericCast = getGenericCast(this.otherCodegenBindings == null ? 0 : this.otherCodegenBindings.length);	515	TypeBinding requiredGenericCast = getGenericCast(this.otherCodegenBindings == null ? 0 : this.otherCodegenBindings.length);
Lines 628-634 Link Here
628	codeStream.getfield(lastFieldBinding);	629	codeStream.getfield(lastFieldBinding);
629	}	630	}
630	} else {	631	} else {
631	codeStream.invokestatic(accessor);	632	codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
632	}	633	}
633	if (lastGenericCast != null) codeStream.checkcast(lastGenericCast);	634	if (lastGenericCast != null) codeStream.checkcast(lastGenericCast);
634	if (!needValue) codeStream.pop();	635	if (!needValue) codeStream.pop();
Lines 641-647 Link Here
641	if (accessor == null) {	642	if (accessor == null) {
642	codeStream.getstatic(lastFieldBinding);	643	codeStream.getstatic(lastFieldBinding);
643	} else {	644	} else {
644	codeStream.invokestatic(accessor);	645	codeStream.invoke(Opcodes.OPC_invokestatic, accessor, null /* default declaringClass */);
645	}	646	}
646	codeStream.pop();	647	codeStream.pop();
647	}	648	}

Lines 391-404 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/MethodBinding.java (-8 lines)
391	return uniqueKey;	391	return uniqueKey;
392	}	392	}
393		393
394	/*
395	* Answer the declaring class to use in the constant pool
396	* may not be a reference binding (see subtypes)
397	*/
398	public TypeBinding constantPoolDeclaringClass() {
399	return this.declaringClass;
400	}
401
402	/* Answer the receiver's constant pool name.	394	/* Answer the receiver's constant pool name.
403	*	395	*
404	* <init> for constructors	396	* <init> for constructors

Lines 23-29 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/Scope.java (-51 / +44 lines)
23	import org.eclipse.jdt.internal.compiler.util.ObjectVector;	23	import org.eclipse.jdt.internal.compiler.util.ObjectVector;
24	import org.eclipse.jdt.internal.compiler.util.SimpleSet;	24	import org.eclipse.jdt.internal.compiler.util.SimpleSet;
25		25
26	public abstract class Scope implements TypeConstants, TypeIds {	26	public abstract class Scope {
27		27
28	/* Scope kinds */	28	/* Scope kinds */
29	public final static int BLOCK_SCOPE = 1;	29	public final static int BLOCK_SCOPE = 1;
Lines 781-787 Link Here
781	// special treatment for Object.getClass() in 1.5 mode (substitute parameterized return type)	781	// special treatment for Object.getClass() in 1.5 mode (substitute parameterized return type)
782	if (receiverType.isInterface() \|\| exactMethod.canBeSeenBy(receiverType, invocationSite, this)) {	782	if (receiverType.isInterface() \|\| exactMethod.canBeSeenBy(receiverType, invocationSite, this)) {
783	if (argumentTypes == Binding.NO_PARAMETERS	783	if (argumentTypes == Binding.NO_PARAMETERS
784	&& CharOperation.equals(selector, GETCLASS)	784	&& CharOperation.equals(selector, TypeConstants.GETCLASS)
785	&& exactMethod.returnType.isParameterizedType()/1.5/) {	785	&& exactMethod.returnType.isParameterizedType()/1.5/) {
786	return ParameterizedMethodBinding.instantiateGetClass(receiverType, exactMethod, this);	786	return ParameterizedMethodBinding.instantiateGetClass(receiverType, exactMethod, this);
787	}	787	}
Lines 832-838 Link Here
832	if (leafType instanceof ReferenceBinding)	832	if (leafType instanceof ReferenceBinding)
833	if (!((ReferenceBinding) leafType).canBeSeenBy(this))	833	if (!((ReferenceBinding) leafType).canBeSeenBy(this))
834	return new ProblemFieldBinding((ReferenceBinding)leafType, fieldName, ProblemReasons.ReceiverTypeNotVisible);	834	return new ProblemFieldBinding((ReferenceBinding)leafType, fieldName, ProblemReasons.ReceiverTypeNotVisible);
835	if (CharOperation.equals(fieldName, LENGTH)) {	835	if (CharOperation.equals(fieldName, TypeConstants.LENGTH)) {
836	if ((leafType.tagBits & TagBits.HasMissingType) != 0) {	836	if ((leafType.tagBits & TagBits.HasMissingType) != 0) {
837	return new ProblemFieldBinding(ArrayBinding.ArrayLength, null, fieldName, ProblemReasons.NotFound);	837	return new ProblemFieldBinding(ArrayBinding.ArrayLength, null, fieldName, ProblemReasons.NotFound);
838	}	838	}
Lines 1314-1332 Link Here
1314	if (argumentTypes == Binding.NO_PARAMETERS) {	1314	if (argumentTypes == Binding.NO_PARAMETERS) {
1315	switch (selector[0]) {	1315	switch (selector[0]) {
1316	case 'c':	1316	case 'c':
1317	if (CharOperation.equals(selector, CLONE)) {	1317	if (CharOperation.equals(selector, TypeConstants.CLONE)) {
1318	return new UpdatedMethodBinding(	1318	return environment().computeArrayClone(methodBinding);
1319	compilerOptions().targetJDK >= ClassFileConstants.JDK1_4 ? (TypeBinding)receiverType : (TypeBinding)object, // remember its array type for codegen purpose on target>=1.4.0
1320	(methodBinding.modifiers & ~ClassFileConstants.AccProtected) \| ClassFileConstants.AccPublic,
1321	CLONE,
1322	methodBinding.returnType,
1323	argumentTypes,
1324	null,
1325	object);
1326	}	1319	}
1327	break;	1320	break;
1328	case 'g':	1321	case 'g':
1329	if (CharOperation.equals(selector, GETCLASS) && methodBinding.returnType.isParameterizedType()/1.5/) {	1322	if (CharOperation.equals(selector, TypeConstants.GETCLASS) && methodBinding.returnType.isParameterizedType()/1.5/) {
1330	return ParameterizedMethodBinding.instantiateGetClass(receiverType, methodBinding, this);	1323	return ParameterizedMethodBinding.instantiateGetClass(receiverType, methodBinding, this);
1331	}	1324	}
1332	break;	1325	break;
Lines 1854-1860 Link Here
1854	}	1847	}
1855	// special treatment for Object.getClass() in 1.5 mode (substitute parameterized return type)	1848	// special treatment for Object.getClass() in 1.5 mode (substitute parameterized return type)
1856	if (argumentTypes == Binding.NO_PARAMETERS	1849	if (argumentTypes == Binding.NO_PARAMETERS
1857	&& CharOperation.equals(selector, GETCLASS)	1850	&& CharOperation.equals(selector, TypeConstants.GETCLASS)
1858	&& methodBinding.returnType.isParameterizedType()/1.5/) {	1851	&& methodBinding.returnType.isParameterizedType()/1.5/) {
1859	return ParameterizedMethodBinding.instantiateGetClass(receiverType, methodBinding, this);	1852	return ParameterizedMethodBinding.instantiateGetClass(receiverType, methodBinding, this);
1860	}	1853	}
Lines 2014-2078 Link Here
2014		2007
2015	public final ReferenceBinding getJavaIoSerializable() {	2008	public final ReferenceBinding getJavaIoSerializable() {
2016	CompilationUnitScope unitScope = compilationUnitScope();	2009	CompilationUnitScope unitScope = compilationUnitScope();
2017	unitScope.recordQualifiedReference(JAVA_IO_SERIALIZABLE);	2010	unitScope.recordQualifiedReference(TypeConstants.JAVA_IO_SERIALIZABLE);
2018	return unitScope.environment.getResolvedType(JAVA_IO_SERIALIZABLE, this);	2011	return unitScope.environment.getResolvedType(TypeConstants.JAVA_IO_SERIALIZABLE, this);
2019	}	2012	}
2020		2013
2021	public final ReferenceBinding getJavaLangAnnotationAnnotation() {	2014	public final ReferenceBinding getJavaLangAnnotationAnnotation() {
2022	CompilationUnitScope unitScope = compilationUnitScope();	2015	CompilationUnitScope unitScope = compilationUnitScope();
2023	unitScope.recordQualifiedReference(JAVA_LANG_ANNOTATION_ANNOTATION);	2016	unitScope.recordQualifiedReference(TypeConstants.JAVA_LANG_ANNOTATION_ANNOTATION);
2024	return unitScope.environment.getResolvedType(JAVA_LANG_ANNOTATION_ANNOTATION, this);	2017	return unitScope.environment.getResolvedType(TypeConstants.JAVA_LANG_ANNOTATION_ANNOTATION, this);
2025	}	2018	}
2026		2019
2027	public final ReferenceBinding getJavaLangAssertionError() {	2020	public final ReferenceBinding getJavaLangAssertionError() {
2028	CompilationUnitScope unitScope = compilationUnitScope();	2021	CompilationUnitScope unitScope = compilationUnitScope();
2029	unitScope.recordQualifiedReference(JAVA_LANG_ASSERTIONERROR);	2022	unitScope.recordQualifiedReference(TypeConstants.JAVA_LANG_ASSERTIONERROR);
2030	return unitScope.environment.getResolvedType(JAVA_LANG_ASSERTIONERROR, this);	2023	return unitScope.environment.getResolvedType(TypeConstants.JAVA_LANG_ASSERTIONERROR, this);
2031	}	2024	}
2032		2025
2033	public final ReferenceBinding getJavaLangClass() {	2026	public final ReferenceBinding getJavaLangClass() {
2034	CompilationUnitScope unitScope = compilationUnitScope();	2027	CompilationUnitScope unitScope = compilationUnitScope();
2035	unitScope.recordQualifiedReference(JAVA_LANG_CLASS);	2028	unitScope.recordQualifiedReference(TypeConstants.JAVA_LANG_CLASS);
2036	return unitScope.environment.getResolvedType(JAVA_LANG_CLASS, this);	2029	return unitScope.environment.getResolvedType(TypeConstants.JAVA_LANG_CLASS, this);
2037	}	2030	}
2038		2031
2039	public final ReferenceBinding getJavaLangCloneable() {	2032	public final ReferenceBinding getJavaLangCloneable() {
2040	CompilationUnitScope unitScope = compilationUnitScope();	2033	CompilationUnitScope unitScope = compilationUnitScope();
2041	unitScope.recordQualifiedReference(JAVA_LANG_CLONEABLE);	2034	unitScope.recordQualifiedReference(TypeConstants.JAVA_LANG_CLONEABLE);
2042	return unitScope.environment.getResolvedType(JAVA_LANG_CLONEABLE, this);	2035	return unitScope.environment.getResolvedType(TypeConstants.JAVA_LANG_CLONEABLE, this);
2043	}	2036	}
2044	public final ReferenceBinding getJavaLangEnum() {	2037	public final ReferenceBinding getJavaLangEnum() {
2045	CompilationUnitScope unitScope = compilationUnitScope();	2038	CompilationUnitScope unitScope = compilationUnitScope();
2046	unitScope.recordQualifiedReference(JAVA_LANG_ENUM);	2039	unitScope.recordQualifiedReference(TypeConstants.JAVA_LANG_ENUM);
2047	return unitScope.environment.getResolvedType(JAVA_LANG_ENUM, this);	2040	return unitScope.environment.getResolvedType(TypeConstants.JAVA_LANG_ENUM, this);
2048	}	2041	}
2049		2042
2050	public final ReferenceBinding getJavaLangIterable() {	2043	public final ReferenceBinding getJavaLangIterable() {
2051	CompilationUnitScope unitScope = compilationUnitScope();	2044	CompilationUnitScope unitScope = compilationUnitScope();
2052	unitScope.recordQualifiedReference(JAVA_LANG_ITERABLE);	2045	unitScope.recordQualifiedReference(TypeConstants.JAVA_LANG_ITERABLE);
2053	return unitScope.environment.getResolvedType(JAVA_LANG_ITERABLE, this);	2046	return unitScope.environment.getResolvedType(TypeConstants.JAVA_LANG_ITERABLE, this);
2054	}	2047	}
2055	public final ReferenceBinding getJavaLangObject() {	2048	public final ReferenceBinding getJavaLangObject() {
2056	CompilationUnitScope unitScope = compilationUnitScope();	2049	CompilationUnitScope unitScope = compilationUnitScope();
2057	unitScope.recordQualifiedReference(JAVA_LANG_OBJECT);	2050	unitScope.recordQualifiedReference(TypeConstants.JAVA_LANG_OBJECT);
2058	return unitScope.environment.getResolvedType(JAVA_LANG_OBJECT, this);	2051	return unitScope.environment.getResolvedType(TypeConstants.JAVA_LANG_OBJECT, this);
2059	}	2052	}
2060		2053
2061	public final ReferenceBinding getJavaLangString() {	2054	public final ReferenceBinding getJavaLangString() {
2062	CompilationUnitScope unitScope = compilationUnitScope();	2055	CompilationUnitScope unitScope = compilationUnitScope();
2063	unitScope.recordQualifiedReference(JAVA_LANG_STRING);	2056	unitScope.recordQualifiedReference(TypeConstants.JAVA_LANG_STRING);
2064	return unitScope.environment.getResolvedType(JAVA_LANG_STRING, this);	2057	return unitScope.environment.getResolvedType(TypeConstants.JAVA_LANG_STRING, this);
2065	}	2058	}
2066		2059
2067	public final ReferenceBinding getJavaLangThrowable() {	2060	public final ReferenceBinding getJavaLangThrowable() {
2068	CompilationUnitScope unitScope = compilationUnitScope();	2061	CompilationUnitScope unitScope = compilationUnitScope();
2069	unitScope.recordQualifiedReference(JAVA_LANG_THROWABLE);	2062	unitScope.recordQualifiedReference(TypeConstants.JAVA_LANG_THROWABLE);
2070	return unitScope.environment.getResolvedType(JAVA_LANG_THROWABLE, this);	2063	return unitScope.environment.getResolvedType(TypeConstants.JAVA_LANG_THROWABLE, this);
2071	}	2064	}
2072	public final ReferenceBinding getJavaUtilIterator() {	2065	public final ReferenceBinding getJavaUtilIterator() {
2073	CompilationUnitScope unitScope = compilationUnitScope();	2066	CompilationUnitScope unitScope = compilationUnitScope();
2074	unitScope.recordQualifiedReference(JAVA_UTIL_ITERATOR);	2067	unitScope.recordQualifiedReference(TypeConstants.JAVA_UTIL_ITERATOR);
2075	return unitScope.environment.getResolvedType(JAVA_UTIL_ITERATOR, this);	2068	return unitScope.environment.getResolvedType(TypeConstants.JAVA_UTIL_ITERATOR, this);
2076	}	2069	}
2077		2070
2078	/* Answer the type binding corresponding to the typeName argument, relative to the enclosingType.	2071	/* Answer the type binding corresponding to the typeName argument, relative to the enclosingType.
Lines 2114-2120 Link Here
2114		2107
2115	// special treatment for Object.getClass() in 1.5 mode (substitute parameterized return type)	2108	// special treatment for Object.getClass() in 1.5 mode (substitute parameterized return type)
2116	if (argumentTypes == Binding.NO_PARAMETERS	2109	if (argumentTypes == Binding.NO_PARAMETERS
2117	&& CharOperation.equals(selector, GETCLASS)	2110	&& CharOperation.equals(selector, TypeConstants.GETCLASS)
2118	&& methodBinding.returnType.isParameterizedType()/1.5/) {	2111	&& methodBinding.returnType.isParameterizedType()/1.5/) {
2119	return ParameterizedMethodBinding.instantiateGetClass(receiverType, methodBinding, this);	2112	return ParameterizedMethodBinding.instantiateGetClass(receiverType, methodBinding, this);
2120	}	2113	}
Lines 3038-3045 Link Here
3038	case 0 : return TypeBinding.VOID;	3031	case 0 : return TypeBinding.VOID;
3039	case 1 : return mecs[0];	3032	case 1 : return mecs[0];
3040	case 2 :	3033	case 2 :
3041	if ((commonDim == 0 ? mecs[1].id : mecs[1].leafComponentType().id) == T_JavaLangObject) return mecs[0];	3034	if ((commonDim == 0 ? mecs[1].id : mecs[1].leafComponentType().id) == TypeIds.T_JavaLangObject) return mecs[0];
3042	if ((commonDim == 0 ? mecs[0].id : mecs[0].leafComponentType().id) == T_JavaLangObject) return mecs[1];	3035	if ((commonDim == 0 ? mecs[0].id : mecs[0].leafComponentType().id) == TypeIds.T_JavaLangObject) return mecs[1];
3043	}	3036	}
3044	TypeBinding[] otherBounds = new TypeBinding[count - 1];	3037	TypeBinding[] otherBounds = new TypeBinding[count - 1];
3045	int rank = 0;	3038	int rank = 0;
Lines 3118-3124 Link Here
3118	if (dim > 0) {	3111	if (dim > 0) {
3119	leafType = typeToVisit.leafComponentType();	3112	leafType = typeToVisit.leafComponentType();
3120	switch(leafType.id) {	3113	switch(leafType.id) {
3121	case T_JavaLangObject:	3114	case TypeIds.T_JavaLangObject:
3122	if (dim > 1) { // Object[][] supertype is Object[]	3115	if (dim > 1) { // Object[][] supertype is Object[]
3123	TypeBinding elementType = ((ArrayBinding)typeToVisit).elementsType();	3116	TypeBinding elementType = ((ArrayBinding)typeToVisit).elementsType();
3124	if (!typesToVisit.contains(elementType)) {	3117	if (!typesToVisit.contains(elementType)) {
Lines 3128-3141 Link Here
3128	continue;	3121	continue;
3129	}	3122	}
3130	//$FALL-THROUGH$	3123	//$FALL-THROUGH$
3131	case T_byte:	3124	case TypeIds.T_byte:
3132	case T_short:	3125	case TypeIds.T_short:
3133	case T_char:	3126	case TypeIds.T_char:
3134	case T_boolean:	3127	case TypeIds.T_boolean:
3135	case T_int:	3128	case TypeIds.T_int:
3136	case T_long:	3129	case TypeIds.T_long:
3137	case T_float:	3130	case TypeIds.T_float:
3138	case T_double:	3131	case TypeIds.T_double:
3139	TypeBinding superType = getJavaIoSerializable();	3132	TypeBinding superType = getJavaIoSerializable();
3140	if (!typesToVisit.contains(superType)) {	3133	if (!typesToVisit.contains(superType)) {
3141	typesToVisit.add(superType);	3134	typesToVisit.add(superType);
Lines 3254-3260 Link Here
3254	TypeBinding erasedSuperType = erasedSuperTypes[j];	3247	TypeBinding erasedSuperType = erasedSuperTypes[j];
3255	if (erasedSuperType == null) continue nextSuperType;	3248	if (erasedSuperType == null) continue nextSuperType;
3256	TypeBinding match;	3249	TypeBinding match;
3257	if (erasedSuperType == otherType \|\| erasedSuperType.id == T_JavaLangObject && otherType.isInterface()) {	3250	if (erasedSuperType == otherType \|\| erasedSuperType.id == TypeIds.T_JavaLangObject && otherType.isInterface()) {
3258	match = erasedSuperType;	3251	match = erasedSuperType;
3259	} else {	3252	} else {
3260	if (erasedSuperType.isArrayType()) {	3253	if (erasedSuperType.isArrayType()) {
Lines 3302-3315 Link Here
3302	TypeBinding otherType = erasedSuperTypes[j];	3295	TypeBinding otherType = erasedSuperTypes[j];
3303	if (otherType == null) continue nextOtherType;	3296	if (otherType == null) continue nextOtherType;
3304	if (erasedSuperType instanceof ReferenceBinding) {	3297	if (erasedSuperType instanceof ReferenceBinding) {
3305	if (otherType.id == T_JavaLangObject && erasedSuperType.isInterface()) continue nextOtherType; // keep Object for an interface	3298	if (otherType.id == TypeIds.T_JavaLangObject && erasedSuperType.isInterface()) continue nextOtherType; // keep Object for an interface
3306	if (erasedSuperType.findSuperTypeOriginatingFrom(otherType) != null) {	3299	if (erasedSuperType.findSuperTypeOriginatingFrom(otherType) != null) {
3307	erasedSuperTypes[j] = null; // discard non minimal supertype	3300	erasedSuperTypes[j] = null; // discard non minimal supertype
3308	remaining--;	3301	remaining--;
3309	}	3302	}
3310	} else if (erasedSuperType.isArrayType()) {	3303	} else if (erasedSuperType.isArrayType()) {
3311	if (otherType.isArrayType() // keep Object[...] for an interface array (same dimensions)	3304	if (otherType.isArrayType() // keep Object[...] for an interface array (same dimensions)
3312	&& otherType.leafComponentType().id == T_JavaLangObject	3305	&& otherType.leafComponentType().id == TypeIds.T_JavaLangObject
3313	&& otherType.dimensions() == erasedSuperType.dimensions()	3306	&& otherType.dimensions() == erasedSuperType.dimensions()
3314	&& erasedSuperType.leafComponentType().isInterface()) continue nextOtherType;	3307	&& erasedSuperType.leafComponentType().isInterface()) continue nextOtherType;
3315	if (erasedSuperType.findSuperTypeOriginatingFrom(otherType) != null) {	3308	if (erasedSuperType.findSuperTypeOriginatingFrom(otherType) != null) {

Lines 154-160 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/CompilationUnitScope.java (-7 / +7 lines)
154	int numberOfImports = numberOfStatements + 1;	154	int numberOfImports = numberOfStatements + 1;
155	for (int i = 0; i < numberOfStatements; i++) {	155	for (int i = 0; i < numberOfStatements; i++) {
156	ImportReference importReference = this.referenceContext.imports[i];	156	ImportReference importReference = this.referenceContext.imports[i];
157	if (((importReference.bits & ASTNode.OnDemand) != 0) && CharOperation.equals(JAVA_LANG, importReference.tokens) && !importReference.isStatic()) {	157	if (((importReference.bits & ASTNode.OnDemand) != 0) && CharOperation.equals(TypeConstants.JAVA_LANG, importReference.tokens) && !importReference.isStatic()) {
158	numberOfImports--;	158	numberOfImports--;
159	break;	159	break;
160	}	160	}
Lines 313-319 Link Here
313	int numberOfImports = numberOfStatements + 1;	313	int numberOfImports = numberOfStatements + 1;
314	for (int i = 0; i < numberOfStatements; i++) {	314	for (int i = 0; i < numberOfStatements; i++) {
315	ImportReference importReference = this.referenceContext.imports[i];	315	ImportReference importReference = this.referenceContext.imports[i];
316	if (((importReference.bits & ASTNode.OnDemand) != 0) && CharOperation.equals(JAVA_LANG, importReference.tokens) && !importReference.isStatic()) {	316	if (((importReference.bits & ASTNode.OnDemand) != 0) && CharOperation.equals(TypeConstants.JAVA_LANG, importReference.tokens) && !importReference.isStatic()) {
317	numberOfImports--;	317	numberOfImports--;
318	break;	318	break;
319	}	319	}
Lines 569-589 Link Here
569	// initialize the default imports if necessary... share the default java.lang.* import	569	// initialize the default imports if necessary... share the default java.lang.* import
570	if (this.environment.defaultImports != null) return this.environment.defaultImports;	570	if (this.environment.defaultImports != null) return this.environment.defaultImports;
571		571
572	Binding importBinding = this.environment.getTopLevelPackage(JAVA);	572	Binding importBinding = this.environment.getTopLevelPackage(TypeConstants.JAVA);
573	if (importBinding != null)	573	if (importBinding != null)
574	importBinding = ((PackageBinding) importBinding).getTypeOrPackage(JAVA_LANG[1]);	574	importBinding = ((PackageBinding) importBinding).getTypeOrPackage(TypeConstants.JAVA_LANG[1]);
575		575
576	if (importBinding == null \|\| !importBinding.isValidBinding()) {	576	if (importBinding == null \|\| !importBinding.isValidBinding()) {
577	// create a proxy for the missing BinaryType	577	// create a proxy for the missing BinaryType
578	problemReporter().isClassPathCorrect(	578	problemReporter().isClassPathCorrect(
579	JAVA_LANG_OBJECT,	579	TypeConstants.JAVA_LANG_OBJECT,
580	this.referenceContext,	580	this.referenceContext,
581	this.environment.missingClassFileLocation);	581	this.environment.missingClassFileLocation);
582	BinaryTypeBinding missingObject = this.environment.createMissingType(null, JAVA_LANG_OBJECT);	582	BinaryTypeBinding missingObject = this.environment.createMissingType(null, TypeConstants.JAVA_LANG_OBJECT);
583	importBinding = missingObject.fPackage;	583	importBinding = missingObject.fPackage;
584	}	584	}
585		585
586	return this.environment.defaultImports = new ImportBinding[] {new ImportBinding(JAVA_LANG, true, importBinding, null)};	586	return this.environment.defaultImports = new ImportBinding[] {new ImportBinding(TypeConstants.JAVA_LANG, true, importBinding, null)};
587	}	587	}
588	// NOT Public API	588	// NOT Public API
589	public final Binding getImport(char[][] compoundName, boolean onDemand, boolean isStaticImport) {	589	public final Binding getImport(char[][] compoundName, boolean onDemand, boolean isStaticImport) {

Removed Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/UpdatedMethodBinding.java (-25 lines)
1	/*******************************************************************************
2	* Copyright (c) 2000, 2006 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.jdt.internal.compiler.lookup;
12
13	public class UpdatedMethodBinding extends MethodBinding {
14
15	public TypeBinding updatedDeclaringClass;
16
17	public UpdatedMethodBinding(TypeBinding updatedDeclaringClass, int modifiers, char[] selector, TypeBinding returnType, TypeBinding[] args, ReferenceBinding[] exceptions, ReferenceBinding declaringClass) {
18	super(modifiers, selector, returnType, args, exceptions, declaringClass);
19	this.updatedDeclaringClass = updatedDeclaringClass;
20	}
21
22	public TypeBinding constantPoolDeclaringClass() {
23	return this.updatedDeclaringClass;
24	}
25	}

Lines 44-49 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/SourceTypeBinding.java (+3 lines)
44	private final static int METHOD_EMUL = 0;	44	private final static int METHOD_EMUL = 0;
45	private final static int FIELD_EMUL = 1;	45	private final static int FIELD_EMUL = 1;
46	private final static int CLASS_LITERAL_EMUL = 2;	46	private final static int CLASS_LITERAL_EMUL = 2;
		47	/** @deprecated */
47	private final static int RECEIVER_TYPE_EMUL = 3;	48	private final static int RECEIVER_TYPE_EMUL = 3;
48		49
49	private final static int MAX_SYNTHETICS = 4;	50	private final static int MAX_SYNTHETICS = 4;
Lines 1064-1069 Link Here
1064	public ReferenceBinding[] memberTypes() {	1065	public ReferenceBinding[] memberTypes() {
1065	return this.memberTypes;	1066	return this.memberTypes;
1066	}	1067	}
		1068	/** @deprecated */
1067	public FieldBinding getUpdatedFieldBinding(FieldBinding targetField, ReferenceBinding newDeclaringClass) {	1069	public FieldBinding getUpdatedFieldBinding(FieldBinding targetField, ReferenceBinding newDeclaringClass) {
1068	if (this.synthetics == null)	1070	if (this.synthetics == null)
1069	this.synthetics = new HashMap[MAX_SYNTHETICS];	1071	this.synthetics = new HashMap[MAX_SYNTHETICS];
Lines 1082-1087 Link Here
1082	}	1084	}
1083	return updatedField;	1085	return updatedField;
1084	}	1086	}
		1087	/** @deprecated */
1085	public MethodBinding getUpdatedMethodBinding(MethodBinding targetMethod, ReferenceBinding newDeclaringClass) {	1088	public MethodBinding getUpdatedMethodBinding(MethodBinding targetMethod, ReferenceBinding newDeclaringClass) {
1086	if (this.synthetics == null)	1089	if (this.synthetics == null)
1087	this.synthetics = new HashMap[MAX_SYNTHETICS];	1090	this.synthetics = new HashMap[MAX_SYNTHETICS];

Lines 111-117 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/lookup/NestedTypeBinding.java (-7 lines)
111	* Compute the resolved positions for all the synthetic arguments	111	* Compute the resolved positions for all the synthetic arguments
112	*/	112	*/
113	final public void computeSyntheticArgumentSlotSizes() {	113	final public void computeSyntheticArgumentSlotSizes() {
114
115	int slotSize = 0;	114	int slotSize = 0;
116	// insert enclosing instances first, followed by the outerLocals	115	// insert enclosing instances first, followed by the outerLocals
117	int enclosingInstancesCount = this.enclosingInstances == null ? 0 : this.enclosingInstances.length;	116	int enclosingInstancesCount = this.enclosingInstances == null ? 0 : this.enclosingInstances.length;
Lines 147-162 Link Here
147	/* Answer the receiver's enclosing type... null if the receiver is a top level type.	146	/* Answer the receiver's enclosing type... null if the receiver is a top level type.
148	*/	147	*/
149	public ReferenceBinding enclosingType() {	148	public ReferenceBinding enclosingType() {
150
151	return this.enclosingType;	149	return this.enclosingType;
152	}	150	}
153		151
154	/* Answer the synthetic argument for <actualOuterLocalVariable> or null if one does not exist.	152	/* Answer the synthetic argument for <actualOuterLocalVariable> or null if one does not exist.
155	*/	153	*/
156	public SyntheticArgumentBinding getSyntheticArgument(LocalVariableBinding actualOuterLocalVariable) {	154	public SyntheticArgumentBinding getSyntheticArgument(LocalVariableBinding actualOuterLocalVariable) {
157
158	if (this.outerLocalVariables == null) return null; // is null if no outer local variables are known	155	if (this.outerLocalVariables == null) return null; // is null if no outer local variables are known
159
160	for (int i = this.outerLocalVariables.length; --i >= 0;)	156	for (int i = this.outerLocalVariables.length; --i >= 0;)
161	if (this.outerLocalVariables[i].actualOuterLocalVariable == actualOuterLocalVariable)	157	if (this.outerLocalVariables[i].actualOuterLocalVariable == actualOuterLocalVariable)
162	return this.outerLocalVariables[i];	158	return this.outerLocalVariables[i];
Lines 170-176 Link Here
170	public ReferenceBinding[] syntheticEnclosingInstanceTypes() {	166	public ReferenceBinding[] syntheticEnclosingInstanceTypes() {
171	if (this.enclosingInstances == null)	167	if (this.enclosingInstances == null)
172	return null;	168	return null;
173
174	int length = this.enclosingInstances.length;	169	int length = this.enclosingInstances.length;
175	ReferenceBinding types[] = new ReferenceBinding[length];	170	ReferenceBinding types[] = new ReferenceBinding[length];
176	for (int i = 0; i < length; i++)	171	for (int i = 0; i < length; i++)
Lines 194-202 Link Here
194	/* Answer the synthetic argument for <targetEnclosingType> or null if one does not exist.	189	/* Answer the synthetic argument for <targetEnclosingType> or null if one does not exist.
195	*/	190	*/
196	public SyntheticArgumentBinding getSyntheticArgument(ReferenceBinding targetEnclosingType, boolean onlyExactMatch) {	191	public SyntheticArgumentBinding getSyntheticArgument(ReferenceBinding targetEnclosingType, boolean onlyExactMatch) {
197
198	if (this.enclosingInstances == null) return null; // is null if no enclosing instances are known	192	if (this.enclosingInstances == null) return null; // is null if no enclosing instances are known
199
200	// exact match	193	// exact match
201	for (int i = this.enclosingInstances.length; --i >= 0;)	194	for (int i = this.enclosingInstances.length; --i >= 0;)
202	if (this.enclosingInstances[i].type == targetEnclosingType)	195	if (this.enclosingInstances[i].type == targetEnclosingType)