public CodeAttribute(ConstantPoolInfo_UTF8 utf8Name, MSBBinaryReaderWrapper reader, ConstantPoolInfo[] pool)
: base(utf8Name,reader,pool)
{
//
// TODO: Add constructor logic here
//
}
public MethodInfo(MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool)
{
accessFlags = reader.ReadUInt16();
nameIndex = reader.ReadUInt16();
descriptorIndex = reader.ReadUInt16();
attributeCount = reader.ReadUInt16();
if (log.IsDebugEnabled) log.DebugFormat("Method = {0}{1}",pool[nameIndex - 1],pool[descriptorIndex-1]);
attributes = new AttributeInfo[attributeCount];
for (int i = 0; i < attributeCount; i++)
{
attributes[i] = AttributeInfo.readAttributeInfo(reader,pool);
if (attributes[i] is CodeAttribute){
methodCode = (CodeAttribute) attributes[i];
}
}
// if (log.IsDebugEnabled) log.DebugFormat("Name should be {0}",pool[nameIndex-1]);
name = (ConstantPoolInfo_UTF8)pool[nameIndex - 1];
descriptor = (ConstantPoolInfo_UTF8)pool[descriptorIndex - 1];
// deriveParameterCount();
}
public override void parse(MSBBinaryReaderWrapper reader, ConstantPoolInfo[] pool)
{
innerClassCount = reader.ReadUInt16();
innerClasses = new InnerClassInfo[innerClassCount];
for (int i = 0; i < innerClassCount; i++){
innerClasses[i] = new InnerClassInfo(reader,pool);
}
}
public override void parse(MSBBinaryReaderWrapper reader, ConstantPoolInfo[] pool)
{
UInt16 count = reader.ReadUInt16();
//if (log.IsDebugEnabled) log.DebugFormat("Will read in {0} line number mappings",count);
for (int i = 0; i < count; i++){
UInt16 position = reader.ReadUInt16();
UInt16 lineNumber = reader.ReadUInt16();
lineNumberTable.Add(position,lineNumber);
//if (log.IsDebugEnabled) log.DebugFormat("{0}->{1}",position,lineNumber);
}
}
public FieldInfo(MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool)
{
accessFlags = reader.ReadUInt16();
nameIndex = reader.ReadUInt16();
descriptorIndex = reader.ReadUInt16();
//if (log.IsDebugEnabled) log.DebugFormat("Name should be {0}",pool[nameIndex-1]);
name = (ConstantPoolInfo_UTF8)pool[nameIndex - 1];
descriptor = (ConstantPoolInfo_UTF8)pool[descriptorIndex - 1];
attributeCount = reader.ReadUInt16();
attributes = new AttributeInfo[attributeCount];
for (int i = 0; i < attributeCount; i++)
{
attributes[i] = AttributeInfo.readAttributeInfo(reader,pool);
}
}
public static AttributeInfo readAttributeInfo(MSBBinaryReaderWrapper reader, ConstantPoolInfo[] pool)
{
int nameIdx = reader.ReadUInt16();
//if (log.IsDebugEnabled) log.DebugFormat("Read Index {0}/{0:X}",nameIdx);
if (pool[nameIdx - 1] is ConstantPoolInfo_UTF8){
ConstantPoolInfo_UTF8 utf8Name = (ConstantPoolInfo_UTF8)pool[nameIdx - 1];
//if (log.IsDebugEnabled) log.DebugFormat("Attribute name: {0}",utf8Name);
String attrName = utf8Name.getUTF8String();
if (attrName.Equals("Code"))
{
return new CodeAttribute(utf8Name,reader,pool);
}
else if (attrName.Equals("InnerClasses")){
return new InnerClassesAttribute(utf8Name,reader,pool);
}
else if (attrName.Equals("ConstantValue")){
return new ConstantValueAttribute(utf8Name,reader,pool);
}
else if (attrName.Equals("LineNumberTable")){
return new LineNumberTableAttribute(utf8Name,reader,pool);
}
else if (attrName.Equals("SourceFile")){
return new SourceFileAttribute(utf8Name,reader,pool);
}
else if (
attrName.Equals("LocalVariableTable") ||
attrName.Equals("Signature") ||
attrName.Equals("Exceptions") ||
attrName.Equals("Deprecated") ||
attrName.Equals("EnclosingMethod") ||
attrName.Equals("RuntimeVisibleAnnotations")){
return new AttributeInfo(utf8Name,reader,pool);
}
else {
throw new Exception("Don't know how to handle " + attrName);
}
}
else {
throw new Exception("Expected UTF8, instead got " + pool[nameIdx - 1]);
}
}
public override void parse(MSBBinaryReaderWrapper reader, ConstantPoolInfo[] pool)
{
//base.parse(reader,pool);
maxLength = reader.ReadUInt16();
maxLocals = reader.ReadUInt16();
codeLength = reader.ReadUInt32();
int readLength = 0;
while (readLength < codeLength)
{
ByteCode bc = ByteCodeFactory.readByteCode(reader,pool,readLength);
//code.Add(bc);
//if (log.IsDebugEnabled) log.DebugFormat("{0}: {1}",readLength,bc);
code.Add(readLength,bc);
readLength += bc.getSize();
}
exceptionTableLength = reader.ReadUInt16();
//if (log.IsDebugEnabled) log.DebugFormat("Exception table length: {0}",exceptionTableLength);
exceptions = new ExceptionTableEntry[exceptionTableLength];
for (int i = 0; i < exceptionTableLength; i++){
exceptions[i] = new ExceptionTableEntry(reader);
}
attributeCount = reader.ReadUInt16();
//if (log.IsDebugEnabled) log.DebugFormat("Have {0} code attributes",attributeCount);
attributes = new AttributeInfo[attributeCount];
for (int i = 0; i < attributeCount; i++)
{
attributes[i] = AttributeInfo.readAttributeInfo(reader,pool);
if (attributes[i] is LineNumberTableAttribute){
lineNumbers = (LineNumberTableAttribute) attributes[i];
}
}
}
public InnerClassInfo(MSBBinaryReaderWrapper reader, ConstantPoolInfo[] pool)
{
UInt16 innerClassIndex = reader.ReadUInt16();
if (innerClassIndex != 0){
innerClass = (ConstantPoolInfo_Class) pool[innerClassIndex - 1];
}
UInt16 outerClassIndex = reader.ReadUInt16();
if (outerClassIndex != 0){
outerClass = (ConstantPoolInfo_Class) pool[outerClassIndex - 1];
}
UInt16 innerNameIndex = reader.ReadUInt16();
if (innerNameIndex != 0){
innerName = (ConstantPoolInfo_UTF8) pool[innerNameIndex - 1];
}
accessFlags = reader.ReadUInt16();
}
public override void parse(MSBBinaryReaderWrapper reader)
{
length = reader.ReadUInt16();
chars = "";
ArrayList codePointArr = new ArrayList();
byte[] originalChars = reader.getReader().ReadBytes(length);
for (int i = 0; i < length; i++){
if ((originalChars[i] & 0x80) ==0){ // ascii
char theChar = (char) originalChars[i];
chars += theChar.ToString(); // yeah bad
codePointArr.Add((int)theChar);
}
else if ((originalChars[i] & 0xE0) == 0xC0){ // u0080-u07ff
byte[] temp = new byte[2];
int val = (originalChars[i] & 0x1F) << 6;
i++;
val = val | (originalChars[i] & 0x3F);
temp[0] = (byte)((val & 0x700) >> 8);
temp[1] = (byte)(val & 0xFF);
chars += BitConverter.ToChar(temp,0);
isUnicode = true;
codePointArr.Add(val);
}
else if ((originalChars[i] & 0xE0) == 0xE0){ // u0800-ffff
byte[] temp = new byte[2];
int val = (originalChars[i] & 0xF) << 12;
i++;
val = val | (originalChars[i] & 0x3F);
i++;
val = val | (originalChars[i] & 0x3F);
temp[0] = (byte)((val & 0xFF00) >> 8);
temp[1] = (byte)(val & 0xFF);
chars += BitConverter.ToChar(temp,0);
isUnicode = true;
codePointArr.Add(val);
}
}
}
/**
* Constructs new ClassFile from the given reader_
*/
public ClassFile(BinaryReader reader_)
{
MSBBinaryReaderWrapper reader = new MSBBinaryReaderWrapper(reader_);
System.UInt32 magic = reader.ReadUInt32();
// if it doesn't start with CLASS_FILE_MAGIC, it ain't even valid!
if (magic != CLASS_FILE_MAGIC)
{
if (log.IsDebugEnabled) log.DebugFormat("Did not get proper magic...");
if (log.IsDebugEnabled) log.DebugFormat("{0:X}",CLASS_FILE_MAGIC);
if (log.IsDebugEnabled) log.DebugFormat("{0:X}",magic);
}
else
{
minor = reader.ReadUInt16();
major = reader.ReadUInt16();
if (log.IsDebugEnabled) log.DebugFormat("{0}.{1}",major,minor);
/**
* The constant pool is the set of Strings, method names, class names and numbers
* that will be referenced throughout the class
*/
constantPoolCount = (UInt16)(reader.ReadUInt16() - 1); // the value here is the maximum 1-indexed entry
if (log.IsDebugEnabled) log.DebugFormat("{0} constant pool entries",constantPoolCount);
constantPool = new ConstantPoolInfo[constantPoolCount];
/**
* Pass 1 - Read in the actual entries
*/
for (int i = 0; i < constantPoolCount; i++)
{
constantPool[i] = ConstantPoolInfoFactory.readConstantPoolEntry(reader);
// Long entries take up 2 constants
if (constantPool[i] is ConstantPoolInfo_Long || constantPool[i] is ConstantPoolInfo_Double){
constantPool[i+1] = constantPool[i];
i++;
}
if (constantPool[i] is ConstantPoolInfo_UTF8){
//ConstantPoolInfo_UTF8 utf8 = (ConstantPoolInfo_UTF8) constantPool[i];
//if (log.IsDebugEnabled) log.DebugFormat("{0} Read {1}:{2}",i+1,constantPool[i].getName(),utf8.isUnicode ? "(UNICODE STRING)" : constantPool[i].ToString());
}
else {
//if (log.IsDebugEnabled) log.DebugFormat("{0} Read {1}:{2}",i+1,constantPool[i].getName(),constantPool[i].ToString());
}
}
/**
* Pass 2 - Resolve constant pool references
* /
*/
for (int i = 0; i < constantPool.Length; i++)
{
constantPool[i].resolve(constantPool);
//if (log.IsDebugEnabled) log.DebugFormat("{0} Read {1}:{2}",i+1,constantPool[i].getName(),constantPool[i].ToString());
}
accessFlags = reader.ReadUInt16();
UInt16 thisClassIndex = reader.ReadUInt16();
thisClass = (ConstantPoolInfo_Class)constantPool[thisClassIndex - 1];
if (log.IsDebugEnabled) log.DebugFormat("This class: {0}",constantPool[thisClass.getNameIndex()-1]);
UInt16 superClassIndex = reader.ReadUInt16();
if (superClassIndex != 0){
superClass = (ConstantPoolInfo_Class)constantPool[superClassIndex - 1];
if (log.IsDebugEnabled) log.DebugFormat("Super class: {0}",constantPool[superClass.getNameIndex()-1]);
}
else if (! thisClass.getClassName().Equals("java/lang/Object")){
throw new Exception("Only Object can have no superclasses");
}
interfaceCount = reader.ReadUInt16();
if (log.IsDebugEnabled) log.DebugFormat("{0} interfaces",interfaceCount);
if (interfaceCount > 0)
{
interfaces = new ConstantPoolInfo_Class[interfaceCount];
for (int i = 0; i < interfaceCount; i++)
{
UInt16 ifaceIdx = reader.ReadUInt16();
interfaces[i] = (ConstantPoolInfo_Class) constantPool[ifaceIdx -1];
}
}
fieldCount = reader.ReadUInt16();
if (log.IsDebugEnabled) log.DebugFormat("{0} fields",fieldCount);
if (fieldCount > 0){
fields = new FieldInfo[fieldCount];
for (int i = 0; i < fieldCount; i++){
fields[i] = new FieldInfo(reader,constantPool);
if (fields[i].isStatic()){
staticFieldValues.Add(fields[i].GetFieldName(),NullValue.INSTANCE);
}
}
}
methodCount = reader.ReadUInt16();
if (log.IsDebugEnabled) log.DebugFormat("{0} methods",methodCount);
if (methodCount > 0)
{
methods = new MethodInfo[methodCount];
for (int i = 0; i < methodCount; i++)
{
methods[i] = new MethodInfo(reader,constantPool);
//methods[i].resolve(constantPool);
//if (log.IsDebugEnabled) log.DebugFormat("Method: {0}",methods[i]);
//if (log.IsDebugEnabled) log.DebugFormat("Storing under {0}",methods[i].getMethodName()+methods[i].getDescriptor());
methodsByName[methods[i].getMethodName()+methods[i].getDescriptor()] = methods[i];
methods[i].SetClassFile(this);
}
}
attributeCount = reader.ReadUInt16();
if (log.IsDebugEnabled) log.DebugFormat("{0} attributes",attributeCount);
attributes = new AttributeInfo[attributeCount];
for (int i = 0; i < attributeCount; i++)
{
attributes[i] = AttributeInfo.readAttributeInfo(reader,constantPool);
if (log.IsDebugEnabled) log.DebugFormat(attributes[i].ToString());
}
}
}
public virtual void parse(MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool)
{
info = reader.getReader().ReadBytes((int)length);
}
public override void parse(MSBBinaryReaderWrapper reader)
{
nameIndex = reader.ReadUInt16();
descriptorIndex = reader.ReadUInt16();
}
public LineNumberTableAttribute(ConstantPoolInfo_UTF8 utf8Name, MSBBinaryReaderWrapper reader, ConstantPoolInfo[] pool)
: base(utf8Name,reader,pool)
{
}
public override void parse(MSBBinaryReaderWrapper reader)
{
// TODO... swap the values...
value = reader.ReadFloat(); // crossing fingers that this is the same...
}
public override void parse(MSBBinaryReaderWrapper reader, ConstantPoolInfo[] pool)
{
UInt16 valueRef = reader.ReadUInt16();
value = pool[valueRef - 1];
}
ConstantPoolInfo value; // should point to Long,String,Int..
#endregion Fields
#region Constructors
public ConstantValueAttribute(ConstantPoolInfo_UTF8 utf8Name, MSBBinaryReaderWrapper reader, ConstantPoolInfo[] pool)
: base(utf8Name,reader,pool)
{
}
public ExceptionTableEntry(MSBBinaryReaderWrapper reader)
{
startPC = reader.ReadUInt16();
endPC = reader.ReadUInt16();
handlerPC = reader.ReadUInt16();
catchType = reader.ReadUInt16();
}
public override void parse(MSBBinaryReaderWrapper reader)
{
classIndex = reader.ReadUInt16();
nameAndTypeIndex = reader.ReadUInt16();
}
public override void parse(MSBBinaryReaderWrapper reader)
{
value = reader.ReadUInt64();
}
public static ConstantPoolInfo readConstantPoolEntry(MSBBinaryReaderWrapper reader)
{
byte tag = reader.ReadByte();
ConstantPoolInfo info = null;
switch (tag)
{
case TYPE_CLASS:
{
info = new ConstantPoolInfo_Class(tag);
break;
}
case TYPE_METHOD_REF:
{
info = new ConstantPoolInfo_MethodRef(tag);
break;
}
case TYPE_INTERFACE_METHOD_REF:
{
info = new ConstantPoolInfo_InterfaceMethodRef(tag);
break;
}
case TYPE_FIELD_REF:
{
info = new ConstantPoolInfo_FieldRef(tag);
break;
}
case TYPE_STRING:
{
info = new ConstantPoolInfo_String(tag);
break;
}
case TYPE_UTF8:
{
info = new ConstantPoolInfo_UTF8(tag);
break;
}
case TYPE_NAME_AND_TYPE:
{
info = new ConstantPoolInfo_NameAndType(tag);
break;
}
case TYPE_INTEGER:
{
info = new ConstantPoolInfo_Integer(tag);
break;
}
case TYPE_FLOAT:
{
info = new ConstantPoolInfo_Float(tag);
break;
}
case TYPE_DOUBLE:
{
info = new ConstantPoolInfo_Double(tag);
break;
}
case TYPE_LONG:
{
info = new ConstantPoolInfo_Long(tag);
break;
}
default:
{
throw new UnknownConstantPoolTypeException(String.Format("Do not know how to parse {0}",tag));
}
}
info.parse(reader);
return info;
}
public AttributeInfo(ConstantPoolInfo_UTF8 name, MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool)
{
this.name = name;
length = reader.ReadUInt32();
parse(reader,pool);
}
public static ByteCode readByteCode(MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool,int offset)
{
byte code = reader.ReadByte();
ByteCode byteCode = null;
switch (code)
{
case 0x00: {byteCode = new ByteCode_nop(code,reader,pool); break; }
case 0x01: {byteCode = new ByteCode_aconst_null(code,reader,pool); break; }
case 0x02: {byteCode = new ByteCode_iconst(code,reader,pool,-1); break; }
case 0x03: {byteCode = new ByteCode_iconst(code,reader,pool,0); break; }
case 0x04: {byteCode = new ByteCode_iconst(code,reader,pool,1); break; }
case 0x05: {byteCode = new ByteCode_iconst(code,reader,pool,2); break; }
case 0x06: {byteCode = new ByteCode_iconst(code,reader,pool,3); break; }
case 0x07: {byteCode = new ByteCode_iconst(code,reader,pool,4); break; }
case 0x08: {byteCode = new ByteCode_iconst(code,reader,pool,5); break; }
case 0x09: {byteCode = new ByteCode_lconst(code,reader,pool,0); break; }
case 0x0A: {byteCode = new ByteCode_lconst(code,reader,pool,1); break; }
case 0x0B: {byteCode = new ByteCode_fconst(code,reader,pool,0); break; }
case 0x0C: {byteCode = new ByteCode_fconst(code,reader,pool,1); break; }
case 0x0D: {byteCode = new ByteCode_fconst(code,reader,pool,2); break; }
case 0x0E: {byteCode = new ByteCode_dconst(code,reader,pool,0); break; }
case 0x0F: {byteCode = new ByteCode_dconst(code,reader,pool,1); break; }
case 0x10: {byteCode = new ByteCode_bipush(code,reader,pool);break; }
case 0x11: {byteCode = new ByteCode_sipush(code,reader,pool);break; }
case 0x12: {byteCode = new ByteCode_ldc(code,reader,pool);break; }
case 0x13: {byteCode = new ByteCode_ldc_w(code,reader,pool); break; }
case 0x14: {byteCode = new ByteCode_ldc2_w(code,reader,pool); break; }
case 0x15: {byteCode = new ByteCode_iload(code,reader,pool); break; }
case 0x16: {byteCode = new ByteCode_lload(code,reader,pool); break; }
case 0x19: {byteCode = new ByteCode_aload0(code,reader,pool); break; }
case 0x1A: {byteCode = new ByteCode_iload(code,reader,pool,0);break; }
case 0x1B: {byteCode = new ByteCode_iload(code,reader,pool,1);break; }
case 0x1C: {byteCode = new ByteCode_iload(code,reader,pool,2);break; }
case 0x1D: {byteCode = new ByteCode_iload(code,reader,pool,3);break; }
case 0x1E: {byteCode = new ByteCode_lload(code,reader,pool,0);break; }
case 0x1F: {byteCode = new ByteCode_lload(code,reader,pool,1);break; }
case 0x20: {byteCode = new ByteCode_lload(code,reader,pool,2);break; }
case 0x21: {byteCode = new ByteCode_lload(code,reader,pool,3);break; }
case 0x22: {byteCode = new ByteCode_fload(code,reader,pool,0);break; }
case 0x23: {byteCode = new ByteCode_fload(code,reader,pool,1);break; }
case 0x24: {byteCode = new ByteCode_fload(code,reader,pool,2);break; }
case 0x25: {byteCode = new ByteCode_fload(code,reader,pool,3);break; }
case 0x26: {byteCode = new ByteCode_fload(code,reader,pool,0);break; }
case 0x27: {byteCode = new ByteCode_fload(code,reader,pool,1);break; }
case 0x28: {byteCode = new ByteCode_fload(code,reader,pool,2);break; }
case 0x2A: {byteCode = new ByteCode_aload0(code,reader,pool,0);break; }
case 0x2B: {byteCode = new ByteCode_aload0(code,reader,pool,1);break; }
case 0x2C: {byteCode = new ByteCode_aload0(code,reader,pool,2);break; }
case 0x2D: {byteCode = new ByteCode_aload0(code,reader,pool,3);break; }
case 0x2E: {byteCode = new ByteCode_iaload(code,reader,pool);break; }
case 0x32: {byteCode = new ByteCode_aaload(code,reader,pool);break; }
case 0x33: {byteCode = new ByteCode_baload(code,reader,pool);break; }
case 0x34: {byteCode = new ByteCode_caload(code,reader,pool);break; }
case 0x36: {byteCode = new ByteCode_istore(code,reader,pool);break; }
case 0x37: {byteCode = new ByteCode_lstore(code,reader,pool);break; }
case 0x3A: {byteCode = new ByteCode_astore(code,reader,pool);break; }
case 0x3B: {byteCode = new ByteCode_istore(code,reader,pool,0);break; }
case 0x3C: {byteCode = new ByteCode_istore(code,reader,pool,1);break; }
case 0x3D: {byteCode = new ByteCode_istore(code,reader,pool,2);break; }
case 0x3E: {byteCode = new ByteCode_istore(code,reader,pool,3);break; }
case 0x3F: {byteCode = new ByteCode_lstore(code,reader,pool,0);break; }
case 0x40: {byteCode = new ByteCode_lstore(code,reader,pool,1);break; }
case 0x41: {byteCode = new ByteCode_lstore(code,reader,pool,2);break; }
case 0x42: {byteCode = new ByteCode_lstore(code,reader,pool,3);break; }
case 0x43: {byteCode = new ByteCode_fstore(code,reader,pool,0);break; }
case 0x44: {byteCode = new ByteCode_fstore(code,reader,pool,1);break; }
case 0x45: {byteCode = new ByteCode_fstore(code,reader,pool,2);break; }
case 0x46: {byteCode = new ByteCode_fstore(code,reader,pool,3);break; }
case 0x47: {byteCode = new ByteCode_dstore(code,reader,pool,0);break; }
case 0x48: {byteCode = new ByteCode_dstore(code,reader,pool,1);break; }
case 0x49: {byteCode = new ByteCode_dstore(code,reader,pool,2);break; }
case 0x4A: {byteCode = new ByteCode_dstore(code,reader,pool,3);break; }
case 0x4B: {byteCode = new ByteCode_astore(code,reader,pool,0); break; }
case 0x4C: {byteCode = new ByteCode_astore(code,reader,pool,1); break; }
case 0x4D: {byteCode = new ByteCode_astore(code,reader,pool,2); break; }
case 0x4E: {byteCode = new ByteCode_astore(code,reader,pool,3); break; }
case 0x4F: {byteCode = new ByteCode_iastore(code,reader,pool); break; }
case 0x53: {byteCode = new ByteCode_aastore(code,reader,pool);break; }
case 0x54: {byteCode = new ByteCode_bastore(code,reader,pool);break; }
case 0x55: {byteCode = new ByteCode_castore(code,reader,pool);break; }
case 0x57: {byteCode = new ByteCode_pop(code,reader,pool,1);break; }
case 0x58: {byteCode = new ByteCode_pop(code,reader,pool,2);break; }
case 0x59: {byteCode = new ByteCode_dup(code,reader,pool,0);break; }
case 0x5A: {byteCode = new ByteCode_dup(code,reader,pool,1);break; }
case 0x5B: {byteCode = new ByteCode_dup(code,reader,pool,2);break; }
case 0x5C: {byteCode = new ByteCode_dup2(code,reader,pool,0);break; }
case 0x60: {byteCode = new ByteCode_iadd(code,reader,pool);break; }
case 0x61: {byteCode = new ByteCode_ladd(code,reader,pool);break; }
case 0x62: {byteCode = new ByteCode_fadd(code,reader,pool);break; }
case 0x63: {byteCode = new ByteCode_dadd(code,reader,pool);break; }
case 0x64: {byteCode = new ByteCode_isub(code,reader,pool);break; }
case 0x65: {byteCode = new ByteCode_lsub(code,reader,pool);break; }
case 0x66: {byteCode = new ByteCode_fsub(code,reader,pool);break; }
case 0x67: {byteCode = new ByteCode_dsub(code,reader,pool);break; }
case 0x68: {byteCode = new ByteCode_imul(code,reader,pool);break; }
case 0x6A: {byteCode = new ByteCode_fmul(code,reader,pool);break; }
case 0x6B: {byteCode = new ByteCode_dmul(code,reader,pool);break; }
case 0x6C: {byteCode = new ByteCode_idiv(code,reader,pool);break; }
case 0x6D: {byteCode = new ByteCode_ldiv(code,reader,pool);break; }
case 0x6F: {byteCode = new ByteCode_ddiv(code,reader,pool);break; }
case 0x70: {byteCode = new ByteCode_irem(code,reader,pool);break; }
case 0x74: {byteCode = new ByteCode_ineg(code,reader,pool);break; }
case 0x75: {byteCode = new ByteCode_lneg(code,reader,pool);break; }
case 0x76: {byteCode = new ByteCode_fneg(code,reader,pool);break; }
case 0x77: {byteCode = new ByteCode_dneg(code,reader,pool);break; }
case 0x78: {byteCode = new ByteCode_ishl(code,reader,pool);break; }
case 0x79: {byteCode = new ByteCode_lshl(code,reader,pool);break; }
case 0x7A: {byteCode = new ByteCode_ishr(code,reader,pool);break; }
case 0x7C: {byteCode = new ByteCode_iushr(code,reader,pool);break; }
case 0x7D: {byteCode = new ByteCode_lushr(code,reader,pool);break; }
case 0x7E: {byteCode = new ByteCode_iand(code,reader,pool);break; }
case 0x7F: {byteCode = new ByteCode_land(code,reader,pool);break; }
case 0x80: {byteCode = new ByteCode_ior(code,reader,pool);break; }
case 0x81: {byteCode = new ByteCode_lor(code,reader,pool);break; }
case 0x82: {byteCode = new ByteCode_ixor(code,reader,pool);break; }
case 0x84: {byteCode = new ByteCode_iinc(code,reader,pool);break; }
case 0x85: {byteCode = new ByteCode_i2l(code,reader,pool);break; }
case 0x86: {byteCode = new ByteCode_i2f(code,reader,pool);break; }
case 0x87: {byteCode = new ByteCode_i2d(code,reader,pool);break; }
case 0x88: {byteCode = new ByteCode_l2i(code,reader,pool);break; }
case 0x8B: {byteCode = new ByteCode_f2i(code,reader,pool);break; }
case 0x8D: {byteCode = new ByteCode_f2d(code,reader,pool);break; }
case 0x8E: {byteCode = new ByteCode_d2i(code,reader,pool);break; }
case 0x8F: {byteCode = new ByteCode_d2l(code,reader,pool);break; }
case 0x91: {byteCode = new ByteCode_i2b(code,reader,pool);break; }
case 0x92: {byteCode = new ByteCode_i2c(code,reader,pool);break; }
case 0x93: {byteCode = new ByteCode_i2s(code,reader,pool);break; }
case 0x94: {byteCode = new ByteCode_lcmp(code,reader,pool);break; }
case 0x95: {byteCode = new ByteCode_fcmp(code,reader,pool,"l");break; }
case 0x96: {byteCode = new ByteCode_fcmp(code,reader,pool,"g");break; }
case 0x97: {byteCode = new ByteCode_dcmp(code,reader,pool,"l");break; }
case 0x98: {byteCode = new ByteCode_dcmp(code,reader,pool,"g");break; }
case 0x99: {byteCode = new ByteCode_if(code,reader,pool,"eq");break; }
case 0x9A: {byteCode = new ByteCode_if(code,reader,pool,"ne");break; }
case 0x9B: {byteCode = new ByteCode_if(code,reader,pool,"lt");break; }
case 0x9C: {byteCode = new ByteCode_if(code,reader,pool,"ge");break; }
case 0x9D: {byteCode = new ByteCode_if(code,reader,pool,"gt");break; }
case 0x9E: {byteCode = new ByteCode_if(code,reader,pool,"le");break; }
case 0x9F: {byteCode = new ByteCode_if_icmp(code,reader,pool,"eq");break; }
case 0xA0: {byteCode = new ByteCode_if_icmp(code,reader,pool,"ne");break; }
case 0xA1: {byteCode = new ByteCode_if_icmp(code,reader,pool,"lt");break; }
case 0xA2: {byteCode = new ByteCode_if_icmp(code,reader,pool,"ge");break; }
case 0xA3: {byteCode = new ByteCode_if_icmp(code,reader,pool,"gt");break; }
case 0xA4: {byteCode = new ByteCode_if_icmp(code,reader,pool,"le");break; }
case 0xA5: {byteCode = new ByteCode_if_acmp(code,reader,pool,"eq");break; }
case 0xA6: {byteCode = new ByteCode_if_acmp(code,reader,pool,"ne");break; }
case 0xA7: {byteCode = new ByteCode_goto(code,reader,pool);break; }
case 0xA8: {byteCode = new ByteCode_jsr(code,reader,pool);break; }
case 0xA9: {byteCode = new ByteCode_ret(code,reader,pool);break; }
case 0xAA: {byteCode = new ByteCode_tableswitch(code,reader,pool,offset);break; }
case 0xAB: {byteCode = new ByteCode_lookupswitch(code,reader,pool,offset);break; }
case 0xAC: {byteCode = new ByteCode_ireturn(code,reader,pool); break; }
case 0xAD: {byteCode = new ByteCode_lreturn(code,reader,pool); break; }
case 0xAE: {byteCode = new ByteCode_freturn(code,reader,pool); break; }
case 0xAF: {byteCode = new ByteCode_dreturn(code,reader,pool); break; }
case 0xB0: {byteCode = new ByteCode_areturn(code,reader,pool); break; }
case 0xB1: {byteCode = new ByteCode_return(code,reader,pool); break; }
case 0xB2: {byteCode = new ByteCode_getstatic(code,reader,pool); break; }
case 0xB3: {byteCode = new ByteCode_putstatic(code,reader,pool); break; }
case 0xB4: {byteCode = new ByteCode_getfield(code,reader,pool); break; }
case 0xB5: {byteCode = new ByteCode_putfield(code,reader,pool); break; }
case 0xB6: {byteCode = new ByteCode_invokevirtual(code,reader,pool); break; }
case 0xB7: {byteCode = new ByteCode_invokespecial(code,reader,pool); break; }
case 0xB8: {byteCode = new ByteCode_invokestatic(code,reader,pool); break; }
case 0xB9: {byteCode = new ByteCode_invokeinterface(code,reader,pool); break; }
case 0xBB: {byteCode = new ByteCode_new(code,reader,pool); break; }
case 0xBC: {byteCode = new ByteCode_newarray(code,reader,pool); break; }
case 0xBD: {byteCode = new ByteCode_anewarray(code,reader,pool); break; }
case 0xBE: {byteCode = new ByteCode_arraylength(code,reader,pool); break; }
case 0xBF: {byteCode = new ByteCode_athrow(code,reader,pool); break; }
case 0xC0: {byteCode = new ByteCode_checkcast(code,reader,pool); break; }
case 0xC1: {byteCode = new ByteCode_instanceof(code,reader,pool); break; }
case 0xC2: {byteCode = new ByteCode_monitorenter(code,reader,pool); break; }
case 0xC3: {byteCode = new ByteCode_monitorexit(code,reader,pool); break; }
case 0xC6: {byteCode = new ByteCode_if(code,reader,pool,"null"); break; }
case 0xC7: {byteCode = new ByteCode_if(code,reader,pool,"nonnull"); break; }
default:
{
throw new UnsupportedByteCodeException(String.Format("Unknown code {0}/{0:X}",code));
}
}
return byteCode;
}
public InnerClassesAttribute(ConstantPoolInfo_UTF8 utf8Name, MSBBinaryReaderWrapper reader, ConstantPoolInfo[] pool)
: base(utf8Name,reader,pool)
{
}
