public ByteCode_tableswitch(byte code,MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool, int offset)
: base(code)
{
// there is a 0-3 byte padding based on what the bytecode
// offset is so that the default reference will end up
// on a 4-byte boundary
offset++; // handle bytecode
name = "tableswitch";
size = 1;
int padCount = (4 - (offset % 4));
if (padCount == 4) { padCount = 0; }
for (int i = 0; i < padCount; i++){
reader.ReadByte();
}
size += padCount;
//if (log.IsDebugEnabled) log.DebugFormat("Read {0} pad characters, offset = {1}",padCount,offset);
defaultBranch = (int)reader.ReadUInt32();
//if (log.IsDebugEnabled) log.DebugFormat("Default: {0}/{0:X}",defaultBranch);
low = (int)reader.ReadUInt32();
high = (int)reader.ReadUInt32();
//if (log.IsDebugEnabled) log.DebugFormat("{0} offsets ({1}/{1:X},{2}/{2:X})",high - low + 1,high,low);
size += 12;
int offsetCount = (int)(high - low + 1);
offsets = new int[offsetCount];
for (int i = 0; i < offsetCount; i++){
offsets[i] = (int) reader.ReadUInt32();
if (log.IsDebugEnabled) log.DebugFormat("Offset: {0}",offsets[i]);
size += 4;
}
}
public override void resolve(ConstantPoolInfo[] pool)
{
theClass = (ConstantPoolInfo_Class)pool[classIndex - 1];
nameAndType = (ConstantPoolInfo_NameAndType)pool[nameAndTypeIndex - 1];
nameAndType.resolve(pool);
deriveParameterCount();
}
public ByteCode_dup2(byte code,MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool,int depth)
: base(code)
{
name = "dup2";
size = 1;
this.depth = depth;
}
public MethodInfo ReadMethodInfo(ConstantPoolInfo constantPool, uint index)
{
MethodInfo result = new MethodInfo(index);
uint paramCount = ReadU30();
result.ReturnType = constantPool.GetMultinameAt(ReadU30());
result.ParamTypeArray = (from n in ReadU30Array(paramCount) select constantPool.GetMultinameAt(n)).ToArray();
result.Name = constantPool.GetStringAt(ReadU30());
result.Flags = (MethodFlags)ReadByte();
if (result.Flags.HasFlag(MethodFlags.HAS_OPTIONAL))
{
result.OptionalParamArray = new OptionalParam[ReadU30()];
for (int i = 0; i < result.OptionalParamArray.Length; i++)
{
result.OptionalParamArray[i] = new OptionalParam();
result.OptionalParamArray[i].Value = ReadU30();
result.OptionalParamArray[i].Kind = (ValueKind)ReadByte();
}
}
if (result.Flags.HasFlag(MethodFlags.HAS_PARAM_NAMES))
{
result.ParamNameArray = ReadU30Array(paramCount);
}
return(result);
}
public ByteCode_lload(byte code,MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool,int index)
: base(code)
{
name = "lload_" + index;
size = 1;
this.index = index;
}
public ByteCode_if(byte code,MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool,string op)
: base(code)
{
name = "if" + op;
size = 3;
branch = (short)reader.ReadUInt16();
if (op.Equals("null")){
opval = OP_NULL;
}
else if (op.Equals("nonnull")){
opval = OP_NOTNULL;
}
else if (op.Equals("eq")){
opval = OP_EQUALS;
}
else if (op.Equals("ge")){
opval = OP_GE;
}
else if (op.Equals("gt")){
opval = OP_G;
}
else if (op.Equals("ne")){
opval = OP_NE;
}
else if (op.Equals("lt")){
opval = OP_LT;
}
else if (op.Equals("le")){
opval = OP_LE;
}
}
int index; // which thing are we loading
#endregion Fields
#region Constructors
public ByteCode_lload(byte code,MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool)
: base(code)
{
size = 2;
this.index = reader.ReadByte();
name = "lload " + index;
}
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 CodeAttribute(ConstantPoolInfo_UTF8 utf8Name, MSBBinaryReaderWrapper reader, ConstantPoolInfo[] pool)
: base(utf8Name,reader,pool)
{
//
// TODO: Add constructor logic here
//
}
public ByteCode_sipush(byte code,MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool)
: base(code)
{
name = "sipush";
value = reader.ReadUInt16();
size = 3;
}
public ByteCode_jsr(byte code,MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool)
: base(code)
{
name = "jsr";
size = 3;
branch = (short)reader.ReadUInt16();
}
int index; // which thing are we loading
#endregion Fields
#region Constructors
public ByteCode_lstore(byte code,MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool)
: base(code)
{
size = 2;
index = reader.ReadByte();
name = "lstore_" + index;
}
public ByteCode_bipush(byte code,MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool)
: base(code)
{
name = "bipush";
value = reader.ReadByte();
size = 2;
}
public ByteCode_new(byte code,MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool)
: base(code)
{
name = "new";
size = 3; // 2 bytes defining index into operand pool
classIndex = reader.ReadUInt16();
classRef = (ConstantPoolInfo_Class)pool[classIndex - 1];
}
public ConstantPoolInfo ReadConstantPoolInfo()
{
ConstantPoolInfo result = new ConstantPoolInfo();
result.IntArrayCapacity = ReadU30();
for (uint i = 1; i < result.IntArrayCapacity; i++)
{
result.SetIntAt(ReadS32(), i);
}
result.UIntArrayCapacity = ReadU30();
for (uint i = 1; i < result.UIntArrayCapacity; i++)
{
result.SetUIntAt(ReadU30(), i);
}
result.DoubleArrayCapacity = ReadU30();
for (uint i = 1; i < result.DoubleArrayCapacity; i++)
{
result.SetDoubleAt(ReadDouble(), i);
}
result.StringArrayCapacity = ReadU30();
for (uint i = 1; i < result.StringArrayCapacity; i++)
{
result.SetStringAt(new StringInfo(i, ReadString()), i);
}
result.NamespaceArrayCapacity = ReadU30();
for (uint i = 1; i < result.NamespaceArrayCapacity; i++)
{
NamespaceInfo namespaceInfo = new NamespaceInfo(result, i);
namespaceInfo.Kind = (NamespaceKind)ReadByte();
namespaceInfo.Name = result.GetStringAt(ReadU30());
result.SetNamespaceAt(namespaceInfo, i);
}
result.NamespaceSetArrayCapacity = ReadU30();
for (uint i = 1; i < result.NamespaceSetArrayCapacity; i++)
{
NamespaceSetInfo namespaceSetInfo = new NamespaceSetInfo(i);
namespaceSetInfo.NamespaceArray = new NamespaceInfo[ReadU30()];
for (int j = 0; j < namespaceSetInfo.NamespaceArray.Length; j++)
{
namespaceSetInfo.NamespaceArray[j] = result.GetNamespaceAt(ReadU30());
}
result.SetNamespaceSetAt(namespaceSetInfo, i);
}
result.MultinameArrayCapacity = ReadU30();
for (uint i = 1; i < result.MultinameArrayCapacity; i++)
{
result.SetMultinameAt(ReadMultinameInfo(result, i), i);
}
return(result);
}
public ByteCode_invokespecial(byte code,MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool)
: base(code)
{
name = "invokespecial";
size = 3; // 2 bytes defining index into operand pool
UInt16 methodIndex = reader.ReadUInt16();
method = (ConstantPoolInfo_MethodRef)pool[methodIndex - 1];
}
public ByteCode_fcmp(byte code,MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool, string op)
: base(code)
{
name = "fcmp"+op;
size = 1;
if ("l".Equals(op)) { opval = OP_LESS; }
if ("g".Equals(op)) { opval = OP_GREATER; }
}
public ByteCode_anewarray(byte code,MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool)
: base(code)
{
name = "anewarray";
size = 3; // 2 bytes defining index into operand pool
UInt16 fieldIndex = reader.ReadUInt16();
reference = (ConstantPoolInfo_Class)pool[fieldIndex - 1];
}
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 ByteCode_putstatic(byte code,MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool)
: base(code)
{
name = "putstatic";
size = 3; // 2 bytes defining index into operand pool
UInt16 fieldIndex = reader.ReadUInt16();
field = (ConstantPoolInfo_FieldRef)pool[fieldIndex - 1];
}
public void SetValue(As3Instruction ins, ConstantPoolInfo cPool = null)
{
switch (ins.Opcode)
{
case Opcode.PushTrue:
ValueKind = Types.ValueKind.True;
ValueIndex = 0;
break;
case Opcode.PushFalse:
ValueKind = Types.ValueKind.False;
ValueIndex = 0;
break;
case Opcode.PushString:
ValueKind = Types.ValueKind.Utf8;
ValueIndex = (ins as As3PushString).String.Index;
break;
case Opcode.PushShort:
ValueKind = Types.ValueKind.Int;
int pushShortValue = (ins as As3PushShort).Short;
uint intIndex = cPool.IndexOfInt(pushShortValue);
if (intIndex == 0)
{
ValueIndex = cPool.AddIntAtEnd(pushShortValue);
}
else
{
ValueIndex = intIndex;
}
break;
case Opcode.PushByte:
ValueKind = Types.ValueKind.Int;
sbyte pushByte = (ins as As3PushByte).Byte;
uint byteIndex = cPool.IndexOfInt(pushByte);
if (byteIndex == 0)
{
ValueIndex = cPool.AddIntAtEnd(pushByte);
}
else
{
ValueIndex = byteIndex;
}
break;
case Opcode.PushDouble:
ValueKind = Types.ValueKind.Double;
ValueIndex = (ins as As3PushDouble).DoubleIndex;
break;
default:
throw new Exception();
}
}
public MultinameInfo ReadMultinameInfo(ConstantPoolInfo constantPool, uint index)
{
MultinameInfo result = new MultinameInfo(index);
result.Kind = (MultinameKind)ReadByte();
switch (result.Kind)
{
case MultinameKind.QName:
case MultinameKind.QNameA:
var mkQName = new MKQName();
mkQName.Namespace = constantPool.GetNamespaceAt(ReadU30());
mkQName.Name = constantPool.GetStringAt(ReadU30());
result.Data = mkQName;
break;
case MultinameKind.RTQName:
case MultinameKind.RTQNameA:
var mkRtkName = new MKRTQName();
mkRtkName.Name = constantPool.GetStringAt(ReadU30());
result.Data = mkRtkName;
break;
case MultinameKind.RTQNameL:
case MultinameKind.RTQNameLA:
var mkRtqNameL = new MKRTQNameL();
result.Data = mkRtqNameL;
break;
case MultinameKind.Multiname:
case MultinameKind.MultinameA:
var mkMultiname = new MKMultiname();
mkMultiname.Name = constantPool.GetStringAt(ReadU30());
mkMultiname.NamespaceSet = constantPool.GetNamespaceSetAt(ReadU30());
result.Data = mkMultiname;
break;
case MultinameKind.MultinameL:
case MultinameKind.MultinameLA:
var mkMultinameL = new MKMultinameL();
mkMultinameL.NamespaceSet = constantPool.GetNamespaceSetAt(ReadU30());
result.Data = mkMultinameL;
break;
case MultinameKind.GenericName:
var mkGenericName = new MKGenericName(constantPool);
mkGenericName.TypeDefinitionIndex = ReadU30();
mkGenericName.ParamArrayIndexes = ReadU30Array(ReadU30());
result.Data = mkGenericName;
break;
default:
throw new Exception();
}
return(result);
}
public ByteCode_instanceof(byte code,MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool)
: base(code)
{
name = "instanceof";
size = 3; // 2 bytes defining index into operand pool
UInt16 methodIndex = reader.ReadUInt16();
clazz = (ConstantPoolInfo_Class)pool[methodIndex - 1];
className = clazz.getClassName();
}
public ByteCode_ldc_w(byte code,MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool)
: base(code)
{
name = "ldc_w";
size = 3;
UInt16 index = reader.ReadUInt16();
reference = pool[index - 1];
}
public ByteCode_pop(byte code,MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool,int num)
: base(code)
{
name = "pop";
if (num == 2){
name = "pop2";
}
size = 1;
this.count = num;
}
public ByteCode_ldc(byte code,MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool)
: base(code)
{
name = "ldc";
size = 2;
byte index = reader.ReadByte();
reference = pool[index - 1];
}
int index; // which thing are we loading
#endregion Fields
#region Constructors
public ByteCode_iinc(byte code,MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool)
: base(code)
{
size = 3;
index = reader.ReadByte();
constant = reader.getReader().ReadSByte();
name = "iinc";
}
public MetadataInfo ReadMetadataInfo(ConstantPoolInfo constantPool)
{
MetadataInfo result = new MetadataInfo();
result.Name = ReadU30();
uint count = ReadU30();
result.KeyArray = (from n in ReadU30Array(count) select constantPool.GetStringAt(n)).ToArray();
result.ValueArray = (from n in ReadU30Array(count) select constantPool.GetStringAt(n)).ToArray();
return(result);
}
public ByteCode_ldc2_w(byte code,MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool)
: base(code)
{
name = "ldc2_w";
size = 3;
UInt16 index = reader.ReadUInt16();
// if (log.IsDebugEnabled) log.DebugFormat("Index is {0}",index);
reference = pool[index - 1];
}
public Abc()
{
MajorVersion = 46;
MinorVersion = 16;
ConstantPool = new ConstantPoolInfo();
MethodArray = new MethodInfo[0];
MetadataArray = new MetadataInfo[0];
AbcClassArray = new AbcClass[0];
ScriptArray = new ScriptInfo[0];
MethodBodyArray = new MethodBodyInfo[0];
}
public ByteCode_invokeinterface(byte code,MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool)
: base(code)
{
name = "invokeinterface";
size = 5; // 2 bytes defining index into operand pool
UInt16 methodIndex = reader.ReadUInt16();
reader.ReadByte(); // count - unused
reader.ReadByte(); // 0;
method = (ConstantPoolInfo_InterfaceMethodRef)pool[methodIndex - 1];
}
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 ByteCode_goto(byte code,MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool)
: base(code)
{
name = "goto";
size = 3;
UInt16 temp = reader.ReadUInt16();
if ((temp & 0x8000) != 0){
branch = (-65536) + (temp);
}
else {
branch = (int) temp;
}
}
public void WriteConstantPool(ConstantPoolInfo value)
{
WriteU30(value.IntArrayLength);
for (uint i = 1; i < value.IntArrayLength; i++)
{
WriteS32(value.GetIntAt(i));
}
WriteU30(value.UIntArrayLength);
for (uint i = 1; i < value.UIntArrayLength; i++)
{
WriteU30(value.GetUIntAt(i));
}
WriteU30(value.DoubleArrayLength);
for (uint i = 1; i < value.DoubleArrayLength; i++)
{
WriteDouble(value.GetDoubleAt(i));
}
WriteU30(value.StringArrayLength);
for (uint i = 1; i < value.StringArrayLength; i++)
{
StringInfo stringInfo = value.GetStringAt(i);
WriteString(stringInfo);
}
WriteU30(value.NamespaceArrayLength);
for (uint i = 1; i < value.NamespaceArrayLength; i++)
{
var namespaceInfo = value.GetNamespaceAt(i);
WriteByte((Byte)namespaceInfo.Kind);
WriteU30(namespaceInfo.Name?.Index ?? 0);
}
WriteU30(value.NamespaceSetArrayLength);
for (uint i = 1; i < value.NamespaceSetArrayLength; i++)
{
WriteU30Array((from n in value.GetNamespaceSetAt(i).NamespaceArray select n.Index).ToArray(), true);
}
WriteU30(value.MultinameArrayLength);
for (uint i = 1; i < value.MultinameArrayLength; i++)
{
WriteMultinameInfo(value.GetMultinameAt(i));
}
}
public ByteCode_if_acmp(byte code,MSBBinaryReaderWrapper reader,ConstantPoolInfo[] pool,string op)
: base(code)
{
name = "if_acmp" + op;
size = 3;
branch = reader.ReadUInt16();
if (op.Equals("ne")){
opval = OP_NE;
}
else if (op.Equals("eq")){
opval = OP_EQ;
}
}
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 object GetValue(ConstantPoolInfo constantPoolInfo)
{
object result;
switch (ValueKind)
{
case ValueKind.Int:
result = constantPoolInfo.GetIntAt(ValueIndex);
break;
case ValueKind.UInt:
result = constantPoolInfo.GetUIntAt(ValueIndex);
break;
case ValueKind.Double:
result = constantPoolInfo.GetDoubleAt(ValueIndex);
break;
case ValueKind.Utf8:
result = '"' + constantPoolInfo.GetStringAt(ValueIndex) + '"';
break;
case ValueKind.False:
result = "false";
break;
case ValueKind.True:
result = "true";
break;
case ValueKind.Null:
result = "null";
break;
case ValueKind.Undefined:
result = "undefined";
break;
default:
throw new ArgumentOutOfRangeException();
}
return(result);
}
public object GetValue(ConstantPoolInfo cPool = null)
{
return("undefined");
}
public object GetValue(ConstantPoolInfo cPool)
{
return(Short);
}
public object GetValue(ConstantPoolInfo cPool = null)
{
return(null);
}
public object GetValue(ConstantPoolInfo cPool)
{
return(cPool.GetDoubleAt(DoubleIndex));
}
public object GetValue(ConstantPoolInfo cPool)
{
return(cPool.GetUIntAt(UIntIndex));
}
public MultinameData(ConstantPoolInfo cPool)
{
_cPool = cPool;
}
public object GetValue(ConstantPoolInfo cPool)
{
return(String.String);
}
private ConstantPoolInfo[] ParseConstantPool(ref ReadOnlySpan <byte> fileData)
{
ushort poolCount = fileData.ReadTwoBytes();
var infos = new ConstantPoolInfo[poolCount];
for (int i = 1; i < poolCount; i++)
{
var tag = (ConstantPoolTag)fileData.ReadOneByte();
switch (tag)
{
case ConstantPoolTag.Class:
infos[i] = new ClassInfo(ref fileData);
break;
case ConstantPoolTag.Fieldref:
infos[i] = new FieldrefInfo(ref fileData);
break;
case ConstantPoolTag.Methodref:
infos[i] = new MethodrefInfo(ref fileData);
break;
case ConstantPoolTag.InterfaceMethodref:
infos[i] = new InterfaceMethodrefInfo(ref fileData);
break;
case ConstantPoolTag.String:
infos[i] = new StringInfo(ref fileData);
break;
case ConstantPoolTag.Integer:
infos[i] = new IntegerInfo(ref fileData);
break;
case ConstantPoolTag.Float:
infos[i] = new FloatInfo(ref fileData);
break;
case ConstantPoolTag.Long:
infos[i] = new LongInfo(ref fileData);
i++;
break;
case ConstantPoolTag.Double:
infos[i] = new DoubleInfo(ref fileData);
i++;
break;
case ConstantPoolTag.NameAndType:
infos[i] = new NameAndTypeInfo(ref fileData);
break;
case ConstantPoolTag.Utf8:
infos[i] = new Utf8Info(ref fileData);
break;
case ConstantPoolTag.MethodHandle:
fileData.ReadOneByte();
fileData.ReadTwoBytes();
break;
case ConstantPoolTag.MethodType:
fileData.ReadTwoBytes();
break;
case ConstantPoolTag.InvokeDynamic:
fileData.ReadFourBytes();
break;
default:
throw new InvalidDataException();
}
}
foreach (ConstantPoolInfo info in infos)
{
info?.Init(infos);
}
return(infos);
}
public object GetValue(ConstantPoolInfo cPool = null)
{
return(double.NaN);
}
public MKQName(ConstantPoolInfo cPool)
: base(cPool)
{
Namespace = _cPool.GetNamespaceAt(1);
Name = _cPool.GetStringAt(1);
}
public As3Instruction GetPushInstruction(ConstantPoolInfo cPool)
{
if (ValueIndex != 0)
{
switch (ValueKind)
{
case ValueKind.Double:
double doubleValue = (double)GetValue(cPool);
if (doubleValue % 1 == 0)
{
if (doubleValue >= sbyte.MinValue && doubleValue <= sbyte.MaxValue)
{
return(new As3PushByte((sbyte)doubleValue));
}
else if (doubleValue >= short.MinValue && doubleValue <= short.MaxValue)
{
return(new As3PushShort((uint)doubleValue));
}
}
return(new As3PushDouble(ValueIndex));
case ValueKind.Utf8:
return(new As3PushString(cPool.GetStringAt(ValueIndex)));
case ValueKind.UInt:
uint uintValue = (uint)GetValue(cPool);
if (uintValue % 1 == 0)
{
if (uintValue <= sbyte.MaxValue)
{
return(new As3PushByte((sbyte)uintValue));
}
else if (uintValue <= short.MaxValue)
{
return(new As3PushShort((uint)uintValue));
}
}
return(new As3PushUInt(ValueIndex));
case ValueKind.Int:
int intValue = (int)GetValue(cPool);
if (intValue % 1 == 0)
{
if (intValue >= sbyte.MinValue && intValue <= sbyte.MaxValue)
{
return(new As3PushByte((sbyte)intValue));
}
else if (intValue >= short.MinValue && intValue <= short.MaxValue)
{
return(new As3PushShort((uint)intValue));
}
}
return(new As3PushInt(ValueIndex));
case ValueKind.True:
return(new As3PushTrue());
case ValueKind.False:
return(new As3PushFalse());
case ValueKind.Undefined:
return(new As3PushUndefined());
}
}
throw new Exception();
}
public MKGenericName(ConstantPoolInfo cPool)
: base(cPool)
{
TypeDefinitionIndex = 1;
ParamArrayIndexes = new uint[0];
}
public ushort Add(ConstantPoolInfo NewItem)
{
FItems.Add(NewItem);
FMaxItems++;
return (ushort)(FItems.Count - 1);
}
public void Write(BinaryWriter Writer)
{
// i am assuming we have a valid constant pool list...
// i dont do any error checking here except bare minimum!
// write the number of constant pool entries
Common.WriteWord(Writer, FMaxItems + 1);
int count = 0;
// goes from 1 -> constantpoolcount - 1
while (count < FMaxItems)
{
ConstantPoolInfo Item = (ConstantPoolInfo)FItems[count];
switch (Item.Tag)
{
case (byte)ConstantPoolInfoTag.ConstantClass:
{
ConstantClassInfo cc = (ConstantClassInfo)Item;
cc.Write(Writer);
break;
}
case (byte)ConstantPoolInfoTag.ConstantString:
{
ConstantStringInfo cc = (ConstantStringInfo)Item;
cc.Write(Writer);
break;
}
case (byte)ConstantPoolInfoTag.ConstantFieldref:
{
ConstantFieldrefInfo cc = (ConstantFieldrefInfo)Item;
cc.Write(Writer);
break;
}
case (byte)ConstantPoolInfoTag.ConstantMethodref:
{
ConstantMethodrefInfo cc = (ConstantMethodrefInfo)Item;
cc.Write(Writer);
break;
}
case (byte)ConstantPoolInfoTag.ConstantInterfaceMethodref:
{
ConstantInterfaceMethodrefInfo cc = (ConstantInterfaceMethodrefInfo)Item;
cc.Write(Writer);
break;
}
case (byte)ConstantPoolInfoTag.ConstantInteger:
{
ConstantIntegerInfo cc = (ConstantIntegerInfo)Item;
cc.Write(Writer);
break;
}
case (byte)ConstantPoolInfoTag.ConstantFloat:
{
ConstantFloatInfo cc = (ConstantFloatInfo)Item;
cc.Write(Writer);
break;
}
case (byte)ConstantPoolInfoTag.ConstantLong:
{
ConstantLongInfo cc = (ConstantLongInfo)Item;
cc.Write(Writer);
// longs take up two entries in the pool table
count++;
break;
}
case (byte)ConstantPoolInfoTag.ConstantDouble:
{
ConstantDoubleInfo cc = (ConstantDoubleInfo)Item;
cc.Write(Writer);
// so do doubles
count++;
break;
}
case (byte)ConstantPoolInfoTag.ConstantNameAndType:
{
ConstantNameAndTypeInfo cc = (ConstantNameAndTypeInfo)Item;
cc.Write(Writer);
break;
}
case (byte)ConstantPoolInfoTag.ConstantUtf8:
{
ConstantUtf8Info cc = (ConstantUtf8Info)Item;
cc.Write(Writer);
break;
}
default:
// fail safe ?
// BADDDDDDDDDDDDDDDDDDDDD, prolly should check/fix this
count++;
break;
}
count++;
}
}
public MKMultiname(ConstantPoolInfo cPool)
: base(cPool)
{
Name = cPool.GetStringAt(1);
NamespaceSet = cPool.GetNamespaceSetAt(1);
}
public object GetValue(ConstantPoolInfo cPool)
{
throw new System.NotImplementedException();
}
public MKRTQName(ConstantPoolInfo cPool)
: base(cPool)
{
Name = _cPool.GetStringAt(1);
}
public MKRTQNameL(ConstantPoolInfo cPool)
: base(cPool)
{
}
private void UpdateTree()
{
TreeClassView.Nodes.Clear();
DeObfuscator = new TDeObfuscator(Files);
foreach (string fn in Files)
{
TClassFile ClassFile = new TClassFile(fn);
if (!ClassFile.Open())
{
TreeClassView.Nodes.Add("Invalid class file: " + fn);
continue;
}
if (ClassFile != null)
{
TreeNode bigroot;
// check if the user wants to rename the class file
string original_class_name = ClassFile.ThisClassName + " : " + ClassFile.SuperClassName;
string class_name = RenameStore.GetNewClassName(original_class_name);
if (class_name == null)
{
class_name = original_class_name;
bigroot = TreeClassView.Nodes.Add(class_name);
}
else
{
bigroot = TreeClassView.Nodes.Add(class_name);
bigroot.BackColor = Color.DodgerBlue;
}
bigroot.Tag = original_class_name;
TreeNode root = bigroot.Nodes.Add("Constants");
TreeNode methodsroot = root.Nodes.Add("Methods/Interfaces/Fields");
TreeNode methods = methodsroot.Nodes.Add("Methods");
TreeNode interfaces = methodsroot.Nodes.Add("Interfaces");
TreeNode fields = methodsroot.Nodes.Add("Fields");
TreeNode variables = root.Nodes.Add("Values");
TreeNode classes = root.Nodes.Add("Classes");
for (int i = 0; i < ClassFile.ConstantPool.MaxItems(); i++)
{
ConstantPoolInfo cc = ClassFile.ConstantPool.Item(i);
if (cc is ConstantPoolMethodInfo)
{
if (cc is ConstantMethodrefInfo)
{
TreeNode temp = methods.Nodes.Add("\"" + ((ConstantMethodrefInfo)cc).NameAndType.Name + "\"");
temp.Nodes.Add("Descriptor = " + ((ConstantMethodrefInfo)cc).NameAndType.Descriptor);
temp.Nodes.Add("Parent = " + ((ConstantMethodrefInfo)cc).ParentClass.Name);
if (DeObfuscator.DoRename(((ConstantMethodrefInfo)cc).NameAndType.Name))
{
temp.BackColor = Color.Red;
}
continue;
}
if (cc is ConstantInterfaceMethodrefInfo)
{
TreeNode temp = interfaces.Nodes.Add("\"" + ((ConstantInterfaceMethodrefInfo)cc).NameAndType.Name + "\"");
temp.Nodes.Add("Descriptor = " + ((ConstantInterfaceMethodrefInfo)cc).NameAndType.Descriptor);
temp.Nodes.Add("Parent = " + ((ConstantInterfaceMethodrefInfo)cc).ParentClass.Name);
if (DeObfuscator.DoRename(((ConstantInterfaceMethodrefInfo)cc).NameAndType.Name))
{
temp.BackColor = Color.Red;
}
continue;
}
if (cc is ConstantFieldrefInfo)
{
TreeNode temp = fields.Nodes.Add("\"" + ((ConstantFieldrefInfo)cc).NameAndType.Name + "\"");
temp.Nodes.Add("Descriptor = " + ((ConstantFieldrefInfo)cc).NameAndType.Descriptor);
if (((ConstantFieldrefInfo)cc).ParentClass != null)
{
temp.Nodes.Add("Parent = " + ((ConstantFieldrefInfo)cc).ParentClass.Name);
}
if (DeObfuscator.DoRename(((ConstantFieldrefInfo)cc).NameAndType.Name))
{
temp.BackColor = Color.Red;
}
continue;
}
}
else
if (cc is ConstantPoolVariableInfo)
{
TreeNode temp = variables.Nodes.Add("\"" + ((ConstantPoolVariableInfo)cc).Value.ToString() + "\"");
temp.Nodes.Add("References = " + cc.References);
}
else
if (cc is ConstantClassInfo)
{
TreeNode temp = classes.Nodes.Add("\"" + ((ConstantClassInfo)cc).Name + "\"");
temp.Nodes.Add("References = " + cc.References);
}
}
root = bigroot.Nodes.Add("Interfaces");
foreach (InterfaceInfo ii in ClassFile.Interfaces.Items)
{
root.Nodes.Add(ii.Interface.Name);
}
root = bigroot.Nodes.Add("Fields");
foreach (FieldInfo fi in ClassFile.Fields.Items)
{
RenameData rd = RenameStore.GetNewFieldInfo(
original_class_name,
fi.Descriptor,
fi.Name.Value);
if (rd != null)
{
TreeNode temp = root.Nodes.Add(rd.FieldName);
temp.Nodes.Add(rd.FieldType);
temp.BackColor = Color.DodgerBlue;
}
else
{
TreeNode temp = root.Nodes.Add(fi.Name.Value);
temp.Nodes.Add(fi.Descriptor);
temp.Tag = fi.Name.Value;
if (DeObfuscator.DoRename(fi.Name.Value))
{
temp.BackColor = Color.Red;
}
}
}
root = bigroot.Nodes.Add("Methods");
foreach (MethodInfo mi in ClassFile.Methods.Items)
{
RenameData rd = RenameStore.GetNewMethodInfo(
original_class_name,
mi.Descriptor,
mi.Name.Value);
if (rd != null)
{
TreeNode temp = root.Nodes.Add(rd.FieldName);
temp.Nodes.Add(rd.FieldType);
temp.BackColor = Color.DodgerBlue;
}
else
{
TreeNode temp = root.Nodes.Add(mi.Name.Value);
temp.Nodes.Add(mi.Descriptor);
temp.Tag = mi.Name.Value;
//temp.Nodes.Add(String.Format("Offset = {0:X}", mi.Offset));
if (DeObfuscator.DoRename(mi.Name.Value))
{
temp.BackColor = Color.Red;
}
}
}
}
}
}
public Words(ConstantPoolInfo constantPool)
{
this.constantPool = constantPool;
}
