/***

* 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;

import java.io.InputStream;

import java.io.IOException;

/**

* A Java class parser to make a {@link ClassVisitor} visit an existing class.

* This class parses a byte array conforming to the Java class file format and

* calls the appropriate visit methods of a given class visitor for each field,

* method and bytecode instruction encountered.

*

* @author Eric Bruneton

* @author Eugene Kuleshov

*/

public class ClassReader{

/**

* Flag to skip method code. If this class is set <code>CODE</code>

* attribute won't be visited. This can be used, for example, to retrieve

* annotations for methods and method parameters.

*/

public final static int SKIP_CODE = 1;

/**

* Flag to skip the debug information in the class. If this flag is set the

* debug information of the class is not visited, i.e. the

* {@link MethodVisitor#visitLocalVariable visitLocalVariable} and

* {@link MethodVisitor#visitLineNumber visitLineNumber} methods will not be

* called.

*/

public final static int SKIP_DEBUG = 2;

/**

* Flag to skip the stack map frames in the class. If this flag is set the

* stack map frames of the class is not visited, i.e. the

* {@link MethodVisitor#visitFrame visitFrame} method will not be called.

* This flag is useful when the {@link ClassWriter#COMPUTE_FRAMES} option is

* used: it avoids visiting frames that will be ignored and recomputed from

* scratch in the class writer.

*/

public final static int SKIP_FRAMES = 4;

/**

* Flag to expand the stack map frames. By default stack map frames are

* visited in their original format (i.e. "expanded" for classes whose

* version is less than V1_6, and "compressed" for the other classes). If

* this flag is set, stack map frames are always visited in expanded format

* (this option adds a decompression/recompression step in ClassReader and

* ClassWriter which degrades performances quite a lot).

*/

public final static int EXPAND_FRAMES = 8;

/**

* The class to be parsed. <i>The content of this array must not be

* modified. This field is intended for {@link Attribute} sub classes, and

* is normally not needed by class generators or adapters.</i>

*/

public final byte[] b;

/**

* The start index of each constant pool item in {@link #b b}, plus one.

* The one byte offset skips the constant pool item tag that indicates its

* type.

*/

private final int[] items;

/**

* The String objects corresponding to the CONSTANT_Utf8 items. This cache

* avoids multiple parsing of a given CONSTANT_Utf8 constant pool item,

* which GREATLY improves performances (by a factor 2 to 3). This caching

* strategy could be extended to all constant pool items, but its benefit

* would not be so great for these items (because they are much less

* expensive to parse than CONSTANT_Utf8 items).

*/

private final String[] strings;

/**

* Maximum length of the strings contained in the constant pool of the

* class.

*/

private final int maxStringLength;

/**

* Start index of the class header information (access, name...) in

* {@link #b b}.

*/

public final int header;

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

// Constructors

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

/**

* Constructs a new {@link ClassReader} object.

*

* @param b the bytecode of the class to be read.

*/

public ClassReader(final byte[] b){

this(b, 0, b.length);

}

/**

* Constructs a new {@link ClassReader} object.

*

* @param b the bytecode of the class to be read.

* @param off the start offset of the class data.

* @param len the length of the class data.

*/

public ClassReader(final byte[] b, final int off, final int len){

this.b = b;

// parses the constant pool

items = new int[readUnsignedShort(off + 8)];

int n = items.length;

strings = new String[n];

int max = 0;

int index = off + 10;

for(int i = 1; i < n; ++i)

{

items[i] = index + 1;

int size;

switch(b[index])

{

case ClassWriter.FIELD:

case ClassWriter.METH:

case ClassWriter.IMETH:

case ClassWriter.INT:

case ClassWriter.FLOAT:

case ClassWriter.NAME_TYPE:

size = 5;

break;

case ClassWriter.LONG:

case ClassWriter.DOUBLE:

size = 9;

++i;

break;

case ClassWriter.UTF8:

size = 3 + readUnsignedShort(index + 1);

if(size > max)

{

max = size;

}

break;

// case ClassWriter.CLASS:

// case ClassWriter.STR:

default:

size = 3;

break;

}

index += size;

}

maxStringLength = max;

// the class header information starts just after the constant pool

header = index;

}

/**

* Returns the class's access flags (see {@link Opcodes}). This value may

* not reflect Deprecated and Synthetic flags when bytecode is before 1.5

* and those flags are represented by attributes.

*

* @return the class access flags

* @see ClassVisitor#visit(int,int,String,String,String,String[])

*/

public int getAccess(){

return readUnsignedShort(header);

}

/**

* Returns the internal name of the class (see

* {@link Type#getInternalName() getInternalName}).

*

* @return the internal class name

* @see ClassVisitor#visit(int,int,String,String,String,String[])

*/

public String getClassName(){

return readClass(header + 2, new char[maxStringLength]);

}

/**

* Returns the internal of name of the super class (see

* {@link Type#getInternalName() getInternalName}). For interfaces, the

* super class is {@link Object}.

*

* @return the internal name of super class, or <tt>null</tt> for

* {@link Object} class.

* @see ClassVisitor#visit(int,int,String,String,String,String[])

*/

public String getSuperName(){

int n = items[readUnsignedShort(header + 4)];

return n == 0 ? null : readUTF8(n, new char[maxStringLength]);

}

/**

* Returns the internal names of the class's interfaces (see

* {@link Type#getInternalName() getInternalName}).

*

* @return the array of internal names for all implemented interfaces or

* <tt>null</tt>.

* @see ClassVisitor#visit(int,int,String,String,String,String[])

*/

public String[] getInterfaces(){

int index = header + 6;

int n = readUnsignedShort(index);

String[] interfaces = new String[n];

if(n > 0)

{

char[] buf = new char[maxStringLength];

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

{

index += 2;

interfaces[i] = readClass(index, buf);

}

}

return interfaces;

}

/**

* Copies the constant pool data into the given {@link ClassWriter}. Should

* be called before the {@link #accept(ClassVisitor,int)} method.

*

* @param classWriter the {@link ClassWriter} to copy constant pool into.

*/

void copyPool(final ClassWriter classWriter){

char[] buf = new char[maxStringLength];

int ll = items.length;

Item[] items2 = new Item[ll];

for(int i = 1; i < ll; i++)

{

int index = items[i];

int tag = b[index - 1];

Item item = new Item(i);

int nameType;

switch(tag)

{

case ClassWriter.FIELD:

case ClassWriter.METH:

case ClassWriter.IMETH:

nameType = items[readUnsignedShort(index + 2)];

item.set(tag,

readClass(index, buf),

readUTF8(nameType, buf),

readUTF8(nameType + 2, buf));

break;

case ClassWriter.INT:

item.set(readInt(index));

break;

case ClassWriter.FLOAT:

item.set(Float.intBitsToFloat(readInt(index)));

break;

case ClassWriter.NAME_TYPE:

item.set(tag,

readUTF8(index, buf),

readUTF8(index + 2, buf),

null);

break;

case ClassWriter.LONG:

item.set(readLong(index));

++i;

break;

case ClassWriter.DOUBLE:

item.set(Double.longBitsToDouble(readLong(index)));

++i;

break;

case ClassWriter.UTF8:

{

String s = strings[i];

if(s == null)

{

index = items[i];

s = strings[i] = readUTF(index + 2,

readUnsignedShort(index),

buf);

}

item.set(tag, s, null, null);

}

break;

// case ClassWriter.STR:

// case ClassWriter.CLASS:

default:

item.set(tag, readUTF8(index, buf), null, null);

break;

}

int index2 = item.hashCode % items2.length;

item.next = items2[index2];

items2[index2] = item;

}

int off = items[1] - 1;

classWriter.pool.putByteArray(b, off, header - off);

classWriter.items = items2;

classWriter.threshold = (int) (0.75d * ll);

classWriter.index = ll;

}

/**

* Constructs a new {@link ClassReader} object.

*

* @param is an input stream from which to read the class.

* @throws IOException if a problem occurs during reading.

*/

public ClassReader(final InputStream is) throws IOException{

this(readClass(is));

}

/**

* Constructs a new {@link ClassReader} object.

*

* @param name the fully qualified name of the class to be read.

* @throws IOException if an exception occurs during reading.

*/

public ClassReader(final String name) throws IOException{

this(ClassLoader.getSystemResourceAsStream(name.replace('.', '/')

+ ".class"));

}

/**

* Reads the bytecode of a class.

*

* @param is an input stream from which to read the class.

* @return the bytecode read from the given input stream.

* @throws IOException if a problem occurs during reading.

*/

private static byte[] readClass(final InputStream is) throws IOException{

if(is == null)

{

throw new IOException("Class not found");

}

byte[] b = new byte[is.available()];

int len = 0;

while(true)

{

int n = is.read(b, len, b.length - len);

if(n == -1)

{

if(len < b.length)

{

byte[] c = new byte[len];

System.arraycopy(b, 0, c, 0, len);

b = c;

}

return b;

}

len += n;

if(len == b.length)

{

byte[] c = new byte[b.length + 1000];

System.arraycopy(b, 0, c, 0, len);

b = c;

}

}

}

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

// Public methods

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

/**

* Makes the given visitor visit the Java class of this {@link ClassReader}.

* This class is the one specified in the constructor (see

* {@link #ClassReader(byte[]) ClassReader}).

*

* @param classVisitor the visitor that must visit this class.

* @param flags option flags that can be used to modify the default behavior

* of this class. See {@link #SKIP_DEBUG}, {@link #EXPAND_FRAMES}.

*/

public void accept(final ClassVisitor classVisitor, final int flags){

accept(classVisitor, new Attribute[0], flags);

}

/**

* Makes the given visitor visit the Java class of this {@link ClassReader}.

* This class is the one specified in the constructor (see

* {@link #ClassReader(byte[]) ClassReader}).

*

* @param classVisitor the visitor that must visit this class.

* @param attrs prototypes of the attributes that must be parsed during the

* visit of the class. Any attribute whose type is not equal to the

* type of one the prototypes will not be parsed: its byte array

* value will be passed unchanged to the ClassWriter. <i>This may

* corrupt it if this value contains references to the constant pool,

* or has syntactic or semantic links with a class element that has

* been transformed by a class adapter between the reader and the

* writer</i>.

* @param flags option flags that can be used to modify the default behavior

* of this class. See {@link #SKIP_DEBUG}, {@link #EXPAND_FRAMES}.

*/

public void accept(

final ClassVisitor classVisitor,

final Attribute[] attrs,

final int flags){

byte[] b = this.b; // the bytecode array

char[] c = new char[maxStringLength]; // buffer used to read strings

int i, j, k; // loop variables

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

Attribute attr;

int access;

String name;

String desc;

String attrName;

String signature;

int anns = 0;

int ianns = 0;

Attribute cattrs = null;

// visits the header

u = header;

access = readUnsignedShort(u);

name = readClass(u + 2, c);

v = items[readUnsignedShort(u + 4)];

String superClassName = v == 0 ? null : readUTF8(v, c);

String[] implementedItfs = new String[readUnsignedShort(u + 6)];

w = 0;

u += 8;

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

{

implementedItfs[i] = readClass(u, c);

u += 2;

}

boolean skipCode = (flags & SKIP_CODE) != 0;

boolean skipDebug = (flags & SKIP_DEBUG) != 0;

boolean unzip = (flags & EXPAND_FRAMES) != 0;

// skips fields and methods

v = u;

i = readUnsignedShort(v);

v += 2;

for(; i > 0; --i)

{

j = readUnsignedShort(v + 6);

v += 8;

for(; j > 0; --j)

{

v += 6 + readInt(v + 2);

}

}

i = readUnsignedShort(v);

v += 2;

for(; i > 0; --i)

{

j = readUnsignedShort(v + 6);

v += 8;

for(; j > 0; --j)

{

v += 6 + readInt(v + 2);

}

}

// reads the class's attributes

signature = null;

String sourceFile = null;

String sourceDebug = null;

String enclosingOwner = null;

String enclosingName = null;

String enclosingDesc = null;

i = readUnsignedShort(v);

v += 2;

for(; i > 0; --i)

{

attrName = readUTF8(v, c);

// tests are sorted in decreasing frequency order

// (based on frequencies observed on typical classes)

if(attrName.equals("SourceFile"))

{

sourceFile = readUTF8(v + 6, c);

}

else if(attrName.equals("InnerClasses"))

{

w = v + 6;

}

else if(attrName.equals("EnclosingMethod"))

{

enclosingOwner = readClass(v + 6, c);

int item = readUnsignedShort(v + 8);

if(item != 0)

{

enclosingName = readUTF8(items[item], c);

enclosingDesc = readUTF8(items[item] + 2, c);

}

}

else if(attrName.equals("Signature"))

{

signature = readUTF8(v + 6, c);

}

else if(attrName.equals("RuntimeVisibleAnnotations"))

{

anns = v + 6;

}

else if(attrName.equals("Deprecated"))

{

access |= Opcodes.ACC_DEPRECATED;

}

else if(attrName.equals("Synthetic"))

{

access |= Opcodes.ACC_SYNTHETIC;

}

else if(attrName.equals("SourceDebugExtension"))

{

int len = readInt(v + 2);

sourceDebug = readUTF(v + 6, len, new char[len]);

}

else if(attrName.equals("RuntimeInvisibleAnnotations"))

{

ianns = v + 6;

}

else

{

attr = readAttribute(attrs,

attrName,

v + 6,

readInt(v + 2),

c,

-1,

null);

if(attr != null)

{

attr.next = cattrs;

cattrs = attr;

}

}

v += 6 + readInt(v + 2);

}

// calls the visit method

classVisitor.visit(readInt(4),

access,

name,

signature,

superClassName,

implementedItfs);

// calls the visitSource method

if(!skipDebug && (sourceFile != null || sourceDebug != null))

{

classVisitor.visitSource(sourceFile, sourceDebug);

}

// calls the visitOuterClass method

if(enclosingOwner != null)

{

classVisitor.visitOuterClass(enclosingOwner,

enclosingName,

enclosingDesc);

}

// visits the class annotations

for(i = 1; i >= 0; --i)

{

v = i == 0 ? ianns : anns;

if(v != 0)

{

j = readUnsignedShort(v);

v += 2;

for(; j > 0; --j)

{

v = readAnnotationValues(v + 2,

c,

true,

classVisitor.visitAnnotation(readUTF8(v, c), i != 0));

}

}

}

// visits the class attributes

while(cattrs != null)

{

attr = cattrs.next;

cattrs.next = null;

classVisitor.visitAttribute(cattrs);

cattrs = attr;

}

// calls the visitInnerClass method

if(w != 0)

{

i = readUnsignedShort(w);

w += 2;

for(; i > 0; --i)

{

classVisitor.visitInnerClass(readUnsignedShort(w) == 0

? null

: readClass(w, c), readUnsignedShort(w + 2) == 0

? null

: readClass(w + 2, c), readUnsignedShort(w + 4) == 0

? null

: readUTF8(w + 4, c),

readUnsignedShort(w + 6));

w += 8;

}

}

// visits the fields

i = readUnsignedShort(u);

u += 2;

for(; i > 0; --i)

{

access = readUnsignedShort(u);

name = readUTF8(u + 2, c);

desc = readUTF8(u + 4, c);

// visits the field's attributes and looks for a ConstantValue

// attribute

int fieldValueItem = 0;

signature = null;

anns = 0;

ianns = 0;

cattrs = null;

j = readUnsignedShort(u + 6);

u += 8;

for(; j > 0; --j)

{

attrName = readUTF8(u, c);

// tests are sorted in decreasing frequency order

// (based on frequencies observed on typical classes)

if(attrName.equals("ConstantValue"))

{

fieldValueItem = readUnsignedShort(u + 6);

}

else if(attrName.equals("Signature"))

{

signature = readUTF8(u + 6, c);

}

else if(attrName.equals("Deprecated"))

{

access |= Opcodes.ACC_DEPRECATED;

}

else if(attrName.equals("Synthetic"))

{

access |= Opcodes.ACC_SYNTHETIC;

}

else if(attrName.equals("RuntimeVisibleAnnotations"))

{

anns = u + 6;

}

else if(attrName.equals("RuntimeInvisibleAnnotations"))

{

ianns = u + 6;

}

else

{

attr = readAttribute(attrs,

attrName,

u + 6,

readInt(u + 2),

c,

-1,

null);

if(attr != null)

{

attr.next = cattrs;

cattrs = attr;

}

}

u += 6 + readInt(u + 2);

}

// visits the field

FieldVisitor fv = classVisitor.visitField(access,

name,

desc,

signature,

fieldValueItem == 0 ? null : readConst(fieldValueItem, c));

// visits the field annotations and attributes

if(fv != null)

{

for(j = 1; j >= 0; --j)

{

v = j == 0 ? ianns : anns;

if(v != 0)

{

k = readUnsignedShort(v);

v += 2;

for(; k > 0; --k)

{

v = readAnnotationValues(v + 2,

c,

true,

fv.visitAnnotation(readUTF8(v, c), j != 0));

}

}

}

while(cattrs != null)

{

attr = cattrs.next;

cattrs.next = null;

fv.visitAttribute(cattrs);

cattrs = attr;

}

fv.visitEnd();

}

}

// visits the methods

i = readUnsignedShort(u);

u += 2;

for(; i > 0; --i)

{

int u0 = u + 6;

access = readUnsignedShort(u);

name = readUTF8(u + 2, c);

desc = readUTF8(u + 4, c);

signature = null;

anns = 0;

ianns = 0;

int dann = 0;

int mpanns = 0;

int impanns = 0;

cattrs = null;

v = 0;

w = 0;

// looks for Code and Exceptions attributes

j = readUnsignedShort(u + 6);

u += 8;

for(; j > 0; --j)

{

attrName = readUTF8(u, c);

int attrSize = readInt(u + 2);

u += 6;

// tests are sorted in decreasing frequency order

// (based on frequencies observed on typical classes)

if(attrName.equals("Code"))

{

if(!skipCode)

{

v = u;

}

}

else if(attrName.equals("Exceptions"))

{

w = u;

}

else if(attrName.equals("Signature"))

{

signature = readUTF8(u, c);

}

else if(attrName.equals("Deprecated"))

{

access |= Opcodes.ACC_DEPRECATED;

}

else if(attrName.equals("RuntimeVisibleAnnotations"))

{

anns = u;

}

else if(attrName.equals("AnnotationDefault"))

{

dann = u;

}

else if(attrName.equals("Synthetic"))

{

access |= Opcodes.ACC_SYNTHETIC;

}

else if(attrName.equals("RuntimeInvisibleAnnotations"))

{

ianns = u;

}

else if(attrName.equals("RuntimeVisibleParameterAnnotations"))

{

mpanns = u;

}

else if(attrName.equals("RuntimeInvisibleParameterAnnotations"))

{

impanns = u;

}

else

{

attr = readAttribute(attrs,

attrName,

u,

attrSize,

c,

-1,

null);

if(attr != null)

{

attr.next = cattrs;

cattrs = attr;

}

}

u += attrSize;

}

// reads declared exceptions

String[] exceptions;

if(w == 0)

{

exceptions = null;

}

else

{

exceptions = new String[readUnsignedShort(w)];

w += 2;

for(j = 0; j < exceptions.length; ++j)

{

exceptions[j] = readClass(w, c);

w += 2;

}

}

// visits the method's code, if any

MethodVisitor mv = classVisitor.visitMethod(access,

name,

desc,

signature,

exceptions);

if(mv != null)

{

/*

* if the returned MethodVisitor is in fact a MethodWriter, it

* means there is no method adapter between the reader and the

* writer. If, in addition, the writer's constant pool was

* copied from this reader (mw.cw.cr == this), and the signature

* and exceptions of the method have not been changed, then it

* is possible to skip all visit events and just copy the

* original code of the method to the writer (the access, name

* and descriptor can have been changed, this is not important

* since they are not copied as is from the reader).

*/

if(mv instanceof MethodWriter)

{

MethodWriter mw = (MethodWriter) mv;

if(mw.cw.cr == this)

{

if(signature == mw.signature)

{

boolean sameExceptions = false;

if(exceptions == null)

{

sameExceptions = mw.exceptionCount == 0;

}

else

{

if(exceptions.length == mw.exceptionCount)

{

sameExceptions = true;

for(j = exceptions.length - 1; j >= 0; --j)

{

w -= 2;

if(mw.exceptions[j] != readUnsignedShort(w))

{

sameExceptions = false;

break;

}

}

}

}

if(sameExceptions)

{

/*

* we do not copy directly the code into

* MethodWriter to save a byte array copy

* operation. The real copy will be done in

* ClassWriter.toByteArray().

*/

mw.classReaderOffset = u0;

mw.classReaderLength = u - u0;

continue;

}

}

}

}

if(dann != 0)

{

AnnotationVisitor dv = mv.visitAnnotationDefault();

readAnnotationValue(dann, c, null, dv);

if(dv != null)

{

dv.visitEnd();

}

}

for(j = 1; j >= 0; --j)

{

w = j == 0 ? ianns : anns;

if(w != 0)

{

k = readUnsignedShort(w);

w += 2;

for(; k > 0; --k)

{

w = readAnnotationValues(w + 2,

c,

true,

mv.visitAnnotation(readUTF8(w, c), j != 0));

}

}

}

if(mpanns != 0)

{

readParameterAnnotations(mpanns, c, true, mv);

}

if(impanns != 0)

{

readParameterAnnotations(impanns, c, false, mv);

}

while(cattrs != null)

{

attr = cattrs.next;

cattrs.next = null;

mv.visitAttribute(cattrs);

cattrs = attr;

}

}

if(mv != null && v != 0)

{

int maxStack = readUnsignedShort(v);

int maxLocals = readUnsignedShort(v + 2);

int codeLength = readInt(v + 4);

v += 8;

int codeStart = v;

int codeEnd = v + codeLength;

mv.visitCode();

// 1st phase: finds the labels

int label;

Label[] labels = new Label[codeLength + 1];

while(v < codeEnd)

{

int opcode = b[v] & 0xFF;

switch(ClassWriter.TYPE[opcode])

{

case ClassWriter.NOARG_INSN:

case ClassWriter.IMPLVAR_INSN:

v += 1;

break;

case ClassWriter.LABEL_INSN:

label = v - codeStart + readShort(v + 1);

if(labels[label] == null)

{

labels[label] = new Label();

}

v += 3;

break;

case ClassWriter.LABELW_INSN:

label = v - codeStart + readInt(v + 1);

if(labels[label] == null)

{

labels[label] = new Label();

}

v += 5;

break;

case ClassWriter.WIDE_INSN:

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

if(opcode == Opcodes.IINC)

{

v += 6;

}

else

{

v += 4;

}

break;

case ClassWriter.TABL_INSN:

// skips 0 to 3 padding bytes

w = v - codeStart;

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

// reads instruction

label = w + readInt(v);

if(labels[label] == null)

{

labels[label] = new Label();