/***

  * ASM: a very small and fast Java bytecode manipulation framework

  * Copyright (c) 2000-2005 INRIA, France Telecom

  * All rights reserved.

  *

  * Redistribution and use in source and binary forms, with or without

  * modification, are permitted provided that the following conditions

  * are met:

  * 1. Redistributions of source code must retain the above copyright

  *    notice, this list of conditions and the following disclaimer.

  * 2. Redistributions in binary form must reproduce the above copyright

  *    notice, this list of conditions and the following disclaimer in the

  *    documentation and/or other materials provided with the distribution.

  * 3. Neither the name of the copyright holders nor the names of its

  *    contributors may be used to endorse or promote products derived from

  *    this software without specific prior written permission.

  *

  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

  * THE POSSIBILITY OF SUCH DAMAGE.

  */

 package clojure.asm;

 

 /**

  * A {@link MethodVisitor} that generates methods in bytecode form. Each visit

  * method of this class appends the bytecode corresponding to the visited

  * instruction to a byte vector, in the order these methods are called.

  *

  * @author Eric Bruneton

  * @author Eugene Kuleshov

  */

 class MethodWriter implements MethodVisitor{

 

 /**

  * Pseudo access flag used to denote constructors.

  */

 final static int ACC_CONSTRUCTOR = 262144;

 

 /**

  * Frame has exactly the same locals as the previous stack map frame and

  * number of stack items is zero.

  */

 final static int SAME_FRAME = 0; // to 63 (0-3f)

 

 /**

  * Frame has exactly the same locals as the previous stack map frame and

  * number of stack items is 1

  */

 final static int SAME_LOCALS_1_STACK_ITEM_FRAME = 64; // to 127 (40-7f)

 

 /**

  * Reserved for future use

  */

 final static int RESERVED = 128;

 

 /**

  * Frame has exactly the same locals as the previous stack map frame and

  * number of stack items is 1. Offset is bigger then 63;

  */

 final static int SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED = 247; // f7

 

 /**

  * Frame where current locals are the same as the locals in the previous

  * frame, except that the k last locals are absent. The value of k is given

  * by the formula 251-frame_type.

  */

 final static int CHOP_FRAME = 248; // to 250 (f8-fA)

 

 /**

  * Frame has exactly the same locals as the previous stack map frame and

  * number of stack items is zero. Offset is bigger then 63;

  */

 final static int SAME_FRAME_EXTENDED = 251; // fb

 

 /**

  * Frame where current locals are the same as the locals in the previous

  * frame, except that k additional locals are defined. The value of k is

  * given by the formula frame_type-251.

  */

 final static int APPEND_FRAME = 252; // to 254 // fc-fe

 

 /**

  * Full frame

  */

 final static int FULL_FRAME = 255; // ff

 

 /**

  * Indicates that the stack map frames must be recomputed from scratch. In

  * this case the maximum stack size and number of local variables is also

  * recomputed from scratch.

  *

  * @see #compute

  */

 private final static int FRAMES = 0;

 

 /**

  * Indicates that the maximum stack size and number of local variables must

  * be automatically computed.

  *

  * @see #compute

  */

 private final static int MAXS = 1;

 

 /**

  * Indicates that nothing must be automatically computed.

  *

  * @see #compute

  */

 private final static int NOTHING = 2;

 

 /**

  * Next method writer (see {@link ClassWriter#firstMethod firstMethod}).

  */

 MethodWriter next;

 

 /**

  * The class writer to which this method must be added.

  */

 ClassWriter cw;

 

 /**

  * Access flags of this method.

  */

 private int access;

 

 /**

  * The index of the constant pool item that contains the name of this

  * method.

  */

 private int name;

 

 /**

  * The index of the constant pool item that contains the descriptor of this

  * method.

  */

 private int desc;

 

 /**

  * The descriptor of this method.

  */

 private String descriptor;

 

 /**

  * The signature of this method.

  */

 String signature;

 

 /**

  * If not zero, indicates that the code of this method must be copied from

  * the ClassReader associated to this writer in <code>cw.cr</code>. More

  * precisely, this field gives the index of the first byte to copied from

  * <code>cw.cr.b</code>.

  */

 int classReaderOffset;

 

 /**

  * If not zero, indicates that the code of this method must be copied from

  * the ClassReader associated to this writer in <code>cw.cr</code>. More

  * precisely, this field gives the number of bytes to copied from

  * <code>cw.cr.b</code>.

  */

 int classReaderLength;

 

 /**

  * Number of exceptions that can be thrown by this method.

  */

 int exceptionCount;

 

 /**

  * The exceptions that can be thrown by this method. More precisely, this

  * array contains the indexes of the constant pool items that contain the

  * internal names of these exception classes.

  */

 int[] exceptions;

 

 /**

  * The annotation default attribute of this method. May be <tt>null</tt>.

  */

 private ByteVector annd;

 

 /**

  * The runtime visible annotations of this method. May be <tt>null</tt>.

  */

 private AnnotationWriter anns;

 

 /**

  * The runtime invisible annotations of this method. May be <tt>null</tt>.

  */

 private AnnotationWriter ianns;

 

 /**

  * The runtime visible parameter annotations of this method. May be

  * <tt>null</tt>.

  */

 private AnnotationWriter[] panns;

 

 /**

  * The runtime invisible parameter annotations of this method. May be

  * <tt>null</tt>.

  */

 private AnnotationWriter[] ipanns;

 

 /**

  * The non standard attributes of the method.

  */

 private Attribute attrs;

 

 /**

  * The bytecode of this method.

  */

 private ByteVector code = new ByteVector();

 

 /**

  * Maximum stack size of this method.

  */

 private int maxStack;

 

 /**

  * Maximum number of local variables for this method.

  */

 private int maxLocals;

 

 /**

  * Number of stack map frames in the StackMapTable attribute.

  */

 private int frameCount;

 

 /**

  * The StackMapTable attribute.

  */

 private ByteVector stackMap;

 

 /**

  * The offset of the last frame that was written in the StackMapTable

  * attribute.

  */

 private int previousFrameOffset;

 

 /**

  * The last frame that was written in the StackMapTable attribute.

  *

  * @see #frame

  */

 private int[] previousFrame;

 

 /**

  * Index of the next element to be added in {@link #frame}.

  */

 private int frameIndex;

 

 /**

  * The current stack map frame. The first element contains the offset of the

  * instruction to which the frame corresponds, the second element is the

  * number of locals and the third one is the number of stack elements. The

  * local variables start at index 3 and are followed by the operand stack

  * values. In summary frame[0] = offset, frame[1] = nLocal, frame[2] =

  * nStack, frame[3] = nLocal. All types are encoded as integers, with the

  * same format as the one used in {@link Label}, but limited to BASE types.

  */

 private int[] frame;

 

 /**

  * Number of elements in the exception handler list.

  */

 private int handlerCount;

 

 /**

  * The first element in the exception handler list.

  */

 private Handler firstHandler;

 

 /**

  * The last element in the exception handler list.

  */

 private Handler lastHandler;

 

 /**

  * Number of entries in the LocalVariableTable attribute.

  */

 private int localVarCount;

 

 /**

  * The LocalVariableTable attribute.

  */

 private ByteVector localVar;

 

 /**

  * Number of entries in the LocalVariableTypeTable attribute.

  */

 private int localVarTypeCount;

 

 /**

  * The LocalVariableTypeTable attribute.

  */

 private ByteVector localVarType;

 

 /**

  * Number of entries in the LineNumberTable attribute.

  */

 private int lineNumberCount;

 

 /**

  * The LineNumberTable attribute.

  */

 private ByteVector lineNumber;

 

 /**

  * The non standard attributes of the method's code.

  */

 private Attribute cattrs;

 

 /**

  * Indicates if some jump instructions are too small and need to be resized.

  */

 private boolean resize;

 

 /**

  * Indicates if the instructions contain at least one JSR instruction.

  */

 private boolean jsr;

 

 // ------------------------------------------------------------------------

 

 /*

 	 * Fields for the control flow graph analysis algorithm (used to compute the

 	 * maximum stack size). A control flow graph contains one node per "basic

 	 * block", and one edge per "jump" from one basic block to another. Each

 	 * node (i.e., each basic block) is represented by the Label object that

 	 * corresponds to the first instruction of this basic block. Each node also

 	 * stores the list of its successors in the graph, as a linked list of Edge

 	 * objects.

 	 */

 

 /**

  * Indicates what must be automatically computed.

  *

  * @see FRAMES

  * @see MAXS

  * @see NOTHING

  */

 private int compute;

 

 /**

  * A list of labels. This list is the list of basic blocks in the method,

  * i.e. a list of Label objects linked to each other by their

  * {@link Label#successor} field, in the order they are visited by

  * {@link visitLabel}, and starting with the first basic block.

  */

 private Label labels;

 

 /**

  * The previous basic block.

  */

 private Label previousBlock;

 

 /**

  * The current basic block.

  */

 private Label currentBlock;

 

 /**

  * The (relative) stack size after the last visited instruction. This size

  * is relative to the beginning of the current basic block, i.e., the true

  * stack size after the last visited instruction is equal to the

  * {@link Label#inputStackTop beginStackSize} of the current basic block

  * plus <tt>stackSize</tt>.

  */

 private int stackSize;

 

 /**

  * The (relative) maximum stack size after the last visited instruction.

  * This size is relative to the beginning of the current basic block, i.e.,

  * the true maximum stack size after the last visited instruction is equal

  * to the {@link Label#inputStackTop beginStackSize} of the current basic

  * block plus <tt>stackSize</tt>.

  */

 private int maxStackSize;

 

 // ------------------------------------------------------------------------

 // Constructor

 // ------------------------------------------------------------------------

 

 /**

  * Constructs a new {@link MethodWriter}.

  *

  * @param cw            the class writer in which the method must be added.

  * @param access        the method's access flags (see {@link Opcodes}).

  * @param name          the method's name.

  * @param desc          the method's descriptor (see {@link Type}).

  * @param signature     the method's signature. May be <tt>null</tt>.

  * @param exceptions    the internal names of the method's exceptions. May be

  *                      <tt>null</tt>.

  * @param computeMaxs   <tt>true</tt> if the maximum stack size and number

  *                      of local variables must be automatically computed.

  * @param computeFrames <tt>true</tt> if the stack map tables must be

  *                      recomputed from scratch.

  */

 MethodWriter(

 		final ClassWriter cw,

 		final int access,

 		final String name,

 		final String desc,

 		final String signature,

 		final String[] exceptions,

 		final boolean computeMaxs,

 		final boolean computeFrames){

 	if(cw.firstMethod == null)

 		{

 		cw.firstMethod = this;

 		}

 	else

 		{

 		cw.lastMethod.next = this;

 		}

 	cw.lastMethod = this;

 	this.cw = cw;

 	this.access = access;

 	this.name = cw.newUTF8(name);

 	this.desc = cw.newUTF8(desc);

 	this.descriptor = desc;

 	this.signature = signature;

 	if(exceptions != null && exceptions.length > 0)

 		{

 		exceptionCount = exceptions.length;

 		this.exceptions = new int[exceptionCount];

 		for(int i = 0; i < exceptionCount; ++i)

 			{

 			this.exceptions[i] = cw.newClass(exceptions[i]);

 			}

 		}

 	this.compute = computeFrames ? FRAMES : (computeMaxs ? MAXS : NOTHING);

 	if(computeMaxs || computeFrames)

 		{

 		if(computeFrames && name.equals("<init>"))

 			{

 			this.access |= ACC_CONSTRUCTOR;

 			}

 		// updates maxLocals

 		int size = getArgumentsAndReturnSizes(descriptor) >> 2;

 		if((access & Opcodes.ACC_STATIC) != 0)

 			{

 			--size;

 			}

 		maxLocals = size;

 		// creates and visits the label for the first basic block

 		labels = new Label();

 		labels.status |= Label.PUSHED;

 		visitLabel(labels);

 		}

 }

 

 // ------------------------------------------------------------------------

 // Implementation of the MethodVisitor interface

 // ------------------------------------------------------------------------

 

 public AnnotationVisitor visitAnnotationDefault(){

 	annd = new ByteVector();

 	return new AnnotationWriter(cw, false, annd, null, 0);

 }

 

 public AnnotationVisitor visitAnnotation(

 		final String desc,

 		final boolean visible){

 	ByteVector bv = new ByteVector();

 	// write type, and reserve space for values count

 	bv.putShort(cw.newUTF8(desc)).putShort(0);

 	AnnotationWriter aw = new AnnotationWriter(cw, true, bv, bv, 2);

 	if(visible)

 		{

 		aw.next = anns;

 		anns = aw;

 		}

 	else

 		{

 		aw.next = ianns;

 		ianns = aw;

 		}

 	return aw;

 }

 

 public AnnotationVisitor visitParameterAnnotation(

 		final int parameter,

 		final String desc,

 		final boolean visible){

 	ByteVector bv = new ByteVector();

 	// write type, and reserve space for values count

 	bv.putShort(cw.newUTF8(desc)).putShort(0);

 	AnnotationWriter aw = new AnnotationWriter(cw, true, bv, bv, 2);

 	if(visible)

 		{

 		if(panns == null)

 			{

 			panns = new AnnotationWriter[Type.getArgumentTypes(descriptor).length];

 			}

 		aw.next = panns[parameter];

 		panns[parameter] = aw;

 		}

 	else

 		{

 		if(ipanns == null)

 			{

 			ipanns = new AnnotationWriter[Type.getArgumentTypes(descriptor).length];

 			}

 		aw.next = ipanns[parameter];

 		ipanns[parameter] = aw;

 		}

 	return aw;

 }

 

 public void visitAttribute(final Attribute attr){

 	if(attr.isCodeAttribute())

 		{

 		attr.next = cattrs;

 		cattrs = attr;

 		}

 	else

 		{

 		attr.next = attrs;

 		attrs = attr;

 		}

 }

 

 public void visitCode(){

 }

 

 public void visitFrame(

 		final int type,

 		final int nLocal,

 		final Object[] local,

 		final int nStack,

 		final Object[] stack){

 	if(compute == FRAMES)

 		{

 		return;

 		}

 

 	if(type == Opcodes.F_NEW)

 		{

 		startFrame(code.length, nLocal, nStack);

 		for(int i = 0; i < nLocal; ++i)

 			{

 			if(local[i] instanceof String)

 				{

 				frame[frameIndex++] = Frame.OBJECT

 				                      | cw.addType((String) local[i]);

 				}

 			else if(local[i] instanceof Integer)

 				{

 				frame[frameIndex++] = ((Integer) local[i]).intValue();

 				}

 			else

 				{

 				frame[frameIndex++] = Frame.UNINITIALIZED

 				                      | cw.addUninitializedType("",

 				                                                ((Label) local[i]).position);

 				}

 			}

 		for(int i = 0; i < nStack; ++i)

 			{

 			if(stack[i] instanceof String)

 				{

 				frame[frameIndex++] = Frame.OBJECT

 				                      | cw.addType((String) stack[i]);

 				}

 			else if(stack[i] instanceof Integer)

 				{

 				frame[frameIndex++] = ((Integer) stack[i]).intValue();

 				}

 			else

 				{

 				frame[frameIndex++] = Frame.UNINITIALIZED

 				                      | cw.addUninitializedType("",

 				                                                ((Label) stack[i]).position);

 				}

 			}

 		endFrame();

 		}

 	else

 		{

 		int delta;

 		if(stackMap == null)

 			{

 			stackMap = new ByteVector();

 			delta = code.length;

 			}

 		else

 			{

 			delta = code.length - previousFrameOffset - 1;

 			}

 

 		switch(type)

 			{

 			case Opcodes.F_FULL:

 				stackMap.putByte(FULL_FRAME)

 						.putShort(delta)

 						.putShort(nLocal);

 				for(int i = 0; i < nLocal; ++i)

 					{

 					writeFrameType(local[i]);

 					}

 				stackMap.putShort(nStack);

 				for(int i = 0; i < nStack; ++i)

 					{

 					writeFrameType(stack[i]);

 					}

 				break;

 			case Opcodes.F_APPEND:

 				stackMap.putByte(SAME_FRAME_EXTENDED + nLocal)

 						.putShort(delta);

 				for(int i = 0; i < nLocal; ++i)

 					{

 					writeFrameType(local[i]);

 					}

 				break;

 			case Opcodes.F_CHOP:

 				stackMap.putByte(SAME_FRAME_EXTENDED - nLocal)

 						.putShort(delta);

 				break;

 			case Opcodes.F_SAME:

 				if(delta < 64)

 					{

 					stackMap.putByte(delta);

 					}

 				else

 					{

 					stackMap.putByte(SAME_FRAME_EXTENDED).putShort(delta);

 					}

 				break;

 			case Opcodes.F_SAME1:

 				if(delta < 64)

 					{

 					stackMap.putByte(SAME_LOCALS_1_STACK_ITEM_FRAME + delta);

 					}

 				else

 					{

 					stackMap.putByte(SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED)

 							.putShort(delta);

 					}

 				writeFrameType(stack[0]);

 				break;

 			}

 

 		previousFrameOffset = code.length;

 		++frameCount;

 		}

 }

 

 public void visitInsn(final int opcode){

 	// adds the instruction to the bytecode of the method

 	code.putByte(opcode);

 	// update currentBlock

 	// Label currentBlock = this.currentBlock;

 	if(currentBlock != null)

 		{

 		if(compute == FRAMES)

 			{

 			currentBlock.frame.execute(opcode, 0, null, null);

 			}

 		else

 			{

 			// updates current and max stack sizes

 			int size = stackSize + Frame.SIZE[opcode];

 			if(size > maxStackSize)

 				{

 				maxStackSize = size;

 				}

 			stackSize = size;

 			}

 		// if opcode == ATHROW or xRETURN, ends current block (no successor)

 		if((opcode >= Opcodes.IRETURN && opcode <= Opcodes.RETURN)

 		   || opcode == Opcodes.ATHROW)

 			{

 			noSuccessor();

 			}

 		}

 }

 

 public void visitIntInsn(final int opcode, final int operand){

 	// Label currentBlock = this.currentBlock;

 	if(currentBlock != null)

 		{

 		if(compute == FRAMES)

 			{

 			currentBlock.frame.execute(opcode, operand, null, null);

 			}

 		else if(opcode != Opcodes.NEWARRAY)

 			{

 			// updates current and max stack sizes only for NEWARRAY

 			// (stack size variation = 0 for BIPUSH or SIPUSH)

 			int size = stackSize + 1;

 			if(size > maxStackSize)

 				{

 				maxStackSize = size;

 				}

 			stackSize = size;

 			}

 		}

 	// adds the instruction to the bytecode of the method

 	if(opcode == Opcodes.SIPUSH)

 		{

 		code.put12(opcode, operand);

 		}

 	else

 		{ // BIPUSH or NEWARRAY

 		code.put11(opcode, operand);

 		}

 }

 

 public void visitVarInsn(final int opcode, final int var){

 	// Label currentBlock = this.currentBlock;

 	if(currentBlock != null)

 		{

 		if(compute == FRAMES)

 			{

 			currentBlock.frame.execute(opcode, var, null, null);

 			}

 		else

 			{

 			// updates current and max stack sizes

 			if(opcode == Opcodes.RET)

 				{

 				// no stack change, but end of current block (no successor)

 				currentBlock.status |= Label.RET;

 				// save 'stackSize' here for future use

 				// (see {@link #findSubroutineSuccessors})

 				currentBlock.inputStackTop = stackSize;

 				noSuccessor();

 				}

 			else

 				{ // xLOAD or xSTORE

 				int size = stackSize + Frame.SIZE[opcode];

 				if(size > maxStackSize)

 					{

 					maxStackSize = size;

 					}

 				stackSize = size;

 				}

 			}

 		}

 	if(compute != NOTHING)

 		{

 		// updates max locals

 		int n;

 		if(opcode == Opcodes.LLOAD || opcode == Opcodes.DLOAD

 		   || opcode == Opcodes.LSTORE || opcode == Opcodes.DSTORE)

 			{

 			n = var + 2;

 			}

 		else

 			{

 			n = var + 1;

 			}

 		if(n > maxLocals)

 			{

 			maxLocals = n;

 			}

 		}

 	// adds the instruction to the bytecode of the method

 	if(var < 4 && opcode != Opcodes.RET)

 		{

 		int opt;

 		if(opcode < Opcodes.ISTORE)

 			{

 			/* ILOAD_0 */

 			opt = 26 + ((opcode - Opcodes.ILOAD) << 2) + var;

 			}

 		else

 			{

 			/* ISTORE_0 */

 			opt = 59 + ((opcode - Opcodes.ISTORE) << 2) + var;

 			}

 		code.putByte(opt);

 		}

 	else if(var >= 256)

 		{

 		code.putByte(196 /* WIDE */).put12(opcode, var);

 		}

 	else

 		{

 		code.put11(opcode, var);

 		}

 	if(opcode >= Opcodes.ISTORE && compute == FRAMES && handlerCount > 0)

 		{

 		visitLabel(new Label());

 		}

 }

 

 public void visitTypeInsn(final int opcode, final String desc){

 	Item i = cw.newClassItem(desc);

 	// Label currentBlock = this.currentBlock;

 	if(currentBlock != null)

 		{

 		if(compute == FRAMES)

 			{

 			currentBlock.frame.execute(opcode, code.length, cw, i);

 			}

 		else if(opcode == Opcodes.NEW)

 			{

 			// updates current and max stack sizes only if opcode == NEW

 			// (no stack change for ANEWARRAY, CHECKCAST, INSTANCEOF)

 			int size = stackSize + 1;

 			if(size > maxStackSize)

 				{

 				maxStackSize = size;

 				}

 			stackSize = size;

 			}

 		}

 	// adds the instruction to the bytecode of the method

 	code.put12(opcode, i.index);

 }

 

 public void visitFieldInsn(

 		final int opcode,

 		final String owner,

 		final String name,

 		final String desc){

 	Item i = cw.newFieldItem(owner, name, desc);

 	// Label currentBlock = this.currentBlock;

 	if(currentBlock != null)

 		{

 		if(compute == FRAMES)

 			{

 			currentBlock.frame.execute(opcode, 0, cw, i);

 			}

 		else

 			{

 			int size;

 			// computes the stack size variation

 			char c = desc.charAt(0);

 			switch(opcode)

 				{

 				case Opcodes.GETSTATIC:

 					size = stackSize + (c == 'D' || c == 'J' ? 2 : 1);

 					break;

 				case Opcodes.PUTSTATIC:

 					size = stackSize + (c == 'D' || c == 'J' ? -2 : -1);

 					break;

 				case Opcodes.GETFIELD:

 					size = stackSize + (c == 'D' || c == 'J' ? 1 : 0);

 					break;

 					// case Constants.PUTFIELD:

 				default:

 					size = stackSize + (c == 'D' || c == 'J' ? -3 : -2);

 					break;

 				}

 			// updates current and max stack sizes

 			if(size > maxStackSize)

 				{

 				maxStackSize = size;

 				}

 			stackSize = size;

 			}

 		}

 	// adds the instruction to the bytecode of the method

 	code.put12(opcode, i.index);

 }

 

 public void visitMethodInsn(

 		final int opcode,

 		final String owner,

 		final String name,

 		final String desc){

 	boolean itf = opcode == Opcodes.INVOKEINTERFACE;

 	Item i = cw.newMethodItem(owner, name, desc, itf);

 	int argSize = i.intVal;

 	// Label currentBlock = this.currentBlock;

 	if(currentBlock != null)

 		{

 		if(compute == FRAMES)

 			{

 			currentBlock.frame.execute(opcode, 0, cw, i);

 			}

 		else

 			{

 			/*

 							 * computes the stack size variation. In order not to recompute

 							 * several times this variation for the same Item, we use the

 							 * intVal field of this item to store this variation, once it

 							 * has been computed. More precisely this intVal field stores

 							 * the sizes of the arguments and of the return value

 							 * corresponding to desc.

 							 */

 			if(argSize == 0)

 				{

 				// the above sizes have not been computed yet,

 				// so we compute them...

 				argSize = getArgumentsAndReturnSizes(desc);

 				// ... and we save them in order

 				// not to recompute them in the future

 				i.intVal = argSize;

 				}

 			int size;

 			if(opcode == Opcodes.INVOKESTATIC)

 				{

 				size = stackSize - (argSize >> 2) + (argSize & 0x03) + 1;

 				}

 			else

 				{

 				size = stackSize - (argSize >> 2) + (argSize & 0x03);

 				}

 			// updates current and max stack sizes

 			if(size > maxStackSize)

 				{

 				maxStackSize = size;

 				}

 			stackSize = size;

 			}

 		}

 	// adds the instruction to the bytecode of the method

 	if(itf)

 		{

 		if(argSize == 0)

 			{

 			argSize = getArgumentsAndReturnSizes(desc);

 			i.intVal = argSize;

 			}

 		code.put12(Opcodes.INVOKEINTERFACE, i.index).put11(argSize >> 2, 0);

 		}

 	else

 		{

 		code.put12(opcode, i.index);

 		}

 }

 

 public void visitJumpInsn(final int opcode, final Label label){

 	Label nextInsn = null;

 	// Label currentBlock = this.currentBlock;

 	if(currentBlock != null)

 		{

 		if(compute == FRAMES)

 			{

 			currentBlock.frame.execute(opcode, 0, null, null);

 			// 'label' is the target of a jump instruction

 			label.getFirst().status |= Label.TARGET;

 			// adds 'label' as a successor of this basic block

 			addSuccessor(Edge.NORMAL, label);

 			if(opcode != Opcodes.GOTO)

 				{

 				// creates a Label for the next basic block

 				nextInsn = new Label();

 				}

 			}

 		else

 			{

 			if(opcode == Opcodes.JSR)

 				{

 				jsr = true;

 				currentBlock.status |= Label.JSR;

 				addSuccessor(stackSize + 1, label);

 				// creates a Label for the next basic block

 				nextInsn = new Label();

 				/*

 									 * note that, by construction in this method, a JSR block

 									 * has at least two successors in the control flow graph:

 									 * the first one leads the next instruction after the JSR,

 									 * while the second one leads to the JSR target.

 									 */

 				}

 			else

 				{

 				// updates current stack size (max stack size unchanged

 				// because stack size variation always negative in this

 				// case)

 				stackSize += Frame.SIZE[opcode];

 				addSuccessor(stackSize, label);

 				}

 			}

 		}

 	// adds the instruction to the bytecode of the method

 	if((label.status & Label.RESOLVED) != 0

 	   && label.position - code.length < Short.MIN_VALUE)

 		{

 		/*

 					 * case of a backward jump with an offset < -32768. In this case we

 					 * automatically replace GOTO with GOTO_W, JSR with JSR_W and IFxxx

 					 * <l> with IFNOTxxx <l'> GOTO_W <l>, where IFNOTxxx is the

 					 * "opposite" opcode of IFxxx (i.e., IFNE for IFEQ) and where <l'>

 					 * designates the instruction just after the GOTO_W.

 					 */

 		if(opcode == Opcodes.GOTO)

 			{

 			code.putByte(200); // GOTO_W

 			}

 		else if(opcode == Opcodes.JSR)

 			{

 			code.putByte(201); // JSR_W

 			}

 		else

 			{

 			// if the IF instruction is transformed into IFNOT GOTO_W the

 			// next instruction becomes the target of the IFNOT instruction

 			if(nextInsn != null)

 				{

 				nextInsn.status |= Label.TARGET;

 				}

 			code.putByte(opcode <= 166

 			             ? ((opcode + 1) ^ 1) - 1

 			             : opcode ^ 1);

 			code.putShort(8); // jump offset

 			code.putByte(200); // GOTO_W

 			}

 		label.put(this, code, code.length - 1, true);

 		}

 	else

 		{

 		/*

 					 * case of a backward jump with an offset >= -32768, or of a forward

 					 * jump with, of course, an unknown offset. In these cases we store

 					 * the offset in 2 bytes (which will be increased in

 					 * resizeInstructions, if needed).

 					 */

 		code.putByte(opcode);

 		label.put(this, code, code.length - 1, false);

 		}

 	if(currentBlock != null)

 		{

 		if(nextInsn != null)

 			{

 			// if the jump instruction is not a GOTO, the next instruction

 			// is also a successor of this instruction. Calling visitLabel

 			// adds the label of this next instruction as a successor of the

 			// current block, and starts a new basic block

 			visitLabel(nextInsn);

 			}

 		if(opcode == Opcodes.GOTO)

 			{

 			noSuccessor();

 			}

 		}

 }

 

 public void visitLabel(final Label label){

 	// resolves previous forward references to label, if any

 	resize |= label.resolve(this, code.length, code.data);

 	// updates currentBlock

 	if((label.status & Label.DEBUG) != 0)

 		{

 		return;

 		}

 	if(compute == FRAMES)

 		{

 		if(currentBlock != null)

 			{

 			if(label.position == currentBlock.position)

 				{

 				// successive labels, do not start a new basic block

 				currentBlock.status |= (label.status & Label.TARGET);

 				label.frame = currentBlock.frame;

 				return;

 				}

 			// ends current block (with one new successor)

 			addSuccessor(Edge.NORMAL, label);

 			}

 		// begins a new current block

 		currentBlock = label;

 		if(label.frame == null)

 			{

 			label.frame = new Frame();

 			label.frame.owner = label;

 			}

 		// updates the basic block list

 		if(previousBlock != null)

 			{

 			if(label.position == previousBlock.position)

 				{

 				previousBlock.status |= (label.status & Label.TARGET);

 				label.frame = previousBlock.frame;

 				currentBlock = previousBlock;

 				return;

 				}

 			previousBlock.successor = label;

 			}

 		previousBlock = label;

 		}

 	else if(compute == MAXS)

 		{

 		if(currentBlock != null)

 			{

 			// ends current block (with one new successor)

 			currentBlock.outputStackMax = maxStackSize;

 			addSuccessor(stackSize, label);

 			}

 		// begins a new current block

 		currentBlock = label;

 		// resets the relative current and max stack sizes

 		stackSize = 0;

 		maxStackSize = 0;

 		// updates the basic block list

 		if(previousBlock != null)

 			{

 			previousBlock.successor = label;

 			}

 		previousBlock = label;

 		}

 }

 

 public void visitLdcInsn(final Object cst){

 	Item i = cw.newConstItem(cst);

 	// Label currentBlock = this.currentBlock;

 	if(currentBlock != null)

 		{

 		if(compute == FRAMES)

 			{

 			currentBlock.frame.execute(Opcodes.LDC, 0, cw, i);

 			}

 		else

 			{

 			int size;

 			// computes the stack size variation

 			if(i.type == ClassWriter.LONG || i.type == ClassWriter.DOUBLE)

 				{

 				size = stackSize + 2;

 				}

 			else

 				{

 				size = stackSize + 1;

 				}

 			// updates current and max stack sizes

 			if(size > maxStackSize)

 				{

 				maxStackSize = size;

 				}

 			stackSize = size;

 			}

 		}

 	// adds the instruction to the bytecode of the method

 	int index = i.index;

 	if(i.type == ClassWriter.LONG || i.type == ClassWriter.DOUBLE)

 		{

 		code.put12(20 /* LDC2_W */, index);

 		}

 	else if(index >= 256)

 		{

 		code.put12(19 /* LDC_W */, index);

 		}

 	else

 		{

 		code.put11(Opcodes.LDC, index);

 		}

 }

 

 public void visitIincInsn(final int var, final int increment){

 	if(currentBlock != null)

 		{

 		if(compute == FRAMES)

 			{

 			currentBlock.frame.execute(Opcodes.IINC, var, null, null);

 			}

 		}

 	if(compute != NOTHING)

 		{

 		// updates max locals

 		int n = var + 1;

 		if(n > maxLocals)

 			{

 			maxLocals = n;

 			}

 		}

 	// adds the instruction to the bytecode of the method

 	if((var > 255) || (increment > 127) || (increment < -128))

 		{

 		code.putByte(196 /* WIDE */)

 				.put12(Opcodes.IINC, var)

 				.putShort(increment);

 		}

 	else

 		{

 		code.putByte(Opcodes.IINC).put11(var, increment);

 		}

 }

 

 public void visitTableSwitchInsn(

 		final int min,

 		final int max,

 		final Label dflt,

 		final Label labels[]){

 	// adds the instruction to the bytecode of the method

 	int source = code.length;

 	code.putByte(Opcodes.TABLESWITCH);

 	code.length += (4 - code.length % 4) % 4;

 	dflt.put(this, code, source, true);

 	code.putInt(min).putInt(max);

 	for(int i = 0; i < labels.length; ++i)

 		{

 		labels[i].put(this, code, source, true);

 		}

 	// updates currentBlock

 	visitSwitchInsn(dflt, labels);

 }

 

 public void visitLookupSwitchInsn(

 		final Label dflt,

 		final int keys[],

 		final Label labels[]){

 	// adds the instruction to the bytecode of the method

 	int source = code.length;

 	code.putByte(Opcodes.LOOKUPSWITCH);

 	code.length += (4 - code.length % 4) % 4;

 	dflt.put(this, code, source, true);

 	code.putInt(labels.length);

 	for(int i = 0; i < labels.length; ++i)

 		{

 		code.putInt(keys[i]);

 		labels[i].put(this, code, source, true);

 		}

 	// updates currentBlock

 	visitSwitchInsn(dflt, labels);

 }

 

 private void visitSwitchInsn(final Label dflt, final Label[] labels){

 	// Label currentBlock = this.currentBlock;

 	if(currentBlock != null)

 		{

 		if(compute == FRAMES)

 			{

 			currentBlock.frame.execute(Opcodes.LOOKUPSWITCH, 0, null, null);

 			// adds current block successors

 			addSuccessor(Edge.NORMAL, dflt);

 			dflt.getFirst().status |= Label.TARGET;

 			for(int i = 0; i < labels.length; ++i)

 				{

 				addSuccessor(Edge.NORMAL, labels[i]);

 				labels[i].getFirst().status |= Label.TARGET;

 				}

 			}

 		else

 			{

 			// updates current stack size (max stack size unchanged)

 			--stackSize;

 			// adds current block successors

 			addSuccessor(stackSize, dflt);

 			for(int i = 0; i < labels.length; ++i)

 				{

 				addSuccessor(stackSize, labels[i]);

 				}

 			}

 		// ends current block

 		noSuccessor();

 		}

 }

 

 public void visitMultiANewArrayInsn(final String desc, final int dims){

 	Item i = cw.newClassItem(desc);

 	// Label currentBlock = this.currentBlock;

 	if(currentBlock != null)

 		{

 		if(compute == FRAMES)

 			{

 			currentBlock.frame.execute(Opcodes.MULTIANEWARRAY, dims, cw, i);

 			}

 		else

 			{

 			// updates current stack size (max stack size unchanged because

 			// stack size variation always negative or null)

 			stackSize += 1 - dims;

 			}

 		}

 	// adds the instruction to the bytecode of the method

 	code.put12(Opcodes.MULTIANEWARRAY, i.index).putByte(dims);

 }

 

 public void visitTryCatchBlock(

 		final Label start,

 		final Label end,

 		final Label handler,

 		final String type){

 	++handlerCount;

 	Handler h = new Handler();

 	h.start = start;

 	h.end = end;

 	h.handler = handler;

 	h.desc = type;

 	h.type = type != null ? cw.newClass(type) : 0;

 	if(lastHandler == null)

 		{

 		firstHandler = h;

 		}

 	else

 		{

 		lastHandler.next = h;

 		}

 	lastHandler = h;

 }

 

 public void visitLocalVariable(

 		final String name,

 		final String desc,

 		final String signature,

 		final Label start,

 		final Label end,

 		final int index){

 	if(signature != null)

 		{

 		if(localVarType == null)

 			{

 			localVarType = new ByteVector();

 			}

 		++localVarTypeCount;

 		localVarType.putShort(start.position)

 				.putShort(end.position - start.position)

 				.putShort(cw.newUTF8(name))

 				.putShort(cw.newUTF8(signature))

 				.putShort(index);

 		}

 	if(localVar == null)

 		{

 		localVar = new ByteVector();

 		}

 	++localVarCount;

 	localVar.putShort(start.position)

 			.putShort(end.position - start.position)

 			.putShort(cw.newUTF8(name))

 			.putShort(cw.newUTF8(desc))

 			.putShort(index);

 	if(compute != NOTHING)

 		{

 		// updates max locals

 		char c = desc.charAt(0);

 		int n = index + (c == 'J' || c == 'D' ? 2 : 1);

 		if(n > maxLocals)

 			{

 			maxLocals = n;

 			}

 		}

 }

 

 public void visitLineNumber(final int line, final Label start){

 	if(lineNumber == null)

 		{

 		lineNumber = new ByteVector();

 		}

 	++lineNumberCount;

 	lineNumber.putShort(start.position);

 	lineNumber.putShort(line);

 }

 

 public void visitMaxs(final int maxStack, final int maxLocals){

 	if(compute == FRAMES)

 		{

 		// completes the control flow graph with exception handler blocks

 		Handler handler = firstHandler;

 		while(handler != null)

 			{

 			Label l = handler.start.getFirst();

 			Label h = handler.handler.getFirst();

 			Label e = handler.end.getFirst();

 			// computes the kind of the edges to 'h'

 			String t = handler.desc == null

 			           ? "java/lang/Throwable"

 			           : handler.desc;

 			int kind = Frame.OBJECT | cw.addType(t);

 			// h is an exception handler

 			h.status |= Label.TARGET;

 			// adds 'h' as a successor of labels between 'start' and 'end'

 			while(l != e)

 				{

 				// creates an edge to 'h'

 				Edge b = new Edge();

 				b.info = kind;

 				b.successor = h;

 				// adds it to the successors of 'l'

 				b.next = l.successors;

 				l.successors = b;

 				// goes to the next label

 				l = l.successor;

 				}

 			handler = handler.next;

 			}

 

 		// creates and visits the first (implicit) frame

 		Frame f = labels.frame;

 		Type[] args = Type.getArgumentTypes(descriptor);

 		f.initInputFrame(cw, access, args, this.maxLocals);

 		visitFrame(f);

 

 		/*

 					 * fix point algorithm: mark the first basic block as 'changed'

 					 * (i.e. put it in the 'changed' list) and, while there are changed

 					 * basic blocks, choose one, mark it as unchanged, and update its

 					 * successors (which can be changed in the process).

 					 */

 		int max = 0;

 		Label changed = labels;

 		while(changed != null)

 			{

 			// removes a basic block from the list of changed basic blocks

 			Label l = changed;

 			changed = changed.next;

 			l.next = null;

 			f = l.frame;

 			// a reacheable jump target must be stored in the stack map

 			if((l.status & Label.TARGET) != 0)

 				{

 				l.status |= Label.STORE;

 				}

 			// all visited labels are reacheable, by definition

 			l.status |= Label.REACHABLE;

 			// updates the (absolute) maximum stack size

 			int blockMax = f.inputStack.length + l.outputStackMax;

 			if(blockMax > max)

 				{

 				max = blockMax;

 				}

 			// updates the successors of the current basic block

 			Edge e = l.successors;

 			while(e != null)

 				{

 				Label n = e.successor.getFirst();

 				boolean change = f.merge(cw, n.frame, e.info);

 				if(change && n.next == null)

 					{

 					// if n has changed and is not already in the 'changed'

 					// list, adds it to this list

 					n.next = changed;

 					changed = n;

 					}

 				e = e.next;

 				}

 			}

 		this.maxStack = max;

 

 		// visits all the frames that must be stored in the stack map

 		Label l = labels;

 		while(l != null)

 			{

 			f = l.frame;

 			if((l.status & Label.STORE) != 0)

 				{

 				visitFrame(f);

 				}

 			if((l.status & Label.REACHABLE) == 0)

 				{

 				// finds start and end of dead basic block

 				Label k = l.successor;

 				int start = l.position;

 				int end = (k == null ? code.length : k.position) - 1;

 				// if non empty basic block

 				if(end >= start)

 					{

 					// replaces instructions with NOP ... NOP ATHROW

 					for(int i = start; i < end; ++i)

 						{

 						code.data[i] = Opcodes.NOP;

 						}

 					code.data[end] = (byte) Opcodes.ATHROW;

 					// emits a frame for this unreachable block

 					startFrame(start, 0, 1);

 					frame[frameIndex++] = Frame.OBJECT

 					                      | cw.addType("java/lang/Throwable");

 					endFrame();

 					}

 				}

 			l = l.successor;

 			}

 		}

 	else if(compute == MAXS)

 		{

 		// completes the control flow graph with exception handler blocks

 		Handler handler = firstHandler;

 		while(handler != null)

 			{

 			Label l = handler.start;

 			Label h = handler.handler;

 			Label e = handler.end;

 			// adds 'h' as a successor of labels between 'start' and 'end'

 			while(l != e)

 				{

 				// creates an edge to 'h'

 				Edge b = new Edge();

 				b.info = Edge.EXCEPTION;

 				b.successor = h;

 				// adds it to the successors of 'l'

 				if((l.status & Label.JSR) != 0)

 					{

 					// if l is a JSR block, adds b after the first two edges

 					// to preserve the hypothesis about JSR block successors

 					// order (see {@link #visitJumpInsn})

 					b.next = l.successors.next.next;

 					l.successors.next.next = b;

 					}

 				else

 					{

 					b.next = l.successors;

 					l.successors = b;

 					}

 				// goes to the next label

 				l = l.successor;

 				}

 			handler = handler.next;

 			}

 

 		if(jsr)

 			{

 			// completes the control flow graph with the RET successors

 			/*

 							 * first step: finds the subroutines. This step determines, for

 							 * each basic block, to which subroutine(s) it belongs, and

 							 * stores this set as a bit set in the {@link Label#status}

 							 * field. Subroutines are numbered with powers of two, from

 							 * 0x1000 to 0x80000000 (so there must be at most 20 subroutines

 							 * in a method).

 							 */

 			// finds the basic blocks that belong to the "main" subroutine

 			int id = 0x1000;

 			findSubroutine(labels, id);

 			// finds the basic blocks that belong to the real subroutines

 			Label l = labels;

 			while(l != null)

 				{

 				if((l.status & Label.JSR) != 0)

 					{

 					// the subroutine is defined by l's TARGET, not by l

 					Label subroutine = l.successors.next.successor;

 					// if this subroutine does not have an id yet...

 					if((subroutine.status & ~0xFFF) == 0)

 						{

 						// ...assigns it a new id and finds its basic blocks

 						id = id << 1;

 						findSubroutine(subroutine, id);

 						}

 					}

 				l = l.successor;

 				}

 			// second step: finds the successors of RET blocks

 			findSubroutineSuccessors(0x1000, new Label[10], 0);

 			}

 

 		/*

 					 * control flow analysis algorithm: while the block stack is not

 					 * empty, pop a block from this stack, update the max stack size,

 					 * compute the true (non relative) begin stack size of the

 					 * successors of this block, and push these successors onto the

 					 * stack (unless they have already been pushed onto the stack).

 					 * Note: by hypothesis, the {@link Label#inputStackTop} of the

 					 * blocks in the block stack are the true (non relative) beginning

 					 * stack sizes of these blocks.

 					 */

 		int max = 0;

 		Label stack = labels;

 		while(stack != null)

 			{

 			// pops a block from the stack

 			Label l = stack;

 			stack = stack.next;

 			// computes the true (non relative) max stack size of this block

 			int start = l.inputStackTop;

 			int blockMax = start + l.outputStackMax;

 			// updates the global max stack size

 			if(blockMax > max)

 				{

 				max = blockMax;

 				}

 			// analyses the successors of the block

 			Edge b = l.successors;

 			if((l.status & Label.JSR) != 0)

 				{

 				// ignores the first edge of JSR blocks (virtual successor)

 				b = b.next;

 				}

 			while(b != null)

 				{

 				l = b.successor;

 				// if this successor has not already been pushed...

 				if((l.status & Label.PUSHED) == 0)

 					{

 					// computes its true beginning stack size...

 					l.inputStackTop = b.info == Edge.EXCEPTION ? 1 : start

 					                                                 + b.info;

 					// ...and pushes it onto the stack

 					l.status |= Label.PUSHED;

 					l.next = stack;

 					stack = l;

 					}

 				b = b.next;

 				}

 			}

 		this.maxStack = max;

 		}

 	else

 		{

 		this.maxStack = maxStack;

 		this.maxLocals = maxLocals;

 		}

 }

 

 public void visitEnd(){

 }

 

 // ------------------------------------------------------------------------

 // Utility methods: control flow analysis algorithm

 // ------------------------------------------------------------------------

 

 /**

  * Computes the size of the arguments and of the return value of a method.

  *

  * @param desc the descriptor of a method.

  * @return the size of the arguments of the method (plus one for the

  *         implicit this argument), argSize, and the size of its return

  *         value, retSize, packed into a single int i =

  *         <tt>(argSize << 2) | retSize</tt> (argSize is therefore equal

  *         to <tt>i >> 2</tt>, and retSize to <tt>i & 0x03</tt>).

  */

 static int getArgumentsAndReturnSizes(final String desc){

 	int n = 1;

 	int c = 1;

 	while(true)

 		{

 		char car = desc.charAt(c++);

 		if(car == ')')

 			{

 			car = desc.charAt(c);

 			return n << 2

 			       | (car == 'V' ? 0 : (car == 'D' || car == 'J' ? 2 : 1));

 			}

 		else if(car == 'L')

 			{

 			while(desc.charAt(c++) != ';')

 				{

 				}

 			n += 1;

 			}

 		else if(car == '[')

 			{

 			while((car = desc.charAt(c)) == '[')

 				{

 				++c;

 				}

 			if(car == 'D' || car == 'J')

 				{

 				n -= 1;

 				}

 			}

 		else if(car == 'D' || car == 'J')

 			{

 			n += 2;

 			}

 		else

 			{

 			n += 1;

 			}

 		}

 }

 

 /**

  * Adds a successor to the {@link #currentBlock currentBlock} block.

  *

  * @param info      information about the control flow edge to be added.

  * @param successor the successor block to be added to the current block.

  */

 private void addSuccessor(final int info, final Label successor){

 	// creates and initializes an Edge object...

 	Edge b = new Edge();

 	b.info = info;

 	b.successor = successor;

 	// ...and adds it to the successor list of the currentBlock block

 	b.next = currentBlock.successors;

 	currentBlock.successors = b;

 }

 

 /**

  * Ends the current basic block. This method must be used in the case where

  * the current basic block does not have any successor.

  */

 private void noSuccessor(){

 	if(compute == FRAMES)

 		{

 		Label l = new Label();

 		l.frame = new Frame();

 		l.frame.owner = l;

 		l.resolve(this, code.length, code.data);

 		previousBlock.successor = l;

 		previousBlock = l;

 		}

 	else

 		{

 		currentBlock.outputStackMax = maxStackSize;

 		}

 	currentBlock = null;

 }

 

 /**

  * Finds the basic blocks that belong to a given subroutine, and marks these

  * blocks as belonging to this subroutine (by using {@link Label#status} as

  * a bit set (see {@link #visitMaxs}). This recursive method follows the

  * control flow graph to find all the blocks that are reachable from the

  * given block WITHOUT following any JSR target.

  *

  * @param block a block that belongs to the subroutine

  * @param id    the id of this subroutine

  */

 private void findSubroutine(final Label block, final int id){

 	// if 'block' is already marked as belonging to subroutine 'id', returns

 	if((block.status & id) != 0)

 		{

 		return;

 		}

 	// marks 'block' as belonging to subroutine 'id'

 	block.status |= id;

 	// calls this method recursively on each successor, except JSR targets

 	Edge e = block.successors;

 	while(e != null)

 		{

 		// if 'block' is a JSR block, then 'block.successors.next' leads

 		// to the JSR target (see {@link #visitJumpInsn}) and must therefore

 		// not be followed

 		if((block.status & Label.JSR) == 0 || e != block.successors.next)

 			{

 			findSubroutine(e.successor, id);

 			}

 		e = e.next;

 		}

 }

 

 /**

  * Finds the successors of the RET blocks of the specified subroutine, and

  * of any nested subroutine it calls.

  *

  * @param id    id of the subroutine whose RET block successors must be found.

  * @param JSRs  the JSR blocks that were followed to reach this subroutine.

  * @param nJSRs number of JSR blocks in the JSRs array.

  */

 private void findSubroutineSuccessors(

 		final int id,

 		final Label[] JSRs,

 		final int nJSRs){

 	// iterates over all the basic blocks...

 	Label l = labels;

 	while(l != null)

 		{

 		// for those that belong to subroutine 'id'...

 		if((l.status & id) != 0)

 			{

 			if((l.status & Label.JSR) != 0)

 				{

 				// finds the subroutine to which 'l' leads by following the

 				// second edge of l.successors (see {@link #visitJumpInsn})

 				int nId = l.successors.next.successor.status & ~0xFFF;

 				if(nId != id)

 					{

 					// calls this method recursively with l pushed onto the

 					// JSRs stack to find the successors of the RET blocks

 					// of this nested subroutine 'nId'

 					JSRs[nJSRs] = l;

 					findSubroutineSuccessors(nId, JSRs, nJSRs + 1);

 					}

 				}

 			else if((l.status & Label.RET) != 0)

 				{

 				/*

 									 * finds the JSR block in the JSRs stack that corresponds to

 									 * this RET block, and updates the successors of this RET

 									 * block accordingly. This corresponding JSR is the one that

 									 * leads to the subroutine to which the RET block belongs.

 									 * But the RET block can belong to several subroutines (if a

 									 * nested subroutine returns to its parent subroutine

 									 * implicitely, without a RET). So, in fact, the JSR that

 									 * corresponds to this RET is the first block in the JSRs

 									 * stack, starting from the bottom of the stack, that leads

 									 * to a subroutine to which the RET block belongs.

 									 */

 				for(int i = 0; i < nJSRs; ++i)

 					{

 					int JSRstatus = JSRs[i].successors.next.successor.status;

 					if(((JSRstatus & ~0xFFF) & (l.status & ~0xFFF)) != 0)

 						{

 						Edge e = new Edge();

 						e.info = l.inputStackTop;

 						e.successor = JSRs[i].successors.successor;

 						e.next = l.successors;

 						l.successors = e;

 						break;

 						}

 					}

 				}

 			}

 		l = l.successor;

 		}

 }

 

 // ------------------------------------------------------------------------

 // Utility methods: stack map frames

 // ------------------------------------------------------------------------

 

 /**

  * Visits a frame that has been computed from scratch.

  *

  * @param f the frame that must be visited.

  */

 private void visitFrame(final Frame f){

 	int i, t;

 	int nTop = 0;

 	int nLocal = 0;

 	int nStack = 0;

 	int[] locals = f.inputLocals;

 	int[] stacks = f.inputStack;

 	// computes the number of locals (ignores TOP types that are just after

 	// a LONG or a DOUBLE, and all trailing TOP types)

 	for(i = 0; i < locals.length; ++i)

 		{

 		t = locals[i];

 		if(t == Frame.TOP)

 			{

 			++nTop;

 			}

 		else

 			{

 			nLocal += nTop + 1;

 			nTop = 0;

 			}

 		if(t == Frame.LONG || t == Frame.DOUBLE)

 			{

 			++i;

 			}

 		}

 	// computes the stack size (ignores TOP types that are just after

 	// a LONG or a DOUBLE)

 	for(i = 0; i < stacks.length; ++i)

 		{

 		t = stacks[i];

 		++nStack;

 		if(t == Frame.LONG || t == Frame.DOUBLE)

 			{

 			++i;

 			}

 		}

 	// visits the frame and its content

 	startFrame(f.owner.position, nLocal, nStack);

 	for(i = 0; nLocal > 0; ++i, --nLocal)

 		{

 		t = locals[i];

 		frame[frameIndex++] = t;

 		if(t == Frame.LONG || t == Frame.DOUBLE)

 			{

 			++i;

 			}

 		}

 	for(i = 0; i < stacks.length; ++i)

 		{

 		t = stacks[i];

 		frame[frameIndex++] = t;

 		if(t == Frame.LONG || t == Frame.DOUBLE)

 			{

 			++i;

 			}

 		}

 	endFrame();

 }

 

 /**

  * Starts the visit of a stack map frame.

  *

  * @param offset the offset of the instruction to which the frame

  *               corresponds.

  * @param nLocal the number of local variables in the frame.

  * @param nStack the number of stack elements in the frame.

  */

 private void startFrame(final int offset, final int nLocal, final int nStack){

 	int n = 3 + nLocal + nStack;

 	if(frame == null || frame.length < n)

 		{

 		frame = new int[n];

 		}

 	frame[0] = offset;

 	frame[1] = nLocal;

 	frame[2] = nStack;

 	frameIndex = 3;

 }

 

 /**

  * Checks if the visit of the current frame {@link #frame} is finished, and

  * if yes, write it in the StackMapTable attribute.

  */

 private void endFrame(){

 	if(previousFrame != null)

 		{ // do not write the first frame

 		if(stackMap == null)

 			{

 			stackMap = new ByteVector();

 			}

 		writeFrame();

 		++frameCount;

 		}

 	previousFrame = frame;

 	frame = null;

 }

 

 /**

  * Compress and writes the current frame {@link #frame} in the StackMapTable

  * attribute.

  */

 private void writeFrame(){

 	int clocalsSize = frame[1];

 	int cstackSize = frame[2];

 	if((cw.version & 0xFFFF) < Opcodes.V1_6)

 		{

 		stackMap.putShort(frame[0]).putShort(clocalsSize);

 		writeFrameTypes(3, 3 + clocalsSize);

 		stackMap.putShort(cstackSize);

 		writeFrameTypes(3 + clocalsSize, 3 + clocalsSize + cstackSize);

 		return;

 		}

 	int localsSize = previousFrame[1];

 	int type = FULL_FRAME;

 	int k = 0;

 	int delta;

 	if(frameCount == 0)

 		{

 		delta = frame[0];

 		}

 	else

 		{

 		delta = frame[0] - previousFrame[0] - 1;

 		}

 	if(cstackSize == 0)

 		{

 		k = clocalsSize - localsSize;

 		switch(k)

 			{

 			case-3:

 			case-2:

 			case-1:

 				type = CHOP_FRAME;

 				localsSize = clocalsSize;

 				break;

 			case 0:

 				type = delta < 64 ? SAME_FRAME : SAME_FRAME_EXTENDED;

 				break;

 			case 1:

 			case 2:

 			case 3:

 				type = APPEND_FRAME;

 				break;

 			}

 		}

 	else if(clocalsSize == localsSize && cstackSize == 1)

 		{

 		type = delta < 63

 		       ? SAME_LOCALS_1_STACK_ITEM_FRAME

 		       : SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED;

 		}

 	if(type != FULL_FRAME)

 		{

 		// verify if locals are the same

 		int l = 3;

 		for(int j = 0; j < localsSize; j++)

 			{

 			if(frame[l] != previousFrame[l])

 				{

 				type = FULL_FRAME;

 				break;

 				}

 			l++;

 			}

 		}

 	switch(type)

 		{

 		case SAME_FRAME:

 			stackMap.putByte(delta);

 			break;

 		case SAME_LOCALS_1_STACK_ITEM_FRAME:

 			stackMap.putByte(SAME_LOCALS_1_STACK_ITEM_FRAME + delta);

 			writeFrameTypes(3 + clocalsSize, 4 + clocalsSize);

 			break;

 		case SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED:

 			stackMap.putByte(SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED)

 					.putShort(delta);

 			writeFrameTypes(3 + clocalsSize, 4 + clocalsSize);

 			break;

 		case SAME_FRAME_EXTENDED:

 			stackMap.putByte(SAME_FRAME_EXTENDED).putShort(delta);

 			break;

 		case CHOP_FRAME:

 			stackMap.putByte(SAME_FRAME_EXTENDED + k).putShort(delta);

 			break;

 		case APPEND_FRAME:

 			stackMap.putByte(SAME_FRAME_EXTENDED + k).putShort(delta);

 			writeFrameTypes(3 + localsSize, 3 + clocalsSize);

 			break;

 			// case FULL_FRAME:

 		default:

 			stackMap.putByte(FULL_FRAME)

 					.putShort(delta)

 					.putShort(clocalsSize);

 			writeFrameTypes(3, 3 + clocalsSize);

 			stackMap.putShort(cstackSize);

 			writeFrameTypes(3 + clocalsSize, 3 + clocalsSize + cstackSize);

 		}

 }

 

 /**

  * Writes some types of the current frame {@link #frame} into the

  * StackMapTableAttribute. This method converts types from the format used

  * in {@link Label} to the format used in StackMapTable attributes. In

  * particular, it converts type table indexes to constant pool indexes.

  *

  * @param start index of the first type in {@link #frame} to write.

  * @param end   index of last type in {@link #frame} to write (exclusive).

  */

 private void writeFrameTypes(final int start, final int end){

 	for(int i = start; i < end; ++i)

 		{

 		int t = frame[i];

 		int d = t & Frame.DIM;

 		if(d == 0)

 			{

 			int v = t & Frame.BASE_VALUE;

 			switch(t & Frame.BASE_KIND)

 				{

 				case Frame.OBJECT:

 					stackMap.putByte(7)

 							.putShort(cw.newClass(cw.typeTable[v].strVal1));

 					break;

 				case Frame.UNINITIALIZED:

 					stackMap.putByte(8).putShort(cw.typeTable[v].intVal);

 					break;

 				default:

 					stackMap.putByte(v);

 				}

 			}

 		else

 			{

 			StringBuffer buf = new StringBuffer();

 			d >>= 28;

 			while(d-- > 0)

 				{

 				buf.append('[');

 				}

 			if((t & Frame.BASE_KIND) == Frame.OBJECT)

 				{

 				buf.append('L');

 				buf.append(cw.typeTable[t & Frame.BASE_VALUE].strVal1);

 				buf.append(';');

 				}

 			else

 				{

 				switch(t & 0xF)

 					{

 					case 1:

 						buf.append('I');

 						break;

 					case 2:

 						buf.append('F');

 						break;

 					case 3:

 						buf.append('D');

 						break;

 					case 9:

 						buf.append('Z');

 						break;

 					case 10:

 						buf.append('B');

 						break;

 					case 11:

 						buf.append('C');

 						break;

 					case 12:

 						buf.append('S');

 						break;

 					default:

 						buf.append('J');

 					}

 				}

 			stackMap.putByte(7).putShort(cw.newClass(buf.toString()));

 			}

 		}

 }

 

 private void writeFrameType(final Object type){

 	if(type instanceof String)

 		{

 		stackMap.putByte(7).putShort(cw.newClass((String) type));

 		}

 	else if(type instanceof Integer)

 		{

 		stackMap.putByte(((Integer) type).intValue());

 		}

 	else

 		{

 		stackMap.putByte(8).putShort(((Label) type).position);

 		}

 }

 

 // ------------------------------------------------------------------------

 // Utility methods: dump bytecode array

 // ------------------------------------------------------------------------

 

 /**

  * Returns the size of the bytecode of this method.

  *

  * @return the size of the bytecode of this method.

  */

 final int getSize(){

 	if(classReaderOffset != 0)

 		{

 		return 6 + classReaderLength;

 		}

 	if(resize)

 		{

 		// replaces the temporary jump opcodes introduced by Label.resolve.

 		resizeInstructions();

 		}

 	int size = 8;

 	if(code.length > 0)

 		{

 		cw.newUTF8("Code");

 		size += 18 + code.length + 8 * handlerCount;

 		if(localVar != null)

 			{

 			cw.newUTF8("LocalVariableTable");

 			size += 8 + localVar.length;

 			}

 		if(localVarType != null)

 			{

 			cw.newUTF8("LocalVariableTypeTable");

 			size += 8 + localVarType.length;

 			}

 		if(lineNumber != null)

 			{

 			cw.newUTF8("LineNumberTable");

 			size += 8 + lineNumber.length;

 			}

 		if(stackMap != null)

 			{

 			boolean zip = (cw.version & 0xFFFF) >= Opcodes.V1_6;

 			cw.newUTF8(zip ? "StackMapTable" : "StackMap");

 			size += 8 + stackMap.length;

 			}

 		if(cattrs != null)

 			{

 			size += cattrs.getSize(cw,

 			                       code.data,

 			                       code.length,

 			                       maxStack,

 			                       maxLocals);

 			}

 		}

 	if(exceptionCount > 0)

 		{

 		cw.newUTF8("Exceptions");

 		size += 8 + 2 * exceptionCount;

 		}

 	if((access & Opcodes.ACC_SYNTHETIC) != 0

 	   && (cw.version & 0xffff) < Opcodes.V1_5)

 		{

 		cw.newUTF8("Synthetic");

 		size += 6;

 		}

 	if((access & Opcodes.ACC_DEPRECATED) != 0)

 		{

 		cw.newUTF8("Deprecated");

 		size += 6;

 		}

 	if(signature != null)

 		{

 		cw.newUTF8("Signature");

 		cw.newUTF8(signature);

 		size += 8;

 		}

 	if(annd != null)

 		{

 		cw.newUTF8("AnnotationDefault");

 		size += 6 + annd.length;

 		}

 	if(anns != null)

 		{

 		cw.newUTF8("RuntimeVisibleAnnotations");

 		size += 8 + anns.getSize();

 		}

 	if(ianns != null)

 		{

 		cw.newUTF8("RuntimeInvisibleAnnotations");

 		size += 8 + ianns.getSize();

 		}

 	if(panns != null)

 		{

 		cw.newUTF8("RuntimeVisibleParameterAnnotations");

 		size += 7 + 2 * panns.length;

 		for(int i = panns.length - 1; i >= 0; --i)

 			{

 			size += panns[i] == null ? 0 : panns[i].getSize();

 			}

 		}

 	if(ipanns != null)

 		{

 		cw.newUTF8("RuntimeInvisibleParameterAnnotations");

 		size += 7 + 2 * ipanns.length;

 		for(int i = ipanns.length - 1; i >= 0; --i)

 			{

 			size += ipanns[i] == null ? 0 : ipanns[i].getSize();

 			}

 		}

 	if(attrs != null)

 		{

 		size += attrs.getSize(cw, null, 0, -1, -1);

 		}

 	return size;

 }

 

 /**

  * Puts the bytecode of this method in the given byte vector.

  *

  * @param out the byte vector into which the bytecode of this method must be

  *            copied.

  */

 final void put(final ByteVector out){

 	out.putShort(access).putShort(name).putShort(desc);

 	if(classReaderOffset != 0)

 		{

 		out.putByteArray(cw.cr.b, classReaderOffset, classReaderLength);

 		return;

 		}

 	int attributeCount = 0;

 	if(code.length > 0)

 		{

 		++attributeCount;

 		}

 	if(exceptionCount > 0)

 		{

 		++attributeCount;

 		}

 	if((access & Opcodes.ACC_SYNTHETIC) != 0

 	   && (cw.version & 0xffff) < Opcodes.V1_5)

 		{

 		++attributeCount;

 		}

 	if((access & Opcodes.ACC_DEPRECATED) != 0)

 		{

 		++attributeCount;

 		}

 	if(signature != null)

 		{

 		++attributeCount;

 		}

 	if(annd != null)

 		{

 		++attributeCount;

 		}

 	if(anns != null)

 		{

 		++attributeCount;

 		}

 	if(ianns != null)

 		{

 		++attributeCount;

 		}

 	if(panns != null)

 		{

 		++attributeCount;

 		}

 	if(ipanns != null)

 		{

 		++attributeCount;

 		}

 	if(attrs != null)

 		{

 		attributeCount += attrs.getCount();

 		}

 	out.putShort(attributeCount);

 	if(code.length > 0)

 		{

 		int size = 12 + code.length + 8 * handlerCount;

 		if(localVar != null)

 			{

 			size += 8 + localVar.length;

 			}

 		if(localVarType != null)

 			{

 			size += 8 + localVarType.length;

 			}

 		if(lineNumber != null)

 			{

 			size += 8 + lineNumber.length;

 			}

 		if(stackMap != null)

 			{

 			size += 8 + stackMap.length;

 			}

 		if(cattrs != null)

 			{

 			size += cattrs.getSize(cw,

 			                       code.data,

 			                       code.length,

 			                       maxStack,

 			                       maxLocals);

 			}

 		out.putShort(cw.newUTF8("Code")).putInt(size);

 		out.putShort(maxStack).putShort(maxLocals);

 		out.putInt(code.length).putByteArray(code.data, 0, code.length);

 		out.putShort(handlerCount);

 		if(handlerCount > 0)

 			{

 			Handler h = firstHandler;

 			while(h != null)

 				{

 				out.putShort(h.start.position)

 						.putShort(h.end.position)

 						.putShort(h.handler.position)

 						.putShort(h.type);

 				h = h.next;

 				}

 			}

 		attributeCount = 0;

 		if(localVar != null)

 			{

 			++attributeCount;

 			}

 		if(localVarType != null)

 			{

 			++attributeCount;

 			}

 		if(lineNumber != null)

 			{

 			++attributeCount;

 			}

 		if(stackMap != null)

 			{

 			++attributeCount;

 			}

 		if(cattrs != null)

 			{

 			attributeCount += cattrs.getCount();

 			}

 		out.putShort(attributeCount);

 		if(localVar != null)

 			{

 			out.putShort(cw.newUTF8("LocalVariableTable"));

 			out.putInt(localVar.length + 2).putShort(localVarCount);

 			out.putByteArray(localVar.data, 0, localVar.length);

 			}

 		if(localVarType != null)

 			{

 			out.putShort(cw.newUTF8("LocalVariableTypeTable"));

 			out.putInt(localVarType.length + 2).putShort(localVarTypeCount);

 			out.putByteArray(localVarType.data, 0, localVarType.length);

 			}

 		if(lineNumber != null)

 			{

 			out.putShort(cw.newUTF8("LineNumberTable"));

 			out.putInt(lineNumber.length + 2).putShort(lineNumberCount);

 			out.putByteArray(lineNumber.data, 0, lineNumber.length);

 			}

 		if(stackMap != null)

 			{

 			boolean zip = (cw.version & 0xFFFF) >= Opcodes.V1_6;

 			out.putShort(cw.newUTF8(zip ? "StackMapTable" : "StackMap"));

 			out.putInt(stackMap.length + 2).putShort(frameCount);

 			out.putByteArray(stackMap.data, 0, stackMap.length);

 			}

 		if(cattrs != null)

 			{

 			cattrs.put(cw, code.data, code.length, maxLocals, maxStack, out);

 			}

 		}

 	if(exceptionCount > 0)

 		{

 		out.putShort(cw.newUTF8("Exceptions"))

 				.putInt(2 * exceptionCount + 2);

 		out.putShort(exceptionCount);

 		for(int i = 0; i < exceptionCount; ++i)

 			{

 			out.putShort(exceptions[i]);

 			}

 		}

 	if((access & Opcodes.ACC_SYNTHETIC) != 0

 	   && (cw.version & 0xffff) < Opcodes.V1_5)

 		{

 		out.putShort(cw.newUTF8("Synthetic")).putInt(0);

 		}

 	if((access & Opcodes.ACC_DEPRECATED) != 0)

 		{

 		out.putShort(cw.newUTF8("Deprecated")).putInt(0);

 		}

 	if(signature != null)

 		{

 		out.putShort(cw.newUTF8("Signature"))

 				.putInt(2)

 				.putShort(cw.newUTF8(signature));

 		}

 	if(annd != null)

 		{

 		out.putShort(cw.newUTF8("AnnotationDefault"));

 		out.putInt(annd.length);

 		out.putByteArray(annd.data, 0, annd.length);

 		}

 	if(anns != null)

 		{

 		out.putShort(cw.newUTF8("RuntimeVisibleAnnotations"));

 		anns.put(out);

 		}

 	if(ianns != null)

 		{

 		out.putShort(cw.newUTF8("RuntimeInvisibleAnnotations"));

 		ianns.put(out);

 		}

 	if(panns != null)

 		{

 		out.putShort(cw.newUTF8("RuntimeVisibleParameterAnnotations"));

 		AnnotationWriter.put(panns, out);

 		}

 	if(ipanns != null)

 		{

 		out.putShort(cw.newUTF8("RuntimeInvisibleParameterAnnotations"));

 		AnnotationWriter.put(ipanns, out);

 		}

 	if(attrs != null)

 		{

 		attrs.put(cw, null, 0, -1, -1, out);

 		}

 }

 

 // ------------------------------------------------------------------------

 // Utility methods: instruction resizing (used to handle GOTO_W and JSR_W)

 // ------------------------------------------------------------------------

 

 /**

  * Resizes and replaces the temporary instructions inserted by

  * {@link Label#resolve} for wide forward jumps, while keeping jump offsets

  * and instruction addresses consistent. This may require to resize other

  * existing instructions, or even to introduce new instructions: for

  * example, increasing the size of an instruction by 2 at the middle of a

  * method can increases the offset of an IFEQ instruction from 32766 to

  * 32768, in which case IFEQ 32766 must be replaced with IFNEQ 8 GOTO_W

  * 32765. This, in turn, may require to increase the size of another jump

  * instruction, and so on... All these operations are handled automatically

  * by this method. <p> <i>This method must be called after all the method

  * that is being built has been visited</i>. In particular, the

  * {@link Label Label} objects used to construct the method are no longer

  * valid after this method has been called.

  */

 private void resizeInstructions(){

 	byte[] b = code.data; // bytecode of the method

 	int u, v, label; // indexes in b

 	int i, j; // loop indexes

 	/*

 			 * 1st step: As explained above, resizing an instruction may require to

 			 * resize another one, which may require to resize yet another one, and

 			 * so on. The first step of the algorithm consists in finding all the

 			 * instructions that need to be resized, without modifying the code.

 			 * This is done by the following "fix point" algorithm:

 			 *

 			 * Parse the code to find the jump instructions whose offset will need

 			 * more than 2 bytes to be stored (the future offset is computed from

 			 * the current offset and from the number of bytes that will be inserted

 			 * or removed between the source and target instructions). For each such

 			 * instruction, adds an entry in (a copy of) the indexes and sizes

 			 * arrays (if this has not already been done in a previous iteration!).

 			 *

 			 * If at least one entry has been added during the previous step, go

 			 * back to the beginning, otherwise stop.

 			 *

 			 * In fact the real algorithm is complicated by the fact that the size

 			 * of TABLESWITCH and LOOKUPSWITCH instructions depends on their

 			 * position in the bytecode (because of padding). In order to ensure the

 			 * convergence of the algorithm, the number of bytes to be added or

 			 * removed from these instructions is over estimated during the previous

 			 * loop, and computed exactly only after the loop is finished (this

 			 * requires another pass to parse the bytecode of the method).

 			 */

 	int[] allIndexes = new int[0]; // copy of indexes

 	int[] allSizes = new int[0]; // copy of sizes

 	boolean[] resize; // instructions to be resized

 	int newOffset; // future offset of a jump instruction

 

 	resize = new boolean[code.length];

 

 	// 3 = loop again, 2 = loop ended, 1 = last pass, 0 = done

 	int state = 3;

 	do

 		{

 		if(state == 3)

 			{

 			state = 2;

 			}

 		u = 0;

 		while(u < b.length)

 			{

 			int opcode = b[u] & 0xFF; // opcode of current instruction

 			int insert = 0; // bytes to be added after this instruction

 

 			switch(ClassWriter.TYPE[opcode])

 				{

 				case ClassWriter.NOARG_INSN:

 				case ClassWriter.IMPLVAR_INSN:

 					u += 1;

 					break;

 				case ClassWriter.LABEL_INSN:

 					if(opcode > 201)

 						{

 						// converts temporary opcodes 202 to 217, 218 and

 						// 219 to IFEQ ... JSR (inclusive), IFNULL and

 						// IFNONNULL

 						opcode = opcode < 218 ? opcode - 49 : opcode - 20;

 						label = u + readUnsignedShort(b, u + 1);

 						}

 					else

 						{

 						label = u + readShort(b, u + 1);

 						}

 					newOffset = getNewOffset(allIndexes, allSizes, u, label);

 					if(newOffset < Short.MIN_VALUE

 					   || newOffset > Short.MAX_VALUE)

 						{

 						if(!resize[u])

 							{

 							if(opcode == Opcodes.GOTO

 							   || opcode == Opcodes.JSR)

 								{

 								// two additional bytes will be required to

 								// replace this GOTO or JSR instruction with

 								// a GOTO_W or a JSR_W

 								insert = 2;

 								}

 							else

 								{

 								// five additional bytes will be required to

 								// replace this IFxxx <l> instruction with

 								// IFNOTxxx <l'> GOTO_W <l>, where IFNOTxxx

 								// is the "opposite" opcode of IFxxx (i.e.,

 								// IFNE for IFEQ) and where <l'> designates

 								// the instruction just after the GOTO_W.

 								insert = 5;

 								}

 							resize[u] = true;

 							}

 						}

 					u += 3;

 					break;

 				case ClassWriter.LABELW_INSN:

 					u += 5;

 					break;

 				case ClassWriter.TABL_INSN:

 					if(state == 1)

 						{

 						// true number of bytes to be added (or removed)

 						// from this instruction = (future number of padding

 						// bytes - current number of padding byte) -

 						// previously over estimated variation =

 						// = ((3 - newOffset%4) - (3 - u%4)) - u%4

 						// = (-newOffset%4 + u%4) - u%4

 						// = -(newOffset & 3)

 						newOffset = getNewOffset(allIndexes, allSizes, 0, u);

 						insert = -(newOffset & 3);

 						}

 					else if(!resize[u])

 						{

 						// over estimation of the number of bytes to be

 						// added to this instruction = 3 - current number

 						// of padding bytes = 3 - (3 - u%4) = u%4 = u & 3

 						insert = u & 3;

 						resize[u] = true;

 						}

 					// skips instruction

 					u = u + 4 - (u & 3);

 					u += 4 * (readInt(b, u + 8) - readInt(b, u + 4) + 1) + 12;

 					break;

 				case ClassWriter.LOOK_INSN:

 					if(state == 1)

 						{

 						// like TABL_INSN

 						newOffset = getNewOffset(allIndexes, allSizes, 0, u);

 						insert = -(newOffset & 3);

 						}

 					else if(!resize[u])

 						{

 						// like TABL_INSN

 						insert = u & 3;

 						resize[u] = true;

 						}

 					// skips instruction

 					u = u + 4 - (u & 3);

 					u += 8 * readInt(b, u + 4) + 8;

 					break;

 				case ClassWriter.WIDE_INSN:

 					opcode = b[u + 1] & 0xFF;

 					if(opcode == Opcodes.IINC)

 						{

 						u += 6;

 						}

 					else

 						{

 						u += 4;

 						}

 					break;

 				case ClassWriter.VAR_INSN:

 				case ClassWriter.SBYTE_INSN:

 				case ClassWriter.LDC_INSN:

 					u += 2;

 					break;

 				case ClassWriter.SHORT_INSN:

 				case ClassWriter.LDCW_INSN:

 				case ClassWriter.FIELDORMETH_INSN:

 				case ClassWriter.TYPE_INSN:

 				case ClassWriter.IINC_INSN:

 					u += 3;

 					break;

 				case ClassWriter.ITFMETH_INSN:

 					u += 5;

 					break;

 					// case ClassWriter.MANA_INSN:

 				default:

 					u += 4;

 					break;

 				}

 			if(insert != 0)

 				{

 				// adds a new (u, insert) entry in the allIndexes and

 				// allSizes arrays

 				int[] newIndexes = new int[allIndexes.length + 1];

 				int[] newSizes = new int[allSizes.length + 1];

 				System.arraycopy(allIndexes,

 				                 0,

 				                 newIndexes,

 				                 0,

 				                 allIndexes.length);

 				System.arraycopy(allSizes, 0, newSizes, 0, allSizes.length);

 				newIndexes[allIndexes.length] = u;

 				newSizes[allSizes.length] = insert;

 				allIndexes = newIndexes;

 				allSizes = newSizes;

 				if(insert > 0)

 					{

 					state = 3;

 					}

 				}

 			}

 		if(state < 3)

 			{

 			--state;

 			}

 		} while(state != 0);

 

 	// 2nd step:

 	// copies the bytecode of the method into a new bytevector, updates the

 	// offsets, and inserts (or removes) bytes as requested.

 

 	ByteVector newCode = new ByteVector(code.length);

 

 	u = 0;

 	while(u < code.length)

 		{

 		int opcode = b[u] & 0xFF;

 		switch(ClassWriter.TYPE[opcode])

 			{

 			case ClassWriter.NOARG_INSN:

 			case ClassWriter.IMPLVAR_INSN:

 				newCode.putByte(opcode);

 				u += 1;

 				break;

 			case ClassWriter.LABEL_INSN:

 				if(opcode > 201)

 					{

 					// changes temporary opcodes 202 to 217 (inclusive), 218

 					// and 219 to IFEQ ... JSR (inclusive), IFNULL and

 					// IFNONNULL

 					opcode = opcode < 218 ? opcode - 49 : opcode - 20;

 					label = u + readUnsignedShort(b, u + 1);

 					}

 				else

 					{

 					label = u + readShort(b, u + 1);

 					}

 				newOffset = getNewOffset(allIndexes, allSizes, u, label);

 				if(resize[u])

 					{

 					// replaces GOTO with GOTO_W, JSR with JSR_W and IFxxx

 					// <l> with IFNOTxxx <l'> GOTO_W <l>, where IFNOTxxx is

 					// the "opposite" opcode of IFxxx (i.e., IFNE for IFEQ)

 					// and where <l'> designates the instruction just after

 					// the GOTO_W.

 					if(opcode == Opcodes.GOTO)

 						{

 						newCode.putByte(200); // GOTO_W

 						}

 					else if(opcode == Opcodes.JSR)

 						{

 						newCode.putByte(201); // JSR_W

 						}

 					else

 						{

 						newCode.putByte(opcode <= 166

 						                ? ((opcode + 1) ^ 1) - 1

 						                : opcode ^ 1);

 						newCode.putShort(8); // jump offset

 						newCode.putByte(200); // GOTO_W

 						// newOffset now computed from start of GOTO_W

 						newOffset -= 3;

 						}

 					newCode.putInt(newOffset);

 					}

 				else

 					{

 					newCode.putByte(opcode);

 					newCode.putShort(newOffset);

 					}

 				u += 3;

 				break;

 			case ClassWriter.LABELW_INSN:

 				label = u + readInt(b, u + 1);

 				newOffset = getNewOffset(allIndexes, allSizes, u, label);

 				newCode.putByte(opcode);

 				newCode.putInt(newOffset);

 				u += 5;

 				break;

 			case ClassWriter.TABL_INSN:

 				// skips 0 to 3 padding bytes

 				v = u;

 				u = u + 4 - (v & 3);

 				// reads and copies instruction

 				newCode.putByte(Opcodes.TABLESWITCH);

 				newCode.length += (4 - newCode.length % 4) % 4;

 				label = v + readInt(b, u);

 				u += 4;

 				newOffset = getNewOffset(allIndexes, allSizes, v, label);

 				newCode.putInt(newOffset);

 				j = readInt(b, u);

 				u += 4;

 				newCode.putInt(j);

 				j = readInt(b, u) - j + 1;

 				u += 4;

 				newCode.putInt(readInt(b, u - 4));

 				for(; j > 0; --j)

 					{

 					label = v + readInt(b, u);

 					u += 4;

 					newOffset = getNewOffset(allIndexes, allSizes, v, label);

 					newCode.putInt(newOffset);

 					}

 				break;

 			case ClassWriter.LOOK_INSN:

 				// skips 0 to 3 padding bytes

 				v = u;

 				u = u + 4 - (v & 3);

 				// reads and copies instruction

 				newCode.putByte(Opcodes.LOOKUPSWITCH);

 				newCode.length += (4 - newCode.length % 4) % 4;

 				label = v + readInt(b, u);

 				u += 4;

 				newOffset = getNewOffset(allIndexes, allSizes, v, label);

 				newCode.putInt(newOffset);

 				j = readInt(b, u);

 				u += 4;

 				newCode.putInt(j);

 				for(; j > 0; --j)

 					{

 					newCode.putInt(readInt(b, u));

 					u += 4;

 					label = v + readInt(b, u);

 					u += 4;

 					newOffset = getNewOffset(allIndexes, allSizes, v, label);

 					newCode.putInt(newOffset);

 					}

 				break;

 			case ClassWriter.WIDE_INSN:

 				opcode = b[u + 1] & 0xFF;

 				if(opcode == Opcodes.IINC)

 					{

 					newCode.putByteArray(b, u, 6);

 					u += 6;

 					}

 				else

 					{

 					newCode.putByteArray(b, u, 4);

 					u += 4;

 					}

 				break;

 			case ClassWriter.VAR_INSN:

 			case ClassWriter.SBYTE_INSN:

 			case ClassWriter.LDC_INSN:

 				newCode.putByteArray(b, u, 2);

 				u += 2;

 				break;

 			case ClassWriter.SHORT_INSN:

 			case ClassWriter.LDCW_INSN:

 			case ClassWriter.FIELDORMETH_INSN:

 			case ClassWriter.TYPE_INSN:

 			case ClassWriter.IINC_INSN:

 				newCode.putByteArray(b, u, 3);

 				u += 3;

 				break;

 			case ClassWriter.ITFMETH_INSN:

 				newCode.putByteArray(b, u, 5);

 				u += 5;

 				break;

 				// case MANA_INSN:

 			default:

 				newCode.putByteArray(b, u, 4);

 				u += 4;

 				break;

 			}

 		}

 

 	// recomputes the stack map frames

 	if(frameCount > 0)

 		{

 		if(compute == FRAMES)

 			{

 			frameCount = 0;

 			stackMap = null;

 			previousFrame = null;

 			frame = null;

 			Frame f = new Frame();

 			f.owner = labels;

 			Type[] args = Type.getArgumentTypes(descriptor);

 			f.initInputFrame(cw, access, args, maxLocals);

 			visitFrame(f);

 			Label l = labels;

 			while(l != null)

 				{

 				/*

 									 * here we need the original label position. getNewOffset

 									 * must therefore never have been called for this label.

 									 */

 				u = l.position - 3;

 				if((l.status & Label.STORE) != 0 || (u >= 0 && resize[u]))

 					{

 					getNewOffset(allIndexes, allSizes, l);

 					// TODO update offsets in UNINITIALIZED values

 					visitFrame(l.frame);

 					}

 				l = l.successor;

 				}

 			}

 		else

 			{

 			/*

 							 * Resizing an existing stack map frame table is really hard.

 							 * Not only the table must be parsed to update the offets, but

 							 * new frames may be needed for jump instructions that were

 							 * inserted by this method. And updating the offsets or

 							 * inserting frames can change the format of the following

 							 * frames, in case of packed frames. In practice the whole table

 							 * must be recomputed. For this the frames are marked as

 							 * potentially invalid. This will cause the whole class to be

 							 * reread and rewritten with the COMPUTE_FRAMES option (see the

 							 * ClassWriter.toByteArray method). This is not very efficient

 							 * but is much easier and requires much less code than any other

 							 * method I can think of.

 							 */

 			cw.invalidFrames = true;

 			}

 		}

 	// updates the exception handler block labels

 	Handler h = firstHandler;

 	while(h != null)

 		{

 		getNewOffset(allIndexes, allSizes, h.start);

 		getNewOffset(allIndexes, allSizes, h.end);

 		getNewOffset(allIndexes, allSizes, h.handler);

 		h = h.next;

 		}

 	// updates the instructions addresses in the

 	// local var and line number tables

 	for(i = 0; i < 2; ++i)

 		{

 		ByteVector bv = i == 0 ? localVar : localVarType;

 		if(bv != null)

 			{

 			b = bv.data;

 			u = 0;

 			while(u < bv.length)

 				{

 				label = readUnsignedShort(b, u);

 				newOffset = getNewOffset(allIndexes, allSizes, 0, label);

 				writeShort(b, u, newOffset);

 				label += readUnsignedShort(b, u + 2);

 				newOffset = getNewOffset(allIndexes, allSizes, 0, label)

 				            - newOffset;

 				writeShort(b, u + 2, newOffset);

 				u += 10;

 				}

 			}

 		}

 	if(lineNumber != null)

 		{

 		b = lineNumber.data;

 		u = 0;

 		while(u < lineNumber.length)

 			{

 			writeShort(b, u, getNewOffset(allIndexes,

 			                              allSizes,

 			                              0,

 			                              readUnsignedShort(b, u)));

 			u += 4;

 			}

 		}

 	// updates the labels of the other attributes

 	Attribute attr = cattrs;

 	while(attr != null)

 		{

 		Label[] labels = attr.getLabels();

 		if(labels != null)

 			{

 			for(i = labels.length - 1; i >= 0; --i)

 				{

 				getNewOffset(allIndexes, allSizes, labels[i]);

 				}

 			}

 		attr = attr.next;

 		}

 

 	// replaces old bytecodes with new ones

 	code = newCode;

 }

 

 /**

  * Reads an unsigned short value in the given byte array.

  *

  * @param b     a byte array.

  * @param index the start index of the value to be read.

  * @return the read value.

  */

 static int readUnsignedShort(final byte[] b, final int index){

 	return ((b[index] & 0xFF) << 8) | (b[index + 1] & 0xFF);

 }

 

 /**

  * Reads a signed short value in the given byte array.

  *

  * @param b     a byte array.

  * @param index the start index of the value to be read.

  * @return the read value.

  */

 static short readShort(final byte[] b, final int index){

 	return (short) (((b[index] & 0xFF) << 8) | (b[index + 1] & 0xFF));

 }

 

 /**

  * Reads a signed int value in the given byte array.

  *

  * @param b     a byte array.

  * @param index the start index of the value to be read.

  * @return the read value.

  */

 static int readInt(final byte[] b, final int index){

 	return ((b[index] & 0xFF) << 24) | ((b[index + 1] & 0xFF) << 16)

 	       | ((b[index + 2] & 0xFF) << 8) | (b[index + 3] & 0xFF);

 }

 

 /**

  * Writes a short value in the given byte array.

  *

  * @param b     a byte array.

  * @param index where the first byte of the short value must be written.

  * @param s     the value to be written in the given byte array.

  */

 static void writeShort(final byte[] b, final int index, final int s){

 	b[index] = (byte) (s >>> 8);

 	b[index + 1] = (byte) s;

 }

 

 /**

  * Computes the future value of a bytecode offset. <p> Note: it is possible

  * to have several entries for the same instruction in the <tt>indexes</tt>

  * and <tt>sizes</tt>: two entries (index=a,size=b) and (index=a,size=b')

  * are equivalent to a single entry (index=a,size=b+b').

  *

  * @param indexes current positions of the instructions to be resized. Each

  *                instruction must be designated by the index of its <i>last</i>

  *                byte, plus one (or, in other words, by the index of the <i>first</i>

  *                byte of the <i>next</i> instruction).

  * @param sizes   the number of bytes to be <i>added</i> to the above

  *                instructions. More precisely, for each i < <tt>len</tt>,

  *                <tt>sizes</tt>[i] bytes will be added at the end of the

  *                instruction designated by <tt>indexes</tt>[i] or, if

  *                <tt>sizes</tt>[i] is negative, the <i>last</i> |<tt>sizes[i]</tt>|

  *                bytes of the instruction will be removed (the instruction size

  *                <i>must not</i> become negative or null).

  * @param begin   index of the first byte of the source instruction.

  * @param end     index of the first byte of the target instruction.

  * @return the future value of the given bytecode offset.

  */

 static int getNewOffset(

 		final int[] indexes,

 		final int[] sizes,

 		final int begin,

 		final int end){

 	int offset = end - begin;

 	for(int i = 0; i < indexes.length; ++i)

 		{

 		if(begin < indexes[i] && indexes[i] <= end)

 			{

 			// forward jump

 			offset += sizes[i];

 			}

 		else if(end < indexes[i] && indexes[i] <= begin)

 			{

 			// backward jump

 			offset -= sizes[i];

 			}

 		}

 	return offset;

 }

 

 /**

  * Updates the offset of the given label.

  *

  * @param indexes current positions of the instructions to be resized. Each

  *                instruction must be designated by the index of its <i>last</i>

  *                byte, plus one (or, in other words, by the index of the <i>first</i>

  *                byte of the <i>next</i> instruction).

  * @param sizes   the number of bytes to be <i>added</i> to the above

  *                instructions. More precisely, for each i < <tt>len</tt>,

  *                <tt>sizes</tt>[i] bytes will be added at the end of the

  *                instruction designated by <tt>indexes</tt>[i] or, if

  *                <tt>sizes</tt>[i] is negative, the <i>last</i> |<tt>sizes[i]</tt>|

  *                bytes of the instruction will be removed (the instruction size

  *                <i>must not</i> become negative or null).

  * @param label   the label whose offset must be updated.

  */

 static void getNewOffset(

 		final int[] indexes,

 		final int[] sizes,

 		final Label label){

 	if((label.status & Label.RESIZED) == 0)

 		{

 		label.position = getNewOffset(indexes, sizes, 0, label.position);

 		label.status |= Label.RESIZED;

 		}

 }

 }