Attachment #10379 for bug #61075

View | Details | Raw Unified | Return to bug 61075
Collapse All | Expand All




	if (DEBUG) System.out.println(position + "\t\taaload"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;

	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_aaload;
		resizeByteArray(OPC_aaload);
	}
}
final public void aastore() {
	if (DEBUG) System.out.println(position + "\t\taastore"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 3;
	
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_aastore;
		resizeByteArray(OPC_aastore);
	}
}
final public void aconst_null() {
	if (DEBUG) System.out.println(position + "\t\taconst_null"); //$NON-NLS-1$

	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_aconst_null;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_aconst_null);
	}
}
public final void addDefinitelyAssignedVariables(Scope scope, int initStateIndex) {
	// Required to fix 1PR0XVS: LFRE:WINNT - Compiler: variable table for method appears incorrect

	if (maxLocals <= iArg) {
		maxLocals = iArg + 1;
	}

	checkOffset(classFileOffset + 1);
	position+=2;
	if (iArg > 255) { // Widen
		bCodeStream[classFileOffset++] = OPC_wide;
		bCodeStream[classFileOffset++] = OPC_aload;
			bCodeStream[classFileOffset++] = OPC_wide;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_wide);
		}
		try {
			position++;
			bCodeStream[classFileOffset++] = OPC_aload;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_aload);
		}
		writeUnsignedShort(iArg);
	} else {
		// Don't need to use the wide bytecode
		bCodeStream[classFileOffset++] = (OPC_aload);
		bCodeStream[classFileOffset++] = (byte)iArg;
			bCodeStream[classFileOffset++] = OPC_aload;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_aload);
		}
		try {
			position++;
			bCodeStream[classFileOffset++] = (byte) (iArg);
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray((byte) iArg);
		}
	}
}
final public void aload_0() {

	if (maxLocals == 0) {
		maxLocals = 1;
	}
	
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_aload_0;
		resizeByteArray(OPC_aload_0);
	}
}
final public void aload_1() {
	if (DEBUG) System.out.println(position + "\t\taload_1"); //$NON-NLS-1$

	if (maxLocals <= 1) {
		maxLocals = 2;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_aload_1;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_aload_1);
	}
}
final public void aload_2() {
	if (DEBUG) System.out.println(position + "\t\taload_2"); //$NON-NLS-1$

	if (maxLocals <= 2) {
		maxLocals = 3;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_aload_2;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_aload_2);
	}
}
final public void aload_3() {
	if (DEBUG) System.out.println(position + "\t\taload_3"); //$NON-NLS-1$

	if (maxLocals <= 3) {
		maxLocals = 4;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_aload_3;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_aload_3);
	}
}
public final void anewarray(TypeBinding typeBinding) {
	if (DEBUG) System.out.println(position + "\t\tanewarray: " + typeBinding); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_anewarray;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_anewarray);
	}
	writeUnsignedShort(constantPool.literalIndex(typeBinding));
}
final public void areturn() {
	if (DEBUG) System.out.println(position + "\t\tareturn"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	// the stackDepth should be equal to 0
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_areturn;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_areturn);
	}
}
public void arrayAt(int typeBindingID) {
	switch (typeBindingID) {

final public void arraylength() {
	if (DEBUG) System.out.println(position + "\t\tarraylength"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_arraylength;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_arraylength);
	}
}
final public void astore(int iArg) {
	if (DEBUG) System.out.println(position + "\t\tastore:"+iArg); //$NON-NLS-1$

	if (maxLocals <= iArg) {
		maxLocals = iArg + 1;
	}
	checkOffset(classFileOffset + 1);
	position+=2;	
	if (iArg > 255) { // Widen
		bCodeStream[classFileOffset++] = OPC_wide;
		bCodeStream[classFileOffset++] = OPC_astore;
			bCodeStream[classFileOffset++] = OPC_wide;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_wide);
		}
		try {
			position++;
			bCodeStream[classFileOffset++] = OPC_astore;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_astore);
		}
		writeUnsignedShort(iArg);
	} else {
		bCodeStream[classFileOffset++] = OPC_astore;
		bCodeStream[classFileOffset++] = (byte)iArg;
			bCodeStream[classFileOffset++] = OPC_astore;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_astore);
		}
		try {
			position++;
			bCodeStream[classFileOffset++] = (byte) iArg;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray((byte) iArg);
		}
	}
}
final public void astore_0() {

	if (maxLocals == 0) {
		maxLocals = 1;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_astore_0;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_astore_0);
	}
}
final public void astore_1() {
	if (DEBUG) System.out.println(position + "\t\tastore_1"); //$NON-NLS-1$

	if (maxLocals <= 1) {
		maxLocals = 2;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_astore_1;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_astore_1);
	}
}
final public void astore_2() {
	if (DEBUG) System.out.println(position + "\t\tastore_2"); //$NON-NLS-1$

	if (maxLocals <= 2) {
		maxLocals = 3;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_astore_2;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_astore_2);
	}
}
final public void astore_3() {
	if (DEBUG) System.out.println(position + "\t\tastore_3"); //$NON-NLS-1$

	if (maxLocals <= 3) {
		maxLocals = 4;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_astore_3;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_astore_3);
	}
}
final public void athrow() {
	if (DEBUG) System.out.println(position + "\t\tathrow"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_athrow;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_athrow);
	}
}
final public void baload() {
	if (DEBUG) System.out.println(position + "\t\tbaload"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_baload;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_baload);
	}
}
final public void bastore() {
	if (DEBUG) System.out.println(position + "\t\tbastore"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 3;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_bastore;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_bastore);
	}
}
final public void bipush(byte b) {
	if (DEBUG) System.out.println(position + "\t\tbipush "+b); //$NON-NLS-1$

	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_bipush;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_bipush);
	}
	writeSignedByte(b);
}
final public void caload() {
	if (DEBUG) System.out.println(position + "\t\tcaload"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_caload;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_caload);
	}
}
final public void castore() {
	if (DEBUG) System.out.println(position + "\t\tcastore"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 3;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_castore;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_castore);
	}
}
public final void checkcast(TypeBinding typeBinding) {
	if (DEBUG) System.out.println(position + "\t\tcheckcast:"+typeBinding); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_checkcast;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_checkcast);
	}
	writeUnsignedShort(constantPool.literalIndex(typeBinding));
}
final public void d2f() {
	if (DEBUG) System.out.println(position + "\t\td2f"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_d2f;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_d2f);
	}
}
final public void d2i() {
	if (DEBUG) System.out.println(position + "\t\td2i"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_d2i;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_d2i);
	}
}
final public void d2l() {
	if (DEBUG) System.out.println(position + "\t\td2l"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_d2l;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_d2l);
	}
}
final public void dadd() {
	if (DEBUG) System.out.println(position + "\t\tdadd"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 2;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_dadd;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_dadd);
	}
}
final public void daload() {
	if (DEBUG) System.out.println(position + "\t\tdaload"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_daload;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_daload);
	}
}
final public void dastore() {
	if (DEBUG) System.out.println(position + "\t\tdastore"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 4;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_dastore;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_dastore);
	}
}
final public void dcmpg() {
	if (DEBUG) System.out.println(position + "\t\tdcmpg"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 3;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_dcmpg;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_dcmpg);
	}
}
final public void dcmpl() {
	if (DEBUG) System.out.println(position + "\t\tdcmpl"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 3;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_dcmpl;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_dcmpl);
	}
}
final public void dconst_0() {
	if (DEBUG) System.out.println(position + "\t\tdconst_0"); //$NON-NLS-1$

	stackDepth += 2;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_dconst_0;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_dconst_0);
	}
}
final public void dconst_1() {
	if (DEBUG) System.out.println(position + "\t\tdconst_1"); //$NON-NLS-1$

	stackDepth += 2;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_dconst_1;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_dconst_1);
	}
}
final public void ddiv() {
	if (DEBUG) System.out.println(position + "\t\tddiv"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 2;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_ddiv;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_ddiv);
	}
}
public void decrStackSize(int offset) {
	stackDepth -= offset;

	if (maxLocals < iArg + 2) {
		maxLocals = iArg + 2; // + 2 because it is a double
	}
	checkOffset(classFileOffset + 1);
	position+=2;
	if (iArg > 255) { // Widen
		bCodeStream[classFileOffset++] = OPC_wide;
		bCodeStream[classFileOffset++] = OPC_dload;
			bCodeStream[classFileOffset++] = OPC_wide;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_wide);
		}
		try {
			position++;
			bCodeStream[classFileOffset++] = OPC_dload;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_dload);
		}
		writeUnsignedShort(iArg);
	} else {
		// Don't need to use the wide bytecode
		bCodeStream[classFileOffset++] = OPC_dload;
		bCodeStream[classFileOffset++] = (byte)iArg;
			bCodeStream[classFileOffset++] = OPC_dload;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_dload);
		}
		try {
			position++;
			bCodeStream[classFileOffset++] = (byte) iArg;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray((byte) iArg);
		}
	}
}
final public void dload_0() {

	if (maxLocals < 2) {
		maxLocals = 2;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_dload_0;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_dload_0);
	}
}
final public void dload_1() {
	if (DEBUG) System.out.println(position + "\t\tdload_1"); //$NON-NLS-1$

	if (maxLocals < 3) {
		maxLocals = 3;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_dload_1;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_dload_1);
	}
}
final public void dload_2() {
	if (DEBUG) System.out.println(position + "\t\tdload_2"); //$NON-NLS-1$

	if (maxLocals < 4) {
		maxLocals = 4;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_dload_2;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_dload_2);
	}
}
final public void dload_3() {
	if (DEBUG) System.out.println(position + "\t\tdload_3"); //$NON-NLS-1$

	if (maxLocals < 5) {
		maxLocals = 5;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_dload_3;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_dload_3);
	}
}
final public void dmul() {
	if (DEBUG) System.out.println(position + "\t\tdmul"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 2;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_dmul;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_dmul);
	}
}
final public void dneg() {
	if (DEBUG) System.out.println(position + "\t\tdneg"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_dneg;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_dneg);
	}
}
final public void drem() {
	if (DEBUG) System.out.println(position + "\t\tdrem"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 2;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_drem;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_drem);
	}
}
final public void dreturn() {
	if (DEBUG) System.out.println(position + "\t\tdreturn"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 2;
	// the stackDepth should be equal to 0
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_dreturn;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_dreturn);
	}
}
final public void dstore(int iArg) {
	if (DEBUG) System.out.println(position + "\t\tdstore:"+iArg); //$NON-NLS-1$

	if (maxLocals <= iArg + 1) {
		maxLocals = iArg + 2;
	}
	checkOffset(classFileOffset + 1);
	position+=2;
	if (iArg > 255) { // Widen
		bCodeStream[classFileOffset++] = OPC_wide;
		bCodeStream[classFileOffset++] = OPC_dstore;
			bCodeStream[classFileOffset++] = OPC_wide;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_wide);
		}
		try {
			position++;
			bCodeStream[classFileOffset++] = OPC_dstore;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_dstore);
		}
		writeUnsignedShort(iArg);
	} else {
		bCodeStream[classFileOffset++] = OPC_dstore;
		bCodeStream[classFileOffset++] = (byte)iArg;
			bCodeStream[classFileOffset++] = OPC_dstore;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_dstore);
		}
		try {
			position++;
			bCodeStream[classFileOffset++] = (byte) iArg;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray((byte) iArg);
		}
	}
}
final public void dstore_0() {

	if (maxLocals < 2) {
		maxLocals = 2;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_dstore_0;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_dstore_0);
	}
}
final public void dstore_1() {
	if (DEBUG) System.out.println(position + "\t\tdstore_1"); //$NON-NLS-1$

	if (maxLocals < 3) {
		maxLocals = 3;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_dstore_1;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_dstore_1);
	}
}
final public void dstore_2() {
	if (DEBUG) System.out.println(position + "\t\tdstore_2"); //$NON-NLS-1$

	if (maxLocals < 4) {
		maxLocals = 4;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_dstore_2;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_dstore_2);
	}
}
final public void dstore_3() {
	if (DEBUG) System.out.println(position + "\t\tdstore_3"); //$NON-NLS-1$

	if (maxLocals < 5) {
		maxLocals = 5;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_dstore_3;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_dstore_3);
	}
}
final public void dsub() {
	if (DEBUG) System.out.println(position + "\t\tdsub"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 2;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_dsub;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_dsub);
	}
}
final public void dup() {
	if (DEBUG) System.out.println(position + "\t\tdup"); //$NON-NLS-1$

	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_dup;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_dup);
	}
}
final public void dup_x1() {
	if (DEBUG) System.out.println(position + "\t\tdup_x1"); //$NON-NLS-1$

	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_dup_x1;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_dup_x1);
	}
}
final public void dup_x2() {
	if (DEBUG) System.out.println(position + "\t\tdup_x2"); //$NON-NLS-1$

	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_dup_x2;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_dup_x2);
	}
}
final public void dup2() {
	if (DEBUG) System.out.println(position + "\t\tdup2"); //$NON-NLS-1$

	stackDepth += 2;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_dup2;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_dup2);
	}
}
final public void dup2_x1() {
	if (DEBUG) System.out.println(position + "\t\tdup2_x1"); //$NON-NLS-1$

	stackDepth += 2;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_dup2_x1;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_dup2_x1);
	}
}
final public void dup2_x2() {
	if (DEBUG) System.out.println(position + "\t\tdup2_x2"); //$NON-NLS-1$

	stackDepth += 2;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_dup2_x2;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_dup2_x2);
	}
}
public void exitUserScope(BlockScope blockScope) {
	// mark all the scope's locals as loosing their definite assignment

	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_f2d;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_f2d);
	}
}
final public void f2i() {
	if (DEBUG) System.out.println(position + "\t\tf2i"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_f2i;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_f2i);
	}
}
final public void f2l() {
	if (DEBUG) System.out.println(position + "\t\tf2l"); //$NON-NLS-1$

	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_f2l;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_f2l);
	}
}
final public void fadd() {
	if (DEBUG) System.out.println(position + "\t\tfadd"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_fadd;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_fadd);
	}
}
final public void faload() {
	if (DEBUG) System.out.println(position + "\t\tfaload"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_faload;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_faload);
	}
}
final public void fastore() {
	if (DEBUG) System.out.println(position + "\t\tfaload"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 3;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_fastore;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_fastore);
	}
}
final public void fcmpg() {
	if (DEBUG) System.out.println(position + "\t\tfcmpg"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_fcmpg;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_fcmpg);
	}
}
final public void fcmpl() {
	if (DEBUG) System.out.println(position + "\t\tfcmpl"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_fcmpl;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_fcmpl);
	}
}
final public void fconst_0() {
	if (DEBUG) System.out.println(position + "\t\tfconst_0"); //$NON-NLS-1$

	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_fconst_0;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_fconst_0);
	}
}
final public void fconst_1() {
	if (DEBUG) System.out.println(position + "\t\tfconst_1"); //$NON-NLS-1$

	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_fconst_1;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_fconst_1);
	}
}
final public void fconst_2() {
	if (DEBUG) System.out.println(position + "\t\tfconst_2"); //$NON-NLS-1$

	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_fconst_2;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_fconst_2);
	}
}
final public void fdiv() {
	if (DEBUG) System.out.println(position + "\t\tfdiv"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_fdiv;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_fdiv);
	}
}
final public void fload(int iArg) {
	if (DEBUG) System.out.println(position + "\t\tfload:"+iArg); //$NON-NLS-1$

	}
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset + 1);
	position+=2;
	if (iArg > 255) { // Widen
		bCodeStream[classFileOffset++] = OPC_wide;
		bCodeStream[classFileOffset++] = OPC_fload;
			bCodeStream[classFileOffset++] = OPC_wide;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_wide);
		}
		try {
			position++;
			bCodeStream[classFileOffset++] = OPC_fload;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_fload);
		}
		writeUnsignedShort(iArg);
	} else {
		bCodeStream[classFileOffset++] = OPC_fload;
		bCodeStream[classFileOffset++] = (byte)iArg;
			bCodeStream[classFileOffset++] = OPC_fload;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_fload);
		}
		try {
			position++;
			bCodeStream[classFileOffset++] = (byte) iArg;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray((byte) iArg);
		}
	}
}
final public void fload_0() {

	}
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_fload_0;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_fload_0);
	}
}
final public void fload_1() {
	if (DEBUG) System.out.println(position + "\t\tfload_1"); //$NON-NLS-1$

	}
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_fload_1;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_fload_1);
	}
}
final public void fload_2() {
	if (DEBUG) System.out.println(position + "\t\tfload_2"); //$NON-NLS-1$

	}
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_fload_2;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_fload_2);
	}
}
final public void fload_3() {
	if (DEBUG) System.out.println(position + "\t\tfload_3"); //$NON-NLS-1$

	}
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_fload_3;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_fload_3);
	}
}
final public void fmul() {
	if (DEBUG) System.out.println(position + "\t\tfmul"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_fmul;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_fmul);
	}
}
final public void fneg() {
	if (DEBUG) System.out.println(position + "\t\tfneg"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_fneg;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_fneg);
	}
}
final public void frem() {
	if (DEBUG) System.out.println(position + "\t\tfrem"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_frem;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_frem);
	}
}
final public void freturn() {
	if (DEBUG) System.out.println(position + "\t\tfreturn"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	// the stackDepth should be equal to 0
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_freturn;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_freturn);
	}
}
final public void fstore(int iArg) {
	if (DEBUG) System.out.println(position + "\t\tfstore:"+iArg); //$NON-NLS-1$

	if (maxLocals <= iArg) {
		maxLocals = iArg + 1;
	}
	checkOffset(classFileOffset + 1);
	position+=2;
	if (iArg > 255) { // Widen
		bCodeStream[classFileOffset++] = OPC_wide;
		bCodeStream[classFileOffset++] = OPC_fstore;
			bCodeStream[classFileOffset++] = OPC_wide;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_wide);
		}
		try {
			position++;
			bCodeStream[classFileOffset++] = OPC_fstore;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_fstore);
		}
		writeUnsignedShort(iArg);
	} else {
		bCodeStream[classFileOffset++] = OPC_fstore;
		bCodeStream[classFileOffset++] = (byte)iArg;
			bCodeStream[classFileOffset++] = OPC_fstore;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_fstore);
		}
		try {
			position++;
			bCodeStream[classFileOffset++] = (byte) iArg;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray((byte) iArg);
		}
	}
}
final public void fstore_0() {

	if (maxLocals == 0) {
		maxLocals = 1;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_fstore_0;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_fstore_0);
	}
}
final public void fstore_1() {
	if (DEBUG) System.out.println(position + "\t\tfstore_1"); //$NON-NLS-1$

	if (maxLocals <= 1) {
		maxLocals = 2;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_fstore_1;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_fstore_1);
	}
}
final public void fstore_2() {
	if (DEBUG) System.out.println(position + "\t\tfstore_2"); //$NON-NLS-1$

	if (maxLocals <= 2) {
		maxLocals = 3;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_fstore_2;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_fstore_2);
	}
}
final public void fstore_3() {
	if (DEBUG) System.out.println(position + "\t\tfstore_3"); //$NON-NLS-1$

	if (maxLocals <= 3) {
		maxLocals = 4;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_fstore_3;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_fstore_3);
	}
}
final public void fsub() {
	if (DEBUG) System.out.println(position + "\t\tfsub"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_fsub;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_fsub);
	}
}
/**
 * Macro for building a class descriptor object

		if (++stackDepth > stackMax)
			stackMax = stackDepth;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_getfield;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_getfield);
	}
	writeUnsignedShort(constantPool.literalIndex(fieldBinding));
}
final public void getstatic(FieldBinding fieldBinding) {

		stackDepth += 1;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_getstatic;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_getstatic);
	}
	writeUnsignedShort(constantPool.literalIndex(fieldBinding));
}
public void getTYPE(int baseTypeID) {
	countLabels = 0;
	if (++stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_getstatic;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_getstatic);
	}
	switch (baseTypeID) {
		case T_byte :
			// getstatic: java.lang.Byte.TYPE			

		return;
	}
	if (DEBUG) System.out.println(position + "\t\tgoto:"+label); //$NON-NLS-1$

	label.inlineForwardReferencesFromLabelsTargeting(position);
		/*
		 Possible optimization for code such as:
		 public Object foo() {

					return;
			}
		}*/
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_goto;
		resizeByteArray(OPC_goto);
	}
	label.branch();
}

final public void goto_w(Label lbl) {
	if (DEBUG) System.out.println(position + "\t\tgotow:"+lbl); //$NON-NLS-1$
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_goto_w;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_goto_w);
	}
	lbl.branchWide();
}
final public void i2b() {
	if (DEBUG) System.out.println(position + "\t\ti2b"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_i2b;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_i2b);
	}
}
final public void i2c() {
	if (DEBUG) System.out.println(position + "\t\ti2c"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_i2c;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_i2c);
	}
}
final public void i2d() {
	if (DEBUG) System.out.println(position + "\t\ti2d"); //$NON-NLS-1$

	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_i2d;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_i2d);
	}
}
final public void i2f() {
	if (DEBUG) System.out.println(position + "\t\ti2f"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_i2f;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_i2f);
	}
}
final public void i2l() {
	if (DEBUG) System.out.println(position + "\t\ti2l"); //$NON-NLS-1$

	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_i2l;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_i2l);
	}
}
final public void i2s() {
	if (DEBUG) System.out.println(position + "\t\ti2s"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_i2s;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_i2s);
	}
}
final public void iadd() {
	if (DEBUG) System.out.println(position + "\t\tiadd"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_iadd;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_iadd);
	}
}
final public void iaload() {
	if (DEBUG) System.out.println(position + "\t\tiaload"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_iaload;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_iaload);
	}
}
final public void iand() {
	if (DEBUG) System.out.println(position + "\t\tiand"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_iand;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_iand);
	}
}
final public void iastore() {
	if (DEBUG) System.out.println(position + "\t\tiastore"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 3;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_iastore;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_iastore);
	}
}
final public void iconst_0() {
	if (DEBUG) System.out.println(position + "\t\ticonst_0"); //$NON-NLS-1$

	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_iconst_0;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_iconst_0);
	}
}
final public void iconst_1() {
	if (DEBUG) System.out.println(position + "\t\ticonst_1"); //$NON-NLS-1$

	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_iconst_1;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_iconst_1);
	}
}
final public void iconst_2() {
	if (DEBUG) System.out.println(position + "\t\ticonst_2"); //$NON-NLS-1$

	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_iconst_2;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_iconst_2);
	}
}
final public void iconst_3() {
	if (DEBUG) System.out.println(position + "\t\ticonst_3"); //$NON-NLS-1$

	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_iconst_3;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_iconst_3);
	}
}
final public void iconst_4() {
	if (DEBUG) System.out.println(position + "\t\ticonst_4"); //$NON-NLS-1$

	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_iconst_4;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_iconst_4);
	}
}
final public void iconst_5() {
	if (DEBUG) System.out.println(position + "\t\ticonst_5"); //$NON-NLS-1$

	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_iconst_5;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_iconst_5);
	}
}
final public void iconst_m1() {
	if (DEBUG) System.out.println(position + "\t\ticonst_m1"); //$NON-NLS-1$

	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_iconst_m1;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_iconst_m1);
	}
}
final public void idiv() {
	if (DEBUG) System.out.println(position + "\t\tidiv"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_idiv;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_idiv);
	}
}
final public void if_acmpeq(Label lbl) {
	if (DEBUG) System.out.println(position + "\t\tif_acmpeq:"+lbl); //$NON-NLS-1$

	stackDepth-=2;
	if (this.wideMode) {
		generateWideRevertedConditionalBranch(OPC_if_acmpne, lbl);
	} else {
		checkOffset(classFileOffset);
		position++;
		bCodeStream[classFileOffset++] = OPC_if_acmpeq;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_if_acmpeq);
		}
		lbl.branch();
	}
}

	stackDepth-=2;
	if (this.wideMode) {
		generateWideRevertedConditionalBranch(OPC_if_acmpeq, lbl);
	} else {
		checkOffset(classFileOffset);
		position++;
		bCodeStream[classFileOffset++] = OPC_if_acmpne;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_if_acmpne);
		}
		lbl.branch();
	}
}

	stackDepth -= 2;
	if (this.wideMode) {
		generateWideRevertedConditionalBranch(OPC_if_icmpne, lbl);
	} else {
		checkOffset(classFileOffset);
		position++;
		bCodeStream[classFileOffset++] = OPC_if_icmpeq;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_if_icmpeq);
		}
		lbl.branch();
	}
}

	if (this.wideMode) {
		generateWideRevertedConditionalBranch(OPC_if_icmplt, lbl);
	} else {	
		checkOffset(classFileOffset);
		position++;
		bCodeStream[classFileOffset++] = OPC_if_icmpge;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_if_icmpge);
		}
		lbl.branch();
	}
}

	stackDepth -= 2;
	if (this.wideMode) {
		generateWideRevertedConditionalBranch(OPC_if_icmple, lbl);
	} else {
		checkOffset(classFileOffset);
		position++;
		bCodeStream[classFileOffset++] = OPC_if_icmpgt;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_if_icmpgt);
		}
		lbl.branch();
	}
}

	stackDepth -= 2;
	if (this.wideMode) {
		generateWideRevertedConditionalBranch(OPC_if_icmpgt, lbl);
	} else {
		checkOffset(classFileOffset);
		position++;
		bCodeStream[classFileOffset++] = OPC_if_icmple;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_if_icmple);
		}
		lbl.branch();
	}
}

	if (this.wideMode) {
		generateWideRevertedConditionalBranch(OPC_if_icmpge, lbl);
	} else {
		checkOffset(classFileOffset);
		position++;
		bCodeStream[classFileOffset++] = OPC_if_icmplt;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_if_icmplt);
		}
		lbl.branch();
	}
}

	if (this.wideMode) {
		generateWideRevertedConditionalBranch(OPC_if_icmpeq, lbl);
	} else {
		checkOffset(classFileOffset);
		position++;
		bCodeStream[classFileOffset++] = OPC_if_icmpne;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_if_icmpne);
		}
		lbl.branch();
	}
}

	if (this.wideMode) {
		generateWideRevertedConditionalBranch(OPC_ifne, lbl);
	} else {
		checkOffset(classFileOffset);
		position++;
		bCodeStream[classFileOffset++] = OPC_ifeq;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_ifeq);
		}
		lbl.branch();
	}
}

	if (this.wideMode) {
		generateWideRevertedConditionalBranch(OPC_iflt, lbl);
	} else {
		checkOffset(classFileOffset);
		position++;
		bCodeStream[classFileOffset++] = OPC_ifge;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_ifge);
		}
		lbl.branch();
	}
}

	if (this.wideMode) {
		generateWideRevertedConditionalBranch(OPC_ifle, lbl);
	} else {
		checkOffset(classFileOffset);
		position++;
		bCodeStream[classFileOffset++] = OPC_ifgt;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_ifgt);
		}
		lbl.branch();
	}
}

	if (this.wideMode) {
		generateWideRevertedConditionalBranch(OPC_ifgt, lbl);
	} else {
		checkOffset(classFileOffset);
		position++;
		bCodeStream[classFileOffset++] = OPC_ifle;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_ifle);
		}
		lbl.branch();
	}
}

	if (this.wideMode) {
		generateWideRevertedConditionalBranch(OPC_ifge, lbl);
	} else {
		checkOffset(classFileOffset);
		position++;
		bCodeStream[classFileOffset++] = OPC_iflt;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_iflt);
		}
		lbl.branch();
	}
}

	if (this.wideMode) {
		generateWideRevertedConditionalBranch(OPC_ifeq, lbl);
	} else {
		checkOffset(classFileOffset);
		position++;
		bCodeStream[classFileOffset++] = OPC_ifne;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_ifne);
		}
		lbl.branch();
	}
}

	if (this.wideMode) {
		generateWideRevertedConditionalBranch(OPC_ifnull, lbl);
	} else {
		checkOffset(classFileOffset);
		position++;
		bCodeStream[classFileOffset++] = OPC_ifnonnull;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_ifnonnull);
		}
		lbl.branch();
	}
}

	if (this.wideMode) {
		generateWideRevertedConditionalBranch(OPC_ifnonnull, lbl);
	} else {
		checkOffset(classFileOffset);
		position++;
		bCodeStream[classFileOffset++] = OPC_ifnull;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_ifnull);
		}
		lbl.branch();
	}
}

	if (DEBUG) System.out.println(position + "\t\tiinc:"+index+","+value); //$NON-NLS-1$ //$NON-NLS-2$
	countLabels = 0;
	if ((index > 255) || (value < -128 || value > 127)) { // have to widen
		checkOffset(classFileOffset + 1);
		position+=2;
		bCodeStream[classFileOffset++] = OPC_wide;
		bCodeStream[classFileOffset++] = OPC_iinc;
			resizeByteArray(OPC_wide);
		}
		try {
			position++;
			bCodeStream[classFileOffset++] = OPC_iinc;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_iinc);
		}
		writeUnsignedShort(index);
		writeSignedShort(value);
	} else {
		checkOffset(classFileOffset);
		position++;
		bCodeStream[classFileOffset++] = OPC_iinc;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_iinc);
		}
		writeUnsignedByte(index);
		writeSignedByte(value);
	}

	}
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset + 1);
	position+=2;
	if (iArg > 255) { // Widen
		bCodeStream[classFileOffset++] = OPC_wide;
		bCodeStream[classFileOffset++] = OPC_iload;
			bCodeStream[classFileOffset++] = OPC_wide;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_wide);
		}
		try {
			position++;
			bCodeStream[classFileOffset++] = OPC_iload;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_iload);
		}
		writeUnsignedShort(iArg);
	} else {
		bCodeStream[classFileOffset++] = OPC_iload;
		bCodeStream[classFileOffset++] = (byte)iArg;
			bCodeStream[classFileOffset++] = OPC_iload;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_iload);
		}
		try {
			position++;
			bCodeStream[classFileOffset++] = (byte) iArg;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray((byte) iArg);
		}
	}
}
final public void iload_0() {

	}
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_iload_0;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_iload_0);
	}
}
final public void iload_1() {
	if (DEBUG) System.out.println(position + "\t\tiload_1"); //$NON-NLS-1$

	}
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_iload_1;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_iload_1);
	}
}
final public void iload_2() {
	if (DEBUG) System.out.println(position + "\t\tiload_2"); //$NON-NLS-1$

	}
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_iload_2;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_iload_2);
	}
}
final public void iload_3() {
	if (DEBUG) System.out.println(position + "\t\tiload_3"); //$NON-NLS-1$

	}
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_iload_3;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_iload_3);
	}
}
final public void imul() {
	if (DEBUG) System.out.println(position + "\t\timul"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_imul;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_imul);
	}
}
public void incrementTemp(LocalVariableBinding localBinding, int value) {
	if (value == (short) value) {

final public void ineg() {
	if (DEBUG) System.out.println(position + "\t\tineg"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_ineg;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_ineg);
	}
}
public void init(ClassFile targetClassFile) {
	this.classFile = targetClassFile;

final public void instance_of(TypeBinding typeBinding) {
	if (DEBUG) System.out.println(position + "\t\tinstance_of:"+typeBinding); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_instanceof;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_instanceof);
	}
	writeUnsignedShort(constantPool.literalIndex(typeBinding));
}
public void invokeClassForName() {
	// invokestatic: java.lang.Class.forName(Ljava.lang.String;)Ljava.lang.Class;
	if (DEBUG) System.out.println(position + "\t\tinvokestatic: java.lang.Class.forName(Ljava.lang.String;)Ljava.lang.Class;"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_invokestatic;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_invokestatic);
	}
	writeUnsignedShort(constantPool.literalIndexForJavaLangClassForName());
}


	if (DEBUG) System.out.println(position + "\t\tinvokevirtual: java.lang.Class.desiredAssertionStatus()Z;"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_invokevirtual;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_invokevirtual);
	}
	writeUnsignedShort(constantPool.literalIndexForJavaLangClassDesiredAssertionStatus());
}


	// invokevirtual: java.lang.Class.getComponentType()java.lang.Class;
	if (DEBUG) System.out.println(position + "\t\tinvokevirtual: java.lang.Class.getComponentType()java.lang.Class;"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_invokevirtual;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_invokevirtual);
	}
	writeUnsignedShort(constantPool.literalIndexForJavaLangClassGetComponentType());
}


	countLabels = 0;
	int argCount = 1;
	int id;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_invokeinterface;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_invokeinterface);
	}
	writeUnsignedShort(constantPool.literalIndex(methodBinding));
	for (int i = methodBinding.parameters.length - 1; i >= 0; i--)
		if (((id = methodBinding.parameters[i].id) == T_double) || (id == T_long))

	writeUnsignedByte(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.
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = (byte)0;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray((byte)0);
	}
	if (((id = methodBinding.returnType.id) == T_double) || (id == T_long))
		stackDepth += (2 - argCount);
	else

	// invokespecial: java.lang.Error<init>(Ljava.lang.String;)V
	if (DEBUG) System.out.println(position + "\t\tinvokespecial: java.lang.Error<init>(Ljava.lang.String;)V"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_invokespecial;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_invokespecial);
	}
	stackDepth -= 2;
	writeUnsignedShort(constantPool.literalIndexForJavaLangErrorConstructor());
}

	// invokespecial: java.lang.NoClassDefFoundError.<init>(Ljava.lang.String;)V
	if (DEBUG) System.out.println(position + "\t\tinvokespecial: java.lang.NoClassDefFoundError.<init>(Ljava.lang.String;)V"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_invokespecial;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_invokespecial);
	}
	writeUnsignedShort(constantPool.literalIndexForJavaLangNoClassDefFoundErrorStringConstructor());
	stackDepth -= 2;
}

	// invokevirtual: java.lang.Object.getClass()Ljava.lang.Class;
	if (DEBUG) System.out.println(position + "\t\tinvokevirtual: java.lang.Object.getClass()Ljava.lang.Class;"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_invokevirtual;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_invokevirtual);
	}
	writeUnsignedShort(constantPool.literalIndexForJavaLangObjectGetClass());
}


	countLabels = 0;
	int argCount = 1;
	int id;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_invokespecial;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_invokespecial);
	}
	writeUnsignedShort(constantPool.literalIndex(methodBinding));
	if (methodBinding.isConstructor() && methodBinding.declaringClass.isNestedType()) {
		// enclosing instances

	countLabels = 0;
	int argCount = 0;
	int id;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_invokestatic;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_invokestatic);
	}
	writeUnsignedShort(constantPool.literalIndex(methodBinding));
	for (int i = methodBinding.parameters.length - 1; i >= 0; i--)
		if (((id = methodBinding.parameters[i].id) == T_double) || (id == T_long))

	else
		usedTypeID = typeID;
	// invokevirtual
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_invokevirtual;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_invokevirtual);
	}
	writeUnsignedShort(constantPool.literalIndexForJavaLangStringBufferAppend(typeID));
	if ((usedTypeID == T_long) || (usedTypeID == T_double))
		stackDepth -= 2;

	// invokespecial: java.lang.AssertionError.<init>(typeBindingID)V
	if (DEBUG) System.out.println(position + "\t\tinvokespecial: java.lang.AssertionError.<init>(typeBindingID)V"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_invokespecial;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_invokespecial);
	}
	writeUnsignedShort(constantPool.literalIndexForJavaLangAssertionErrorConstructor(typeBindingID));
	stackDepth -= 2;
}

	// invokespecial: java.lang.AssertionError.<init>()V
	if (DEBUG) System.out.println(position + "\t\tinvokespecial: java.lang.AssertionError.<init>()V"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_invokespecial;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_invokespecial);
	}
	writeUnsignedShort(constantPool.literalIndexForJavaLangAssertionErrorDefaultConstructor());
	stackDepth --;
}

	// invokespecial: java.lang.StringBuffer.<init>()V
	if (DEBUG) System.out.println(position + "\t\tinvokespecial: java.lang.StringBuffer.<init>()V"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_invokespecial;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_invokespecial);
	}
	writeUnsignedShort(constantPool.literalIndexForJavaLangStringBufferDefaultConstructor());
	stackDepth--;
}

	// invokespecial: java.lang.StringBuffer.<init>(Ljava.lang.String;)V
	if (DEBUG) System.out.println(position + "\t\tjava.lang.StringBuffer.<init>(Ljava.lang.String;)V"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_invokespecial;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_invokespecial);
	}
	writeUnsignedShort(constantPool.literalIndexForJavaLangStringBufferConstructor());
	stackDepth -= 2;
}

	// invokevirtual: StringBuffer.toString()Ljava.lang.String;
	if (DEBUG) System.out.println(position + "\t\tinvokevirtual: StringBuffer.toString()Ljava.lang.String;"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_invokevirtual;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_invokevirtual);
	}
	writeUnsignedShort(constantPool.literalIndexForJavaLangStringBufferToString());
}
public void invokeStringIntern() {
	// invokevirtual: java.lang.String.intern()
	if (DEBUG) System.out.println(position + "\t\tinvokevirtual: java.lang.String.intern()"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_invokevirtual;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_invokevirtual);
	}
	writeUnsignedShort(constantPool.literalIndexForJavaLangStringIntern());
}
public void invokeStringValueOf(int typeID) {
	// invokestatic: java.lang.String.valueOf(argumentType)
	if (DEBUG) System.out.println(position + "\t\tinvokestatic: java.lang.String.valueOf(...)"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_invokestatic;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_invokestatic);
	}
	writeUnsignedShort(constantPool.literalIndexForJavaLangStringValueOf(typeID));
}
public void invokeThrowableGetMessage() {
	// invokevirtual: java.lang.Throwable.getMessage()Ljava.lang.String;
	if (DEBUG) System.out.println(position + "\t\tinvokevirtual: java.lang.Throwable.getMessage()Ljava.lang.String;"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_invokevirtual;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_invokevirtual);
	}
	writeUnsignedShort(constantPool.literalIndexForJavaLangThrowableGetMessage());
}
final public void invokevirtual(MethodBinding methodBinding) {

	countLabels = 0;
	int argCount = 1;
	int id;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_invokevirtual;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_invokevirtual);
	}
	writeUnsignedShort(constantPool.literalIndex(methodBinding));
	for (int i = methodBinding.parameters.length - 1; i >= 0; i--)
		if (((id = methodBinding.parameters[i].id) == T_double) || (id == T_long))

	if (DEBUG) System.out.println(position + "\t\tior"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_ior;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_ior);
	}
}
final public void irem() {
	if (DEBUG) System.out.println(position + "\t\tirem"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_irem;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_irem);
	}
}
final public void ireturn() {
	if (DEBUG) System.out.println(position + "\t\tireturn"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	// the stackDepth should be equal to 0
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_ireturn;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_ireturn);
	}
}
public boolean isDefinitelyAssigned(Scope scope, int initStateIndex, LocalVariableBinding local) {
	// Dependant of UnconditionalFlowInfo.isDefinitelyAssigned(..)

	if (DEBUG) System.out.println(position + "\t\tishl"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_ishl;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_ishl);
	}
}
final public void ishr() {
	if (DEBUG) System.out.println(position + "\t\tishr"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_ishr;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_ishr);
	}
}
final public void istore(int iArg) {
	if (DEBUG) System.out.println(position + "\t\tistore:"+iArg); //$NON-NLS-1$

	if (maxLocals <= iArg) {
		maxLocals = iArg + 1;
	}
	checkOffset(classFileOffset + 1);
	position+=2;
	if (iArg > 255) { // Widen
		bCodeStream[classFileOffset++] = OPC_wide;
		bCodeStream[classFileOffset++] = OPC_istore;
			bCodeStream[classFileOffset++] = OPC_wide;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_wide);
		}
		try {
			position++;
			bCodeStream[classFileOffset++] = OPC_istore;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_istore);
		}
		writeUnsignedShort(iArg);
	} else {
		bCodeStream[classFileOffset++] = OPC_istore;
		bCodeStream[classFileOffset++] = (byte)iArg;
			bCodeStream[classFileOffset++] = OPC_istore;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_istore);
		}
		try {
			position++;
			bCodeStream[classFileOffset++] = (byte) iArg;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray((byte) iArg);
		}
	}
}
final public void istore_0() {

	if (maxLocals == 0) {
		maxLocals = 1;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_istore_0;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_istore_0);
	}
}
final public void istore_1() {
	if (DEBUG) System.out.println(position + "\t\tistore_1"); //$NON-NLS-1$

	if (maxLocals <= 1) {
		maxLocals = 2;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_istore_1;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_istore_1);
	}
}
final public void istore_2() {
	if (DEBUG) System.out.println(position + "\t\tistore_2"); //$NON-NLS-1$

	if (maxLocals <= 2) {
		maxLocals = 3;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_istore_2;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_istore_2);
	}
}
final public void istore_3() {
	if (DEBUG) System.out.println(position + "\t\tistore_3"); //$NON-NLS-1$

	if (maxLocals <= 3) {
		maxLocals = 4;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_istore_3;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_istore_3);
	}
}
final public void isub() {
	if (DEBUG) System.out.println(position + "\t\tisub"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_isub;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_isub);
	}
}
final public void iushr() {
	if (DEBUG) System.out.println(position + "\t\tiushr"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_iushr;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_iushr);
	}
}
final public void ixor() {
	if (DEBUG) System.out.println(position + "\t\tixor"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_ixor;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_ixor);
	}
}
final public void jsr(Label lbl) {
	if (this.wideMode) {

	}
	if (DEBUG) System.out.println(position + "\t\tjsr"+lbl); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_jsr;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_jsr);
	}
	lbl.branch();
}
final public void jsr_w(Label lbl) {
	if (DEBUG) System.out.println(position + "\t\tjsr_w"+lbl); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_jsr_w;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_jsr_w);
	}
	lbl.branchWide();
}
final public void l2d() {
	if (DEBUG) System.out.println(position + "\t\tl2d"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_l2d;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_l2d);
	}
}
final public void l2f() {
	if (DEBUG) System.out.println(position + "\t\tl2f"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_l2f;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_l2f);
	}
}
final public void l2i() {
	if (DEBUG) System.out.println(position + "\t\tl2i"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_l2i;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_l2i);
	}
}
final public void ladd() {
	if (DEBUG) System.out.println(position + "\t\tladd"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 2;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_ladd;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_ladd);
	}
}
final public void laload() {
	if (DEBUG) System.out.println(position + "\t\tlaload"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_laload;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_laload);
	}
}
final public void land() {
	if (DEBUG) System.out.println(position + "\t\tland"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 2;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_land;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_land);
	}
}
final public void lastore() {
	if (DEBUG) System.out.println(position + "\t\tlastore"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 4;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_lastore;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_lastore);
	}
}
final public void lcmp() {
	if (DEBUG) System.out.println(position + "\t\tlcmp"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 3;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_lcmp;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_lcmp);
	}
}
final public void lconst_0() {
	if (DEBUG) System.out.println(position + "\t\tlconst_0"); //$NON-NLS-1$

	stackDepth += 2;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_lconst_0;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_lconst_0);
	}
}
final public void lconst_1() {
	if (DEBUG) System.out.println(position + "\t\tlconst_1"); //$NON-NLS-1$

	stackDepth += 2;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_lconst_1;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_lconst_1);
	}
}
final public void ldc(float constant) {
	if (DEBUG) System.out.println(position + "\t\tldc:"+constant); //$NON-NLS-1$

	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	if (index > 255) {
		// Generate a ldc_w
		bCodeStream[classFileOffset++] = OPC_ldc_w;
			position++;
			bCodeStream[classFileOffset++] = OPC_ldc_w;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_ldc_w);
		}
		writeUnsignedShort(index);
	} else {
		// Generate a ldc
		bCodeStream[classFileOffset++] = OPC_ldc;
			position++;
			bCodeStream[classFileOffset++] = OPC_ldc;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_ldc);
		}
		writeUnsignedByte(index);
	}
}

	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	if (index > 255) {
		// Generate a ldc_w
		bCodeStream[classFileOffset++] = OPC_ldc_w;
			position++;
			bCodeStream[classFileOffset++] = OPC_ldc_w;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_ldc_w);
		}
		writeUnsignedShort(index);
	} else {
		// Generate a ldc
		bCodeStream[classFileOffset++] = OPC_ldc;
			position++;
			bCodeStream[classFileOffset++] = OPC_ldc;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_ldc);
		}
		writeUnsignedByte(index);
	}
}

		stackDepth++;
		if (stackDepth > stackMax)
			stackMax = stackDepth;
		checkOffset(classFileOffset);
		position++;
		if (index > 255) {
			// Generate a ldc_w
			bCodeStream[classFileOffset++] = OPC_ldc_w;
				position++;
				bCodeStream[classFileOffset++] = OPC_ldc_w;
			} catch (IndexOutOfBoundsException e) {
				resizeByteArray(OPC_ldc_w);
			}
			writeUnsignedShort(index);
		} else {
			// Generate a ldc
			bCodeStream[classFileOffset++] = OPC_ldc;
				position++;
				bCodeStream[classFileOffset++] = OPC_ldc;
			} catch (IndexOutOfBoundsException e) {
				resizeByteArray(OPC_ldc);
			}
			writeUnsignedByte(index);
		}
	} else {

		stackDepth++;
		if (stackDepth > stackMax)
			stackMax = stackDepth;
		checkOffset(classFileOffset);
		position++;
		if (index > 255) {
			// Generate a ldc_w
			bCodeStream[classFileOffset++] = OPC_ldc_w;
				position++;
				bCodeStream[classFileOffset++] = OPC_ldc_w;
			} catch (IndexOutOfBoundsException e) {
				resizeByteArray(OPC_ldc_w);
			}
			writeUnsignedShort(index);
		} else {
			// Generate a ldc
			bCodeStream[classFileOffset++] = OPC_ldc;
				position++;
				bCodeStream[classFileOffset++] = OPC_ldc;
			} catch (IndexOutOfBoundsException e) {
				resizeByteArray(OPC_ldc);
			}
			writeUnsignedByte(index);
		}
		// write the remaining part

			stackDepth++;
			if (stackDepth > stackMax)
				stackMax = stackDepth;
			checkOffset(classFileOffset);
			position++;
			if (index > 255) {
				// Generate a ldc_w
				bCodeStream[classFileOffset++] = OPC_ldc_w;
					position++;
					bCodeStream[classFileOffset++] = OPC_ldc_w;
				} catch (IndexOutOfBoundsException e) {
					resizeByteArray(OPC_ldc_w);
				}
				writeUnsignedShort(index);
			} else {
				// Generate a ldc
				bCodeStream[classFileOffset++] = OPC_ldc;
					position++;
					bCodeStream[classFileOffset++] = OPC_ldc;
				} catch (IndexOutOfBoundsException e) {
					resizeByteArray(OPC_ldc);
				}
				writeUnsignedByte(index);
			}
			// now on the stack it should be a StringBuffer and a string.

	if (stackDepth > stackMax)
		stackMax = stackDepth;
	// Generate a ldc2_w
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_ldc2_w;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_ldc2_w);
	}
	writeUnsignedShort(index);
}
final public void ldc2_w(long constant) {

	if (stackDepth > stackMax)
		stackMax = stackDepth;
	// Generate a ldc2_w
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_ldc2_w;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_ldc2_w);
	}
	writeUnsignedShort(index);
}
final public void ldiv() {
	if (DEBUG) System.out.println(position + "\t\tldiv"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 2;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_ldiv;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_ldiv);
	}
}
final public void lload(int iArg) {
	if (DEBUG) System.out.println(position + "\t\tlload:"+iArg); //$NON-NLS-1$

	}
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset + 1);
	position+=2;
	if (iArg > 255) { // Widen
		bCodeStream[classFileOffset++] = OPC_wide;
		bCodeStream[classFileOffset++] = OPC_lload;
			bCodeStream[classFileOffset++] = OPC_wide;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_wide);
		}
		try {
			position++;
			bCodeStream[classFileOffset++] = OPC_lload;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_lload);
		}
		writeUnsignedShort(iArg);
	} else {
		bCodeStream[classFileOffset++] = OPC_lload;
		bCodeStream[classFileOffset++] = (byte)iArg;
			bCodeStream[classFileOffset++] = OPC_lload;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_lload);
		}
		try {
			position++;
			bCodeStream[classFileOffset++] = (byte) iArg;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray((byte) iArg);
		}
	}
}
final public void lload_0() {

	}
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_lload_0;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_lload_0);
	}
}
final public void lload_1() {
	if (DEBUG) System.out.println(position + "\t\tlload_1"); //$NON-NLS-1$

	}
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_lload_1;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_lload_1);
	}
}
final public void lload_2() {
	if (DEBUG) System.out.println(position + "\t\tlload_2"); //$NON-NLS-1$

	}
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_lload_2;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_lload_2);
	}
}
final public void lload_3() {
	if (DEBUG) System.out.println(position + "\t\tlload_3"); //$NON-NLS-1$

	}
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_lload_3;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_lload_3);
	}
}
final public void lmul() {
	if (DEBUG) System.out.println(position + "\t\tlmul"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 2;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_lmul;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_lmul);
	}
}
final public void lneg() {
	if (DEBUG) System.out.println(position + "\t\tlneg"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_lneg;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_lneg);
	}
}
public final void load(LocalVariableBinding localBinding) {
	countLabels = 0;

	for (int i = 0; i < length; i++) {
		casesLabel[i].placeInstruction();
	}
	
	int lookupCount = (3 - (pos % 4));
	checkOffset(classFileOffset + lookupCount);
	position+= lookupCount + 1;
	bCodeStream[classFileOffset++] = OPC_lookupswitch;
	for (int i = lookupCount; i > 0; i--) {
		bCodeStream[classFileOffset++] = (byte)0;
		try {
			position++;
			bCodeStream[classFileOffset++] = 0;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray((byte)0);
		}
	}
	defaultLabel.branch();
	writeSignedWord(length);

	if (DEBUG) System.out.println(position + "\t\tlor"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 2;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_lor;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_lor);
	}
}
final public void lrem() {
	if (DEBUG) System.out.println(position + "\t\tlrem"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 2;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_lrem;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_lrem);
	}
}
final public void lreturn() {
	if (DEBUG) System.out.println(position + "\t\tlreturn"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 2;
	// the stackDepth should be equal to 0
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_lreturn;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_lreturn);
	}
}
final public void lshl() {
	if (DEBUG) System.out.println(position + "\t\tlshl"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_lshl;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_lshl);
	}
}
final public void lshr() {
	if (DEBUG) System.out.println(position + "\t\tlshr"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_lshr;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_lshr);
	}
}
final public void lstore(int iArg) {
	if (DEBUG) System.out.println(position + "\t\tlstore:"+iArg); //$NON-NLS-1$

	if (maxLocals <= iArg + 1) {
		maxLocals = iArg + 2;
	}
	checkOffset(classFileOffset + 1);
	position+=2;
	if (iArg > 255) { // Widen
		bCodeStream[classFileOffset++] = OPC_wide;
		bCodeStream[classFileOffset++] = OPC_lstore;
			bCodeStream[classFileOffset++] = OPC_wide;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_wide);
		}
		try {
			position++;
			bCodeStream[classFileOffset++] = OPC_lstore;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_lstore);
		}
		writeUnsignedShort(iArg);
	} else {
		bCodeStream[classFileOffset++] = OPC_lstore;
		bCodeStream[classFileOffset++] = (byte)iArg;
			bCodeStream[classFileOffset++] = OPC_lstore;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_lstore);
		}
		try {
			position++;
			bCodeStream[classFileOffset++] = (byte) iArg;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray((byte) iArg);
		}
	}
}
final public void lstore_0() {

	if (maxLocals < 2) {
		maxLocals = 2;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_lstore_0;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_lstore_0);
	}
}
final public void lstore_1() {
	if (DEBUG) System.out.println(position + "\t\tlstore_1"); //$NON-NLS-1$

	if (maxLocals < 3) {
		maxLocals = 3;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_lstore_1;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_lstore_1);
	}
}
final public void lstore_2() {
	if (DEBUG) System.out.println(position + "\t\tlstore_2"); //$NON-NLS-1$

	if (maxLocals < 4) {
		maxLocals = 4;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_lstore_2;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_lstore_2);
	}
}
final public void lstore_3() {
	if (DEBUG) System.out.println(position + "\t\tlstore_3"); //$NON-NLS-1$

	if (maxLocals < 5) {
		maxLocals = 5;
	}
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_lstore_3;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_lstore_3);
	}
}
final public void lsub() {
	if (DEBUG) System.out.println(position + "\t\tlsub"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 2;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_lsub;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_lsub);
	}
}
final public void lushr() {
	if (DEBUG) System.out.println(position + "\t\tlushr"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_lushr;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_lushr);
	}
}
final public void lxor() {
	if (DEBUG) System.out.println(position + "\t\tlxor"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 2;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_lxor;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_lxor);
	}
}
final public void monitorenter() {
	if (DEBUG) System.out.println(position + "\t\tmonitorenter"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_monitorenter;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_monitorenter);
	}
}
final public void monitorexit() {
	if (DEBUG) System.out.println(position + "\t\tmonitorexit"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_monitorexit;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_monitorexit);
	}
}
final public void multianewarray(TypeBinding typeBinding, int dimensions) {
	if (DEBUG) System.out.println(position + "\t\tmultinewarray:"+typeBinding+","+dimensions); //$NON-NLS-1$ //$NON-NLS-2$
	countLabels = 0;
	stackDepth += (1 - dimensions);
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_multianewarray;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_multianewarray);
	}
	writeUnsignedShort(constantPool.literalIndex(typeBinding));
	writeUnsignedByte(dimensions);
}

	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_new;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_new);
	}
	writeUnsignedShort(constantPool.literalIndex(typeBinding));
}
final public void newarray(int array_Type) {
	if (DEBUG) System.out.println(position + "\t\tnewarray:"+array_Type); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_newarray;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_newarray);
	}
	writeUnsignedByte(array_Type);
}
public void newArray(Scope scope, ArrayBinding arrayBinding) {

	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_new;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_new);
	}
	writeUnsignedShort(constantPool.literalIndexForJavaLangError());
}


	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_new;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_new);
	}
	writeUnsignedShort(constantPool.literalIndexForJavaLangAssertionError());
}


	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_new;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_new);
	}
	writeUnsignedShort(constantPool.literalIndexForJavaLangNoClassDefFoundError());
}
public void newStringBuffer() {

	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_new;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_new);
	}
	writeUnsignedShort(constantPool.literalIndexForJavaLangStringBuffer());
}
public void newWrapperFor(int typeID) {

	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_new;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_new);
	}
	switch (typeID) {
		case T_int : // new: java.lang.Integer
			if (DEBUG) System.out.println(position + "\t\tnew: java.lang.Integer"); //$NON-NLS-1$

final public void nop() {
	if (DEBUG) System.out.println(position + "\t\tnop"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_nop;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_nop);
	}
}
final public void pop() {
	if (DEBUG) System.out.println(position + "\t\tpop"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_pop;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_pop);
	}
}
final public void pop2() {
	if (DEBUG) System.out.println(position + "\t\tpop2"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 2;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_pop2;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_pop2);
	}
}
final public void putfield(FieldBinding fieldBinding) {
	if (DEBUG) System.out.println(position + "\t\tputfield:"+fieldBinding); //$NON-NLS-1$

		stackDepth -= 2;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_putfield;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_putfield);
	}
	writeUnsignedShort(constantPool.literalIndex(fieldBinding));
}
final public void putstatic(FieldBinding fieldBinding) {

		stackDepth -= 1;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_putstatic;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_putstatic);
	}
	writeUnsignedShort(constantPool.literalIndex(fieldBinding));
}
public void record(LocalVariableBinding local) {

	resizeByteArray();
	bCodeStream[classFileOffset - 1] = b;
}
protected final void checkOffset(int offset) {
	if (offset >= bCodeStream.length)
		resizeByteArray();
}

final public void ret(int index) {
	if (DEBUG) System.out.println(position + "\t\tret:"+index); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset + 1);
	position+=2;
	if (index > 255) { // Widen
		bCodeStream[classFileOffset++] = OPC_wide;
		bCodeStream[classFileOffset++] = OPC_ret;
			bCodeStream[classFileOffset++] = OPC_wide;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_wide);
		}
		try {
			position++;
			bCodeStream[classFileOffset++] = OPC_ret;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_ret);
		}
		writeUnsignedShort(index);
	} else { // Don't Widen
		bCodeStream[classFileOffset++] = OPC_ret;
		bCodeStream[classFileOffset++] = (byte)index;
			bCodeStream[classFileOffset++] = OPC_ret;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(OPC_ret);
		}
		try {
			position++;
			bCodeStream[classFileOffset++] = (byte) index;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray((byte) index);
		}
	}
}
final public void return_() {
	if (DEBUG) System.out.println(position + "\t\treturn"); //$NON-NLS-1$
	countLabels = 0;
	// the stackDepth should be equal to 0
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_return;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_return);
	}
}
final public void saload() {
	if (DEBUG) System.out.println(position + "\t\tsaload"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth--;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_saload;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_saload);
	}
}
final public void sastore() {
	if (DEBUG) System.out.println(position + "\t\tsastore"); //$NON-NLS-1$
	countLabels = 0;
	stackDepth -= 3;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_sastore;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_sastore);
	}
}
/**
 * @param operatorConstant int

	stackDepth++;
	if (stackDepth > stackMax)
		stackMax = stackDepth;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_sipush;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_sipush);
	}
	writeSignedShort(s);
}
public static final void sort(int[] tab, int lo0, int hi0, int[] result) {

final public void swap() {
	if (DEBUG) System.out.println(position + "\t\tswap"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_swap;	
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_swap);
	}
}
private static final void swap(int a[], int i, int j, int result[]) {
	int T;

	defaultLabel.placeInstruction();
	for (int i = 0; i < length; i++)
		casesLabel[i].placeInstruction();
	int switchCount = (3 - (pos % 4));
	checkOffset(classFileOffset + switchCount);
	position+= switchCount + 1;
	bCodeStream[classFileOffset++] = OPC_tableswitch;
	for (int i = switchCount; i > 0; i--) {
		bCodeStream[classFileOffset++] = (byte)0;
	for (int i = (3 - (pos % 4)); i > 0; i--) {
		try {
			position++;
			bCodeStream[classFileOffset++] = 0;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray((byte)0);
		}
	}
	defaultLabel.branch();
	writeSignedWord(low);

final public void wide() {
	if (DEBUG) System.out.println(position + "\t\twide"); //$NON-NLS-1$
	countLabels = 0;
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = OPC_wide;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(OPC_wide);
	}
}
public final void writeByte(byte value) {
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = (byte)value;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray(value);
	}
}
public final void writeByteAtPos(int pos, byte value) {
	checkOffset(pos);
	bCodeStream[pos] = value; 
	} catch (IndexOutOfBoundsException ex) {
		resizeByteArray();
		bCodeStream[pos] = value;
	}
}
/**
 * Write a unsigned 8 bits value into the byte array
 * @param b the signed byte
 */
public final void writeSignedByte(int value) {
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = (byte)value;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray((byte) value);
	}
}
/**
 * Write a signed 16 bits value into the byte array
 * @param value the signed short
 */
public final void writeSignedShort(int value) {
	checkOffset(classFileOffset + 1);
	position+=2;
	bCodeStream[classFileOffset++] = (byte) (value >> 8);
	bCodeStream[classFileOffset++] = (byte)value;
		resizeByteArray((byte) (value >> 8));
	}
	try {
		position++;
		bCodeStream[classFileOffset++] = (byte) value;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray((byte) value);
	}
}
public final void writeSignedShort(int pos, int value) {
	int currentOffset = startingClassFileOffset + pos;
	checkOffset(currentOffset + 1);
	bCodeStream[currentOffset++] = (byte) (value >> 8);
	bCodeStream[currentOffset] = (byte) value;
		resizeByteArray();
		bCodeStream[currentOffset] = (byte) (value >> 8);
	}
	try {
		bCodeStream[currentOffset + 1] = (byte) value;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray();
		bCodeStream[currentOffset + 1] = (byte) value;
	}
}
public final void writeSignedWord(int value) {
	checkOffset(classFileOffset + 3);
	position+=4;
	bCodeStream[classFileOffset++] = (byte) ((value & 0xFF000000) >> 24);
	bCodeStream[classFileOffset++] = (byte) ((value & 0xFF0000) >> 16);
	bCodeStream[classFileOffset++] = (byte) ((value & 0xFF00) >> 8);
	bCodeStream[classFileOffset++] = (byte) (value & 0xFF);
	try {
		position++;
		bCodeStream[classFileOffset++] = (byte) ((value & 0xFF0000) >> 16);
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray((byte) ((value & 0xFF0000) >> 16));
	}
	try {
		position++;
		bCodeStream[classFileOffset++] = (byte) ((value & 0xFF00) >> 8);
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray((byte) ((value & 0xFF00) >> 8));
	}
	try {
		position++;
		bCodeStream[classFileOffset++] = (byte) (value & 0xFF);
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray((byte) (value & 0xFF));
	}
}
public final void writeSignedWord(int pos, int value) {
	int currentOffset = startingClassFileOffset + pos;
	checkOffset(currentOffset + 3);
	bCodeStream[currentOffset++] = (byte) ((value & 0xFF000000) >> 24);
	bCodeStream[currentOffset++] = (byte) ((value & 0xFF0000) >> 16);
	bCodeStream[currentOffset++] = (byte) ((value & 0xFF00) >> 8);
	bCodeStream[currentOffset] = (byte) (value & 0xFF);
	}
	try {
		bCodeStream[currentOffset++] = (byte) ((value & 0xFF0000) >> 16);
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray();
		bCodeStream[currentOffset-1] = (byte) ((value & 0xFF0000) >> 16);
	}
	try {
		bCodeStream[currentOffset++] = (byte) ((value & 0xFF00) >> 8);
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray();
		bCodeStream[currentOffset-1] = (byte) ((value & 0xFF00) >> 8);
	}
	try {
		bCodeStream[currentOffset++] = (byte) (value & 0xFF);
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray();
		bCodeStream[currentOffset-1] = (byte) (value & 0xFF);
	}
}
/**
 * Write a unsigned 8 bits value into the byte array
 * @param b the unsigned byte
 */
public final void writeUnsignedByte(int value) {
	checkOffset(classFileOffset);
	position++;
	bCodeStream[classFileOffset++] = (byte) value;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray((byte) value);
	}
}
/**
 * Write a unsigned 16 bits value into the byte array
 * @param b the unsigned short
 */
public final void writeUnsignedShort(int value) {
	checkOffset(classFileOffset + 1);
	position+=2;
	bCodeStream[classFileOffset++] = (byte) (value >>> 8);
	bCodeStream[classFileOffset++] = (byte) value;
		resizeByteArray((byte) (value >>> 8));
	}
	try {
		position++;
		bCodeStream[classFileOffset++] = (byte) value;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray((byte) value);
	}
}
/**
 * Write a unsigned 32 bits value into the byte array
 * @param value the unsigned word
 */
public final void writeUnsignedWord(int value) {
	checkOffset(classFileOffset + 3);
	position+=4;
	bCodeStream[classFileOffset++] = ((byte) (value >>> 24));
	bCodeStream[classFileOffset++] = ((byte) (value >>> 16));
	bCodeStream[classFileOffset++] = ((byte) (value >>> 8));
	bCodeStream[classFileOffset++] = ((byte) value);
	try {
		position++;
		bCodeStream[classFileOffset++] = (byte) (value >>> 16);
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray((byte) (value >>> 16));
	}
	try {
		position++;
		bCodeStream[classFileOffset++] = (byte) (value >>> 8);
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray((byte) (value >>> 8));
	}
	try {
		position++;
		bCodeStream[classFileOffset++] = (byte) value;
	} catch (IndexOutOfBoundsException e) {
		resizeByteArray((byte) value);
	}
}



 */
public void generateWideRevertedConditionalBranch(byte revertedOpcode, Label wideTarget) {
		Label intermediate = new Label(this);
		checkOffset(classFileOffset);
		position++;
		bCodeStream[classFileOffset++] = revertedOpcode;
		} catch (IndexOutOfBoundsException e) {
			resizeByteArray(revertedOpcode);
		}
		intermediate.branch();
		this.goto_w(wideTarget);
		intermediate.place();




		writeU1(DoubleTag);
		// Then add the 8 bytes representing the double
		long temp = java.lang.Double.doubleToLongBits(key);
		checkOffset(currentOffset + 7);
		for (int i = 0; i < 8; i++) {
			poolContent[currentOffset++] =(byte) (temp >>> (56 - (i << 3)));
				poolContent[currentOffset++] = (byte) (temp >>> (56 - (i << 3)));
			} catch (IndexOutOfBoundsException e) { //currentOffset has been ++ already (see the -1)
				int length = poolContent.length;
				System.arraycopy(poolContent, 0, (poolContent = new byte[(length << 1) + CONSTANTPOOL_INITIAL_SIZE]), 0, length);
				poolContent[currentOffset - 1] = (byte) (temp >>> (56 - (i << 3)));
			}
		}
	}
	return index;

		writeU1(FloatTag);
		// Then add the 4 bytes representing the float
		int temp = java.lang.Float.floatToIntBits(key);
		checkOffset(currentOffset + 3);
		for (int i = 0; i < 4; i++) {
			poolContent[currentOffset++] = (byte) (temp >>> (24 - i * 8));
				poolContent[currentOffset++] = (byte) (temp >>> (24 - i * 8));
			} catch (IndexOutOfBoundsException e) { //currentOffset has been ++ already (see the -1)
				int length = poolContent.length;
				System.arraycopy(poolContent, 0, (poolContent = new byte[length * 2 + CONSTANTPOOL_INITIAL_SIZE]), 0, length);
				poolContent[currentOffset - 1] = (byte) (temp >>> (24 - i * 8));
			}
		}
	}
	return index;

		// First add the tag
		writeU1(IntegerTag);
		// Then add the 4 bytes representing the int
		checkOffset(currentOffset + 3);
		for (int i = 0; i < 4; i++) {
			poolContent[currentOffset++] = (byte) (key >>> (24 - i * 8));
				poolContent[currentOffset++] = (byte) (key >>> (24 - i * 8));
			} catch (IndexOutOfBoundsException e) { //currentOffset has been ++ already (see the -1)
				int length = poolContent.length;
				System.arraycopy(poolContent, 0, (poolContent = new byte[length * 2 + CONSTANTPOOL_INITIAL_SIZE]), 0, length);
				poolContent[currentOffset - 1] = (byte) (key >>> (24 - i * 8));
			}
		}
	}
	return index;

		// First add the tag
		writeU1(LongTag);
		// Then add the 8 bytes representing the long
		checkOffset(currentOffset + 7);
		for (int i = 0; i < 8; i++) {
			poolContent[currentOffset++] = (byte) (key >>> (56 - (i << 3)));
				poolContent[currentOffset++] = (byte) (key >>> (56 - (i << 3)));
			} catch (IndexOutOfBoundsException e) { //currentOffset has been ++ already (see the -1)
				int length = poolContent.length;
				System.arraycopy(poolContent, 0, (poolContent = new byte[(length << 1) + CONSTANTPOOL_INITIAL_SIZE]), 0, length);
				poolContent[currentOffset - 1] = (byte) (key >>> (56 - (i << 3)));
			}
		}
	}
	return index;

 * @param <CODE>int</CODE> The value to write into the byte array
 */
protected final void writeU1(int value) {
	checkOffset(currentOffset);
	poolContent[currentOffset++] = (byte)value;
	} catch (IndexOutOfBoundsException e) {
		//currentOffset has been ++ already (see the -1)
		int length = poolContent.length;
		System.arraycopy(poolContent, 0, (poolContent = new byte[length + CONSTANTPOOL_GROW_SIZE]), 0, length);
		poolContent[currentOffset - 1] = (byte) value;
	}
}
/**
 * Write a unsigned byte into the byte array

 */
protected final void writeU2(int value) {
	//first byte
	checkOffset(currentOffset + 1);
	poolContent[currentOffset++] = (byte) (value >> 8);
	poolContent[currentOffset++] = (byte) value;
}

protected final void checkOffset(int offset) {
	if (offset >= poolContent.length) {
	}
	try {
		poolContent[currentOffset++] = (byte) value;
	} catch (IndexOutOfBoundsException e) {
		 //currentOffset has been ++ already (see the -1)
		int length = poolContent.length;
		System.arraycopy(poolContent, 0, (poolContent = new byte[length + CONSTANTPOOL_GROW_SIZE]), 0, length);
		poolContent[currentOffset - 1] = (byte) value;
	}
}
}




	/*add a new obj on top of the ast stack
	astPtr points on the top*/

	this.astPtr++;
	if (this.astPtr == this.astStack.length) {
	} catch (IndexOutOfBoundsException e) {
		int oldStackLength = this.astStack.length;
		ASTNode[] oldStack = this.astStack;
		this.astStack = new ASTNode[oldStackLength + AstStackIncrement];
		System.arraycopy(oldStack, 0, this.astStack, 0, oldStackLength);
		this.astPtr = oldStackLength;
		this.astStack[this.astPtr] = node;
	}
	this.astStack[this.astPtr] = node;

	this.astLengthPtr++;
	if (this.astLengthPtr == this.astLengthStack.length) {
	} catch (IndexOutOfBoundsException e) {
		int oldStackLength = this.astLengthStack.length;
		int[] oldPos = this.astLengthStack;
		this.astLengthStack = new int[oldStackLength + AstStackIncrement];
		System.arraycopy(oldPos, 0, this.astLengthStack, 0, oldStackLength);
		this.astLengthStack[this.astLengthPtr] = 1;
	}
	this.astLengthStack[this.astLengthPtr] = 1;
}
protected void pushOnExpressionStack(Expression expr) {
	this.expressionPtr++;
	if (this.expressionPtr == this.expressionStack.length) {
		this.expressionStack[++this.expressionPtr] = expr;
	} catch (IndexOutOfBoundsException e) {
		//this.expressionPtr is correct 
		int oldStackLength = this.expressionStack.length;
		Expression[] oldStack = this.expressionStack;
		this.expressionStack = new Expression[oldStackLength + ExpressionStackIncrement];
		System.arraycopy(oldStack, 0, this.expressionStack, 0, oldStackLength);		
		this.expressionStack[this.expressionPtr] = expr;
	}

	this.expressionStack[this.expressionPtr] = expr;
	pushOnExpressionStackLengthStack(1);
	} catch (IndexOutOfBoundsException e) {
		int oldStackLength = this.expressionLengthStack.length;
		int[] oldPos = this.expressionLengthStack;
		this.expressionLengthStack = new int[oldStackLength + ExpressionStackIncrement];
		System.arraycopy(oldPos, 0, this.expressionLengthStack, 0, oldStackLength);
		this.expressionLengthStack[this.expressionLengthPtr] = 1;
	}
}
protected void pushOnExpressionStackLengthStack(int pos) {
	this.expressionLengthPtr++;
	if (this.expressionLengthPtr == this.expressionLengthStack.length) {
	} catch (IndexOutOfBoundsException e) {
		int oldStackLength = this.expressionLengthStack.length;
		int[] oldPos = this.expressionLengthStack;
		this.expressionLengthStack = new int[oldStackLength + StackIncrement];
		System.arraycopy(oldPos, 0, this.expressionLengthStack, 0, oldStackLength);		
		this.expressionLengthStack[this.expressionLengthPtr] = pos;
	}
	
	this.expressionLengthStack[this.expressionLengthPtr] = pos;
}
protected void pushOnIntStack(int pos) {





		//TODO (olivier) david - why the following line was "if ((this.linePtr > 0) && (this.lineEnds[this.linePtr] >= separatorPos)) return;" ?
		if ((this.linePtr >= 0) && (this.lineEnds[this.linePtr] >= separatorPos)) return;
		//System.out.println("CR-" + separatorPos);
		this.linePtr++;
		if (this.linePtr == this.lineEnds.length) {
		} catch (IndexOutOfBoundsException e) {
			//this.linePtr value is correct
			int oldLength = this.lineEnds.length;
			int[] old = this.lineEnds;
			this.lineEnds = new int[oldLength + INCREMENT];
			System.arraycopy(old, 0, this.lineEnds, 0, oldLength);
			this.lineEnds[this.linePtr] = separatorPos;
		}
		this.lineEnds[this.linePtr] = separatorPos;

		// look-ahead for merged cr+lf
		try {
			if (this.source[this.currentPosition] == '\n') {

				int separatorPos = this.currentPosition - 1;
				//TODO (olivier) david - why the following line was "if ((this.linePtr > 0) && (this.lineEnds[this.linePtr] >= separatorPos)) return;" ?
				if ((this.linePtr >= 0) && (this.lineEnds[this.linePtr] >= separatorPos)) return;
				// System.out.println("LF-" + separatorPos);
				++this.linePtr;
				if (this.linePtr == this.lineEnds.length) {
				} catch (IndexOutOfBoundsException e) {
					//this.linePtr value is correct
					int oldLength = this.lineEnds.length;
					int[] old = this.lineEnds;
					this.lineEnds = new int[oldLength + INCREMENT];
					System.arraycopy(old, 0, this.lineEnds, 0, oldLength);
					this.lineEnds[this.linePtr] = separatorPos;
				}
				this.lineEnds[this.linePtr] = separatorPos;
			}
			this.wasAcr = false;
		}

	}

	// a new comment is recorded
	this.commentPtr++;
	if (this.commentPtr == this.commentStops.length) {
	} catch (IndexOutOfBoundsException e) {
		int oldStackLength = this.commentStops.length;
		int[] oldStack = this.commentStops;
		this.commentStops = new int[oldStackLength + 30];
		System.arraycopy(oldStack, 0, this.commentStops, 0, oldStackLength);
		this.commentStops[this.commentPtr] = stopPosition;
		//grows the positions buffers too
		int[] old = this.commentStarts;
		this.commentStarts = new int[oldStackLength + 30];
		System.arraycopy(old, 0, this.commentStarts, 0, oldStackLength);
	}
	this.commentStops[this.commentPtr] = stopPosition;

	//the buffer is of a correct size here
	this.commentStarts[this.commentPtr] = this.startPosition;




			int scannerStart = this.scanner.commentStarts[i]<0 ? -this.scanner.commentStarts[i] : this.scanner.commentStarts[i];
			int commentStart = this.commentPtr == -1 ? -1 : (this.commentStarts[this.commentPtr]<0 ? -this.commentStarts[this.commentPtr] : this.commentStarts[this.commentPtr]);
			if (commentStart == -1 ||  scannerStart > commentStart) {
				this.commentPtr++;
				if (commentPtr == this.commentStarts.length) {
					this.commentStarts[this.commentPtr] = this.scanner.commentStarts[i];
					this.commentStops[this.commentPtr] = this.scanner.commentStops[i];
				} catch (IndexOutOfBoundsException e) {
					// this.commentPtr is still correct 
					int oldStackLength = this.commentStarts.length;
					int oldCommentStarts[] = this.commentStarts;
					this.commentStarts = new int[oldStackLength + CommentIncrement];
					System.arraycopy(oldCommentStarts, 0, this.commentStarts, 0, oldStackLength);
					this.commentStarts[this.commentPtr] = this.scanner.commentStarts[i];
					int oldCommentStops[] = this.commentStops;
					this.commentStops = new int[oldStackLength + CommentIncrement];
					System.arraycopy(oldCommentStops, 0, this.commentStops, 0, oldStackLength);
					this.commentStops[this.commentPtr] = this.scanner.commentStops[i];
				}
				this.commentStarts[this.commentPtr] = this.scanner.commentStarts[i];
				this.commentStops[this.commentPtr] = this.scanner.commentStops[i];
			}
		}
	}

Return to bug 61075

Lines 766-779 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/codegen/ConstantPool.java (-49 / +17 lines)
766	writeU1(DoubleTag);	766	writeU1(DoubleTag);
767	// Then add the 8 bytes representing the double	767	// Then add the 8 bytes representing the double
768	long temp = java.lang.Double.doubleToLongBits(key);	768	long temp = java.lang.Double.doubleToLongBits(key);
		769	checkOffset(currentOffset + 7);
769	for (int i = 0; i < 8; i++) {	770	for (int i = 0; i < 8; i++) {
770	try {	771	poolContent[currentOffset++] =(byte) (temp >>> (56 - (i << 3)));
771	poolContent[currentOffset++] = (byte) (temp >>> (56 - (i << 3)));
772	} catch (IndexOutOfBoundsException e) { //currentOffset has been ++ already (see the -1)
773	int length = poolContent.length;
774	System.arraycopy(poolContent, 0, (poolContent = new byte[(length << 1) + CONSTANTPOOL_INITIAL_SIZE]), 0, length);
775	poolContent[currentOffset - 1] = (byte) (temp >>> (56 - (i << 3)));
776	}
777	}	772	}
778	}	773	}
779	return index;	774	return index;
Lines 804-817 Link Here
804	writeU1(FloatTag);	799	writeU1(FloatTag);
805	// Then add the 4 bytes representing the float	800	// Then add the 4 bytes representing the float
806	int temp = java.lang.Float.floatToIntBits(key);	801	int temp = java.lang.Float.floatToIntBits(key);
		802	checkOffset(currentOffset + 3);
807	for (int i = 0; i < 4; i++) {	803	for (int i = 0; i < 4; i++) {
808	try {	804	poolContent[currentOffset++] = (byte) (temp >>> (24 - i * 8));
809	poolContent[currentOffset++] = (byte) (temp >>> (24 - i * 8));
810	} catch (IndexOutOfBoundsException e) { //currentOffset has been ++ already (see the -1)
811	int length = poolContent.length;
812	System.arraycopy(poolContent, 0, (poolContent = new byte[length * 2 + CONSTANTPOOL_INITIAL_SIZE]), 0, length);
813	poolContent[currentOffset - 1] = (byte) (temp >>> (24 - i * 8));
814	}
815	}	805	}
816	}	806	}
817	return index;	807	return index;
Lines 841-854 Link Here
841	// First add the tag	831	// First add the tag
842	writeU1(IntegerTag);	832	writeU1(IntegerTag);
843	// Then add the 4 bytes representing the int	833	// Then add the 4 bytes representing the int
		834	checkOffset(currentOffset + 3);
844	for (int i = 0; i < 4; i++) {	835	for (int i = 0; i < 4; i++) {
845	try {	836	poolContent[currentOffset++] = (byte) (key >>> (24 - i * 8));
846	poolContent[currentOffset++] = (byte) (key >>> (24 - i * 8));
847	} catch (IndexOutOfBoundsException e) { //currentOffset has been ++ already (see the -1)
848	int length = poolContent.length;
849	System.arraycopy(poolContent, 0, (poolContent = new byte[length * 2 + CONSTANTPOOL_INITIAL_SIZE]), 0, length);
850	poolContent[currentOffset - 1] = (byte) (key >>> (24 - i * 8));
851	}
852	}	837	}
853	}	838	}
854	return index;	839	return index;
Lines 881-894 Link Here
881	// First add the tag	866	// First add the tag
882	writeU1(LongTag);	867	writeU1(LongTag);
883	// Then add the 8 bytes representing the long	868	// Then add the 8 bytes representing the long
		869	checkOffset(currentOffset + 7);
884	for (int i = 0; i < 8; i++) {	870	for (int i = 0; i < 8; i++) {
885	try {	871	poolContent[currentOffset++] = (byte) (key >>> (56 - (i << 3)));
886	poolContent[currentOffset++] = (byte) (key >>> (56 - (i << 3)));
887	} catch (IndexOutOfBoundsException e) { //currentOffset has been ++ already (see the -1)
888	int length = poolContent.length;
889	System.arraycopy(poolContent, 0, (poolContent = new byte[(length << 1) + CONSTANTPOOL_INITIAL_SIZE]), 0, length);
890	poolContent[currentOffset - 1] = (byte) (key >>> (56 - (i << 3)));
891	}
892	}	872	}
893	}	873	}
894	return index;	874	return index;
Lines 3090-3103 Link Here
3090	* @param <CODE>int</CODE> The value to write into the byte array	3070	* @param <CODE>int</CODE> The value to write into the byte array
3091	*/	3071	*/
3092	protected final void writeU1(int value) {	3072	protected final void writeU1(int value) {
3093	try {	3073	checkOffset(currentOffset);
3094	poolContent[currentOffset++] = (byte) value;	3074	poolContent[currentOffset++] = (byte)value;
3095	} catch (IndexOutOfBoundsException e) {
3096	//currentOffset has been ++ already (see the -1)
3097	int length = poolContent.length;
3098	System.arraycopy(poolContent, 0, (poolContent = new byte[length + CONSTANTPOOL_GROW_SIZE]), 0, length);
3099	poolContent[currentOffset - 1] = (byte) value;
3100	}
3101	}	3075	}
3102	/**	3076	/**
3103	* Write a unsigned byte into the byte array	3077	* Write a unsigned byte into the byte array
Lines 3106-3126 Link Here
3106	*/	3080	*/
3107	protected final void writeU2(int value) {	3081	protected final void writeU2(int value) {
3108	//first byte	3082	//first byte
3109	try {	3083	checkOffset(currentOffset + 1);
3110	poolContent[currentOffset++] = (byte) (value >> 8);	3084	poolContent[currentOffset++] = (byte) (value >> 8);
3111	} catch (IndexOutOfBoundsException e) {	3085	poolContent[currentOffset++] = (byte) value;
3112	//currentOffset has been ++ already (see the -1)	3086	}
3113	int length = poolContent.length;	3087
3114	System.arraycopy(poolContent, 0, (poolContent = new byte[length + CONSTANTPOOL_GROW_SIZE]), 0, length);	3088	protected final void checkOffset(int offset) {
3115	poolContent[currentOffset - 1] = (byte) (value >> 8);	3089	if (offset >= poolContent.length) {
3116	}
3117	try {
3118	poolContent[currentOffset++] = (byte) value;
3119	} catch (IndexOutOfBoundsException e) {
3120	//currentOffset has been ++ already (see the -1)
3121	int length = poolContent.length;	3090	int length = poolContent.length;
3122	System.arraycopy(poolContent, 0, (poolContent = new byte[length + CONSTANTPOOL_GROW_SIZE]), 0, length);	3091	System.arraycopy(poolContent, 0, (poolContent = new byte[length + CONSTANTPOOL_GROW_SIZE]), 0, length);
3123	poolContent[currentOffset - 1] = (byte) value;
3124	}	3092	}
3125	}	3093	}
3126	}	3094	}

Lines 5841-5900 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java (-29 / +16 lines)
5841	/*add a new obj on top of the ast stack	5841	/*add a new obj on top of the ast stack
5842	astPtr points on the top*/	5842	astPtr points on the top*/
5843		5843
5844	try {	5844	this.astPtr++;
5845	this.astStack[++this.astPtr] = node;	5845	if (this.astPtr == this.astStack.length) {
5846	} catch (IndexOutOfBoundsException e) {
5847	int oldStackLength = this.astStack.length;	5846	int oldStackLength = this.astStack.length;
5848	ASTNode[] oldStack = this.astStack;	5847	ASTNode[] oldStack = this.astStack;
5849	this.astStack = new ASTNode[oldStackLength + AstStackIncrement];	5848	this.astStack = new ASTNode[oldStackLength + AstStackIncrement];
5850	System.arraycopy(oldStack, 0, this.astStack, 0, oldStackLength);	5849	System.arraycopy(oldStack, 0, this.astStack, 0, oldStackLength);
5851	this.astPtr = oldStackLength;	5850	this.astPtr = oldStackLength;
5852	this.astStack[this.astPtr] = node;
5853	}	5851	}
		5852	this.astStack[this.astPtr] = node;
5854		5853
5855	try {	5854	this.astLengthPtr++;
5856	this.astLengthStack[++this.astLengthPtr] = 1;	5855	if (this.astLengthPtr == this.astLengthStack.length) {
5857	} catch (IndexOutOfBoundsException e) {
5858	int oldStackLength = this.astLengthStack.length;	5856	int oldStackLength = this.astLengthStack.length;
5859	int[] oldPos = this.astLengthStack;	5857	int[] oldPos = this.astLengthStack;
5860	this.astLengthStack = new int[oldStackLength + AstStackIncrement];	5858	this.astLengthStack = new int[oldStackLength + AstStackIncrement];
5861	System.arraycopy(oldPos, 0, this.astLengthStack, 0, oldStackLength);	5859	System.arraycopy(oldPos, 0, this.astLengthStack, 0, oldStackLength);
5862	this.astLengthStack[this.astLengthPtr] = 1;
5863	}	5860	}
		5861	this.astLengthStack[this.astLengthPtr] = 1;
5864	}	5862	}
5865	protected void pushOnExpressionStack(Expression expr) {	5863	protected void pushOnExpressionStack(Expression expr) {
5866		5864	this.expressionPtr++;
5867	try {	5865	if (this.expressionPtr == this.expressionStack.length) {
5868	this.expressionStack[++this.expressionPtr] = expr;
5869	} catch (IndexOutOfBoundsException e) {
5870	//this.expressionPtr is correct
5871	int oldStackLength = this.expressionStack.length;	5866	int oldStackLength = this.expressionStack.length;
5872	Expression[] oldStack = this.expressionStack;	5867	Expression[] oldStack = this.expressionStack;
5873	this.expressionStack = new Expression[oldStackLength + ExpressionStackIncrement];	5868	this.expressionStack = new Expression[oldStackLength + ExpressionStackIncrement];
5874	System.arraycopy(oldStack, 0, this.expressionStack, 0, oldStackLength);	5869	System.arraycopy(oldStack, 0, this.expressionStack, 0, oldStackLength);
5875	this.expressionStack[this.expressionPtr] = expr;
5876	}	5870	}
5877		5871
5878	try {	5872	this.expressionStack[this.expressionPtr] = expr;
5879	this.expressionLengthStack[++this.expressionLengthPtr] = 1;	5873	pushOnExpressionStackLengthStack(1);
5880	} catch (IndexOutOfBoundsException e) {
5881	int oldStackLength = this.expressionLengthStack.length;
5882	int[] oldPos = this.expressionLengthStack;
5883	this.expressionLengthStack = new int[oldStackLength + ExpressionStackIncrement];
5884	System.arraycopy(oldPos, 0, this.expressionLengthStack, 0, oldStackLength);
5885	this.expressionLengthStack[this.expressionLengthPtr] = 1;
5886	}
5887	}	5874	}
5888	protected void pushOnExpressionStackLengthStack(int pos) {	5875	protected void pushOnExpressionStackLengthStack(int pos) {
5889	try {	5876	this.expressionLengthPtr++;
5890	this.expressionLengthStack[++this.expressionLengthPtr] = pos;	5877	if (this.expressionLengthPtr == this.expressionLengthStack.length) {
5891	} catch (IndexOutOfBoundsException e) {
5892	int oldStackLength = this.expressionLengthStack.length;	5878	int oldStackLength = this.expressionLengthStack.length;
5893	int[] oldPos = this.expressionLengthStack;	5879	int[] oldPos = this.expressionLengthStack;
5894	this.expressionLengthStack = new int[oldStackLength + StackIncrement];	5880	this.expressionLengthStack = new int[oldStackLength + StackIncrement];
5895	System.arraycopy(oldPos, 0, this.expressionLengthStack, 0, oldStackLength);	5881	System.arraycopy(oldPos, 0, this.expressionLengthStack, 0, oldStackLength);
5896	this.expressionLengthStack[this.expressionLengthPtr] = pos;
5897	}	5882	}
		5883
		5884	this.expressionLengthStack[this.expressionLengthPtr] = pos;
5898	}	5885	}
5899	protected void pushOnIntStack(int pos) {	5886	protected void pushOnIntStack(int pos) {
5900		5887

Lines 2235-2250 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/parser/Scanner.java (-14 / +11 lines)
2235	//TODO (olivier) david - why the following line was "if ((this.linePtr > 0) && (this.lineEnds[this.linePtr] >= separatorPos)) return;" ?	2235	//TODO (olivier) david - why the following line was "if ((this.linePtr > 0) && (this.lineEnds[this.linePtr] >= separatorPos)) return;" ?
2236	if ((this.linePtr >= 0) && (this.lineEnds[this.linePtr] >= separatorPos)) return;	2236	if ((this.linePtr >= 0) && (this.lineEnds[this.linePtr] >= separatorPos)) return;
2237	//System.out.println("CR-" + separatorPos);	2237	//System.out.println("CR-" + separatorPos);
2238	try {	2238	this.linePtr++;
2239	this.lineEnds[++this.linePtr] = separatorPos;	2239	if (this.linePtr == this.lineEnds.length) {
2240	} catch (IndexOutOfBoundsException e) {
2241	//this.linePtr value is correct	2240	//this.linePtr value is correct
2242	int oldLength = this.lineEnds.length;	2241	int oldLength = this.lineEnds.length;
2243	int[] old = this.lineEnds;	2242	int[] old = this.lineEnds;
2244	this.lineEnds = new int[oldLength + INCREMENT];	2243	this.lineEnds = new int[oldLength + INCREMENT];
2245	System.arraycopy(old, 0, this.lineEnds, 0, oldLength);	2244	System.arraycopy(old, 0, this.lineEnds, 0, oldLength);
2246	this.lineEnds[this.linePtr] = separatorPos;
2247	}	2245	}
		2246	this.lineEnds[this.linePtr] = separatorPos;
		2247
2248	// look-ahead for merged cr+lf	2248	// look-ahead for merged cr+lf
2249	try {	2249	try {
2250	if (this.source[this.currentPosition] == '\n') {	2250	if (this.source[this.currentPosition] == '\n') {
Lines 2268-2284 Link Here
2268	int separatorPos = this.currentPosition - 1;	2268	int separatorPos = this.currentPosition - 1;
2269	//TODO (olivier) david - why the following line was "if ((this.linePtr > 0) && (this.lineEnds[this.linePtr] >= separatorPos)) return;" ?	2269	//TODO (olivier) david - why the following line was "if ((this.linePtr > 0) && (this.lineEnds[this.linePtr] >= separatorPos)) return;" ?
2270	if ((this.linePtr >= 0) && (this.lineEnds[this.linePtr] >= separatorPos)) return;	2270	if ((this.linePtr >= 0) && (this.lineEnds[this.linePtr] >= separatorPos)) return;
2271	// System.out.println("LF-" + separatorPos);	2271	// System.out.println("LF-" + separatorPos);
2272	try {	2272	++this.linePtr;
2273	this.lineEnds[++this.linePtr] = separatorPos;	2273	if (this.linePtr == this.lineEnds.length) {
2274	} catch (IndexOutOfBoundsException e) {
2275	//this.linePtr value is correct
2276	int oldLength = this.lineEnds.length;	2274	int oldLength = this.lineEnds.length;
2277	int[] old = this.lineEnds;	2275	int[] old = this.lineEnds;
2278	this.lineEnds = new int[oldLength + INCREMENT];	2276	this.lineEnds = new int[oldLength + INCREMENT];
2279	System.arraycopy(old, 0, this.lineEnds, 0, oldLength);	2277	System.arraycopy(old, 0, this.lineEnds, 0, oldLength);
2280	this.lineEnds[this.linePtr] = separatorPos;
2281	}	2278	}
		2279	this.lineEnds[this.linePtr] = separatorPos;
2282	}	2280	}
2283	this.wasAcr = false;	2281	this.wasAcr = false;
2284	}	2282	}
Lines 2317-2335 Link Here
2317	}	2315	}
2318		2316
2319	// a new comment is recorded	2317	// a new comment is recorded
2320	try {	2318	this.commentPtr++;
2321	this.commentStops[++this.commentPtr] = stopPosition;	2319	if (this.commentPtr == this.commentStops.length) {
2322	} catch (IndexOutOfBoundsException e) {
2323	int oldStackLength = this.commentStops.length;	2320	int oldStackLength = this.commentStops.length;
2324	int[] oldStack = this.commentStops;	2321	int[] oldStack = this.commentStops;
2325	this.commentStops = new int[oldStackLength + 30];	2322	this.commentStops = new int[oldStackLength + 30];
2326	System.arraycopy(oldStack, 0, this.commentStops, 0, oldStackLength);	2323	System.arraycopy(oldStack, 0, this.commentStops, 0, oldStackLength);
2327	this.commentStops[this.commentPtr] = stopPosition;
2328	//grows the positions buffers too	2324	//grows the positions buffers too
2329	int[] old = this.commentStarts;	2325	int[] old = this.commentStarts;
2330	this.commentStarts = new int[oldStackLength + 30];	2326	this.commentStarts = new int[oldStackLength + 30];
2331	System.arraycopy(old, 0, this.commentStarts, 0, oldStackLength);	2327	System.arraycopy(old, 0, this.commentStarts, 0, oldStackLength);
2332	}	2328	}
		2329	this.commentStops[this.commentPtr] = stopPosition;
2333		2330
2334	//the buffer is of a correct size here	2331	//the buffer is of a correct size here
2335	this.commentStarts[this.commentPtr] = this.startPosition;	2332	this.commentStarts[this.commentPtr] = this.startPosition;

Lines 234-255 Link Here

(-)model/org/eclipse/jdt/internal/core/util/CommentRecorderParser.java (-7 / +4 lines)
234	int scannerStart = this.scanner.commentStarts[i]<0 ? -this.scanner.commentStarts[i] : this.scanner.commentStarts[i];	234	int scannerStart = this.scanner.commentStarts[i]<0 ? -this.scanner.commentStarts[i] : this.scanner.commentStarts[i];
235	int commentStart = this.commentPtr == -1 ? -1 : (this.commentStarts[this.commentPtr]<0 ? -this.commentStarts[this.commentPtr] : this.commentStarts[this.commentPtr]);	235	int commentStart = this.commentPtr == -1 ? -1 : (this.commentStarts[this.commentPtr]<0 ? -this.commentStarts[this.commentPtr] : this.commentStarts[this.commentPtr]);
236	if (commentStart == -1 \|\| scannerStart > commentStart) {	236	if (commentStart == -1 \|\| scannerStart > commentStart) {
237	try {	237	this.commentPtr++;
238	this.commentPtr++;	238	if (commentPtr == this.commentStarts.length) {
239	this.commentStarts[this.commentPtr] = this.scanner.commentStarts[i];
240	this.commentStops[this.commentPtr] = this.scanner.commentStops[i];
241	} catch (IndexOutOfBoundsException e) {
242	// this.commentPtr is still correct	239	// this.commentPtr is still correct
243	int oldStackLength = this.commentStarts.length;	240	int oldStackLength = this.commentStarts.length;
244	int oldCommentStarts[] = this.commentStarts;	241	int oldCommentStarts[] = this.commentStarts;
245	this.commentStarts = new int[oldStackLength + CommentIncrement];	242	this.commentStarts = new int[oldStackLength + CommentIncrement];
246	System.arraycopy(oldCommentStarts, 0, this.commentStarts, 0, oldStackLength);	243	System.arraycopy(oldCommentStarts, 0, this.commentStarts, 0, oldStackLength);
247	this.commentStarts[this.commentPtr] = this.scanner.commentStarts[i];
248	int oldCommentStops[] = this.commentStops;	244	int oldCommentStops[] = this.commentStops;
249	this.commentStops = new int[oldStackLength + CommentIncrement];	245	this.commentStops = new int[oldStackLength + CommentIncrement];
250	System.arraycopy(oldCommentStops, 0, this.commentStops, 0, oldStackLength);	246	System.arraycopy(oldCommentStops, 0, this.commentStops, 0, oldStackLength);
251	this.commentStops[this.commentPtr] = this.scanner.commentStops[i];
252	}	247	}
		248	this.commentStarts[this.commentPtr] = this.scanner.commentStarts[i];
		249	this.commentStops[this.commentPtr] = this.scanner.commentStops[i];
253	}	250	}
254	}	251	}
255	}	252	}