Check that indices are correct before writing them out.

src/org/ow2/asmdex/instruction/Instruction.java

@@ -151,6 +151,23 @@ public abstract class Instruction {
 		}
 	}
 	
+    /**
+     * Tests if the given number can be held in 8 bits, throw an IllegalArgumentException otherwise.
+     */
+    public static void test8BitsLimit(int number) {
+        if ((number & 0xffffff00) != 0) {
+            throw new IllegalArgumentException("The number " + number +" can't be held in 8 bits !");
+        }
+    }
+
+    /**
+     * Tests if the given number can be held in 16 bits, throw an IllegalArgumentException otherwise.
+     */
+    public static void test16BitsLimit(int number) {
+        if ((number & 0xffff0000) != 0) {
+            throw new IllegalArgumentException("The number " + number +" can't be held in 16 bits !");
+        }
+    }
     /**
 	 * Tests if the given numbers can be held in 4 bits, throw an IllegalArgumentException otherwise.
 	 */
@@ -190,4 +207,5 @@ public abstract class Instruction {
 	public static byte getInstructionSizeInByte(int opcode) {
 		return instructionSizeInBytes[opcode];
 	}
+	
 }

src/org/ow2/asmdex/instruction/InstructionFormat11N.java

@@ -98,6 +98,7 @@ implements IOneRegisterInstruction, ILiteralInstruction {
 	
 	@Override
 	public void write(ByteVector out, ConstantPool constantPool) {
+	    test4BitsLimit(registerA);
 		int firstShort = ((literalB & 0xf) << 12) + ((registerA & 0xf) << 8) + opcodeByte;
 		out.putShort(firstShort);
 	}

src/org/ow2/asmdex/instruction/InstructionFormat11X.java

@@ -105,6 +105,7 @@ public class InstructionFormat11X extends Instruction implements IOneRegisterIns
 	
 	@Override
 	public void write(ByteVector out, ConstantPool constantPool) {
+	    test8BitsLimit(registerA);
 		out.putShort(((registerA & 0xff) << 8) + opcodeByte);
 	}
 

src/org/ow2/asmdex/instruction/InstructionFormat12X.java

@@ -139,6 +139,7 @@ public class InstructionFormat12X extends Instruction implements ITwoRegistersIn
 	
 	@Override
 	public void write(ByteVector out, ConstantPool constantPool) {
+	    test4BitsLimit(registerA | registerB);
 		int firstShort = ((registerB & 0xf) << 12) + ((registerA & 0xf) << 8) +	opcodeByte;
 		out.putShort(firstShort);
 	}

src/org/ow2/asmdex/instruction/InstructionFormat21C.java

@@ -162,6 +162,7 @@ implements IOneRegisterInstruction, IIndexInstruction {
 
 	@Override
 	public void write(ByteVector out, ConstantPool constantPool) {
+	    test8BitsLimit(registerA);
 		// The format is AA|op BBBB.
 		out.putShort(((registerA & 0xff) << 8) + opcodeByte);
 		// The index may be a Type, or a String index.

src/org/ow2/asmdex/instruction/InstructionFormat21H.java

@@ -138,6 +138,7 @@ implements IOneRegisterInstruction, ILiteralInstruction {
 
 	@Override
 	public void write(ByteVector out, ConstantPool constantPool) {
+	    test8BitsLimit(registerA);
 		out.putShort(((registerA & 0xff) << 8) + opcodeByte);
 		out.putShort(literalB & 0xffff);
 	}

src/org/ow2/asmdex/instruction/InstructionFormat21S.java

@@ -133,6 +133,7 @@ implements IOneRegisterInstruction, ILiteralInstruction {
 
 	@Override
 	public void write(ByteVector out, ConstantPool constantPool) {
+	    test8BitsLimit(registerA);
 		out.putShort(((registerA & 0xff) << 8) + opcodeByte);
 		out.putShort(literalB & 0xffff);
 	}

src/org/ow2/asmdex/instruction/InstructionFormat21T.java

@@ -162,6 +162,7 @@ implements IOneRegisterInstruction, IOffsetInstruction {
 	
 	@Override
 	public void write(ByteVector out, ConstantPool constantPool) {
+	    test8BitsLimit(registerA);
 		// The format is AA|op BBBB.
 		int firstShort = ((registerA & 0xff) << 8) + opcodeByte;
 		int secondShort = (label.getOffset() - instructionOffset) / 2; // / 2 because offsets are word-based.

src/org/ow2/asmdex/instruction/InstructionFormat22B.java

@@ -158,6 +158,7 @@ implements ITwoRegistersInstruction, ILiteralInstruction {
 
 	@Override
 	public void write(ByteVector out, ConstantPool constantPool) {
+	    test8BitsLimit(registerA | registerB);
 		out.putShort(((registerA & 0xff) << 8) + opcodeByte);
 		out.putShort(((literalC & 0xff) << 8) + (registerB & 0xff));
 	}

src/org/ow2/asmdex/instruction/InstructionFormat22C.java

@@ -189,6 +189,7 @@ implements ITwoRegistersInstruction, IIndexInstruction {
 	@Override
 	public void write(ByteVector out, ConstantPool constantPool) {
 		// The format is B|A|op CCCC.
+	    test8BitsLimit(registerA | registerB);
 		out.putShort((((registerA & 0xf) << 8) + ((registerB & 0xf) << 12)) + opcodeByte);
 		// The index may be a Type, or a Field index.
 		int index;

src/org/ow2/asmdex/instruction/InstructionFormat22S.java

@@ -147,6 +147,7 @@ implements ITwoRegistersInstruction, ILiteralInstruction {
 
 	@Override
 	public void write(ByteVector out, ConstantPool constantPool) {
+	    test4BitsLimit(registerA | registerB);
 		out.putShort((((registerA & 0xf) << 8) + ((registerB & 0xf) << 12)) + opcodeByte);
 		out.putShort(literalC & 0xffff);
 	}

src/org/ow2/asmdex/instruction/InstructionFormat22T.java

@@ -183,6 +183,8 @@ implements ITwoRegistersInstruction, IOffsetInstruction {
 	
 	@Override
 	public void write(ByteVector out, ConstantPool constantPool) {
+	    test4BitsLimit(registerA | registerB);
+	    
 		// The format is B|A|op CCCC.
 		int firstShort = ((registerB & 0xf) << 12) + ((registerA & 0xf) << 8) + opcodeByte;
 		int secondShort = (label.getOffset() - instructionOffset) / 2; // / 2 because offsets are word-based.

src/org/ow2/asmdex/instruction/InstructionFormat22X.java

@@ -134,6 +134,8 @@ implements ITwoRegistersInstruction {
 
 	@Override
 	public void write(ByteVector out, ConstantPool constantPool) {
+	    test8BitsLimit(registerA);
+	    test16BitsLimit(registerB);
 		int firstShort = ((registerA & 0xff) << 8) + opcodeByte;
 		out.putShort(firstShort);
 		out.putShort(registerB & 0xffff);

src/org/ow2/asmdex/instruction/InstructionFormat23X.java

@@ -197,6 +197,7 @@ implements IThreeRegistersInstruction {
 
 	@Override
 	public void write(ByteVector out, ConstantPool constantPool) {
+	    test8BitsLimit(registerA | registerB | registerC);
 		out.putShort(((registerA & 0xff) << 8) + opcodeByte);
 		out.putShort(((registerC & 0xff) << 8) + (registerB & 0xff)); 
 	}

src/org/ow2/asmdex/instruction/InstructionFormat31C.java

@@ -132,6 +132,7 @@ implements IOneRegisterInstruction, IIndexInstruction {
 
 	@Override
 	public void write(ByteVector out, ConstantPool constantPool) {
+	    test8BitsLimit(registerA);
 		// The format is AA|op BBBBlo BBBBhi.
 		out.putShort(((registerA & 0xff) << 8) + opcodeByte);
 		int index = constantPool.getStringIndex(string);

src/org/ow2/asmdex/instruction/InstructionFormat31I.java

@@ -134,6 +134,7 @@ implements IOneRegisterInstruction, ILiteralInstruction {
 
 	@Override
 	public void write(ByteVector out, ConstantPool constantPool) {
+	    test8BitsLimit(registerA);
 		out.putShort(((registerA & 0xff) << 8) + opcodeByte);
 		out.putShort(literalB & 0xffff);
 		out.putShort((literalB >> 16) & 0xffff);

src/org/ow2/asmdex/instruction/InstructionFormat31T.java

@@ -168,6 +168,7 @@ implements IOneRegisterInstruction, IOffsetInstruction {
 	@Override
 	public void write(ByteVector out, ConstantPool constantPool) {
 		// The format is AA|op BBBBlo BBBBhi.
+	    test8BitsLimit(registerA);
 		out.putShort(((registerA & 0xff) << 8) + opcodeByte);
 		int branchOffset = (label.getOffset() - instructionOffset) / 2; // / 2 because offsets are word-based. 
 		out.putShort(branchOffset & 0xffff);

src/org/ow2/asmdex/instruction/InstructionFormat32X.java

@@ -136,6 +136,7 @@ implements ITwoRegistersInstruction {
 
 	@Override
 	public void write(ByteVector out, ConstantPool constantPool) {
+	    test16BitsLimit(registerA | registerB);
 		out.putShort(opcodeByte);
 		out.putShort(registerA & 0xffff);
 		out.putShort(registerB & 0xffff);

src/org/ow2/asmdex/instruction/InstructionFormat35C.java

@@ -200,7 +200,9 @@ implements IRegisterArrayInstruction, IIndexInstruction {
 			try { throw new Exception("Abnormal arguments number : " + nbRegisters); }
     		catch (Exception e) { e.printStackTrace(); }
 		}
-		
+		int mask=0;
+		for(int i=0; i < nbRegisters; i++) mask |= registers[i];
+		test4BitsLimit(mask);
 		out.putShort(firstShort);
 		if (opcodeByte == 0x24) {
 			out.putShort(constantPool.getTypeIndex(type));

src/org/ow2/asmdex/instruction/InstructionFormat51L.java

@@ -141,6 +141,7 @@ implements IOneRegisterInstruction, ILongLiteralInstruction {
 
 	@Override
 	public void write(ByteVector out, ConstantPool constantPool) {
+	    test8BitsLimit(registerA);
 		out.putShort(((registerA & 0xff) << 8) + opcodeByte);
 		out.putByte((byte)literalB);
 		out.putByte((byte)(literalB >> 8));