public ASNamespaceSet(ABCFile abc, FlashReader reader)
: this(abc)
{
NamespaceIndices.Capacity = reader.Read7BitEncodedInt();
for (int i = 0; i < NamespaceIndices.Capacity; i++)
NamespaceIndices.Add(reader.Read7BitEncodedInt());
}
public SlotConstantTrait(ABCFile abc, string objName, TraitType traitType)
{
_abc = abc;
ObjName = objName;
TraitType = traitType;
}
public MethodGetterSetterTrait(ABCFile abc, string objName, TraitType traitType)
{
_abc = abc;
ObjName = objName;
TraitType = traitType;
}
public Typename(ABCFile abc, FlashReader reader)
: this(abc)
{
TypeIndex = reader.Read7BitEncodedInt();
ParameterTypeIndices.Capacity = reader.Read7BitEncodedInt();
for (int i = 0; i < ParameterTypeIndices.Capacity; i++)
ParameterTypeIndices.Add(reader.Read7BitEncodedInt());
}
public ASTrait(ABCFile abc, FlashReader reader)
{
_abc = abc;
NameIndex = reader.Read7BitEncodedInt();
byte trueKind = reader.ReadByte();
var traitType = (TraitType)(trueKind & 0xF);
Attributes = (TraitAttributes)(trueKind >> 4);
#region Trait Reading
switch (traitType)
{
case TraitType.Slot:
case TraitType.Constant:
Data = new SlotConstantTrait(abc, reader, Name.ObjName, traitType);
break;
case TraitType.Method:
case TraitType.Getter:
case TraitType.Setter:
{
var mgsTrait = new MethodGetterSetterTrait(abc, reader, Name.ObjName, traitType);
mgsTrait.Method.ObjName = Name.ObjName;
Data = mgsTrait;
break;
}
case TraitType.Class:
{
var classTrait = new ClassTrait(abc, reader, Name.ObjName);
// TODO: Link trait information?
Data = classTrait;
break;
}
case TraitType.Function:
{
var functionTrait = new FunctionTrait(abc, reader, Name.ObjName);
// TODO: Link trait information?
Data = functionTrait;
break;
}
default:
throw new Exception("Invalid trait: " + TraitType);
}
#endregion
MetadataIndices = new List<int>();
if ((Attributes & TraitAttributes.Metadata) != 0)
MetadataIndices.Capacity = reader.Read7BitEncodedInt();
for (int i = 0; i < MetadataIndices.Capacity; i++)
MetadataIndices.Add(reader.Read7BitEncodedInt());
}
public ASException(ABCFile abc, FlashReader reader)
{
_abc = abc;
From = reader.Read7BitEncodedInt();
To = reader.Read7BitEncodedInt();
Target = reader.Read7BitEncodedInt();
ExceptionTypeIndex = reader.Read7BitEncodedInt();
VariableNameIndex = reader.Read7BitEncodedInt();
}
public MultinameL(ABCFile abc, ConstantType multinameType)
{
if (multinameType == ConstantType.MultinameL ||
multinameType == ConstantType.MultinameLA)
{
ABC = abc;
MultinameType = multinameType;
}
else throw new Exception($"Invalid {nameof(MultinameL)} type: " + multinameType);
}
public ASClass(ABCFile abc, FlashReader reader)
{
_abc = abc;
ConstructorIndex = reader.Read7BitEncodedInt();
Traits = new List<ASTrait>(reader.Read7BitEncodedInt());
for (int i = 0; i < Traits.Capacity; i++)
Traits.Add(new ASTrait(abc, reader));
}
public SlotConstantTrait(ABCFile abc, FlashReader reader, string objName, TraitType traitType)
: this(abc, objName, traitType)
{
SlotId = reader.Read7BitEncodedInt();
TypeIndex = reader.Read7BitEncodedInt();
ValueIndex = reader.Read7BitEncodedInt();
if (ValueIndex != 0)
ValueType = (ConstantType)reader.ReadByte();
}
public RTQName(ABCFile abc, ConstantType multinameType)
{
if (multinameType == ConstantType.RTQName ||
multinameType == ConstantType.RTQNameA)
{
ABC = abc;
MultinameType = multinameType;
}
else throw new Exception($"Invalid {nameof(RTQName)} type: " + multinameType);
}
public ASScript(ABCFile abc, FlashReader reader)
{
_abc = abc;
FunctionIndex =
reader.Read7BitEncodedInt();
Traits = new List<ASTrait>(reader.Read7BitEncodedInt());
for (int i = 0; i < Traits.Capacity; i++)
Traits.Add(new ASTrait(abc, reader));
}
public DoABCTag(FlashReader reader, TagRecord header)
: base(reader, header)
{
Flags = reader.ReadUInt32();
Name = reader.ReadNullTerminatedString();
int nameLength = (Encoding.UTF8.GetByteCount(Name) + 1);
byte[] abcData = reader.ReadBytes(header.Body.Length - (nameLength + 4));
ABC = new ABCFile(abcData);
}
public ASMultiname(ABCFile abc, FlashReader reader)
: this(abc)
{
var multinameType = (ConstantType)reader.ReadByte();
switch (multinameType)
{
case ConstantType.QName:
case ConstantType.QNameA:
{
var qName = new QName(abc, reader, multinameType);
ObjNameIndex = qName.ObjNameIndex;
Data = qName;
break;
}
case ConstantType.RTQName:
case ConstantType.RTQNameA:
{
var rtqName = new RTQName(abc, reader, multinameType);
ObjNameIndex = rtqName.ObjNameIndex;
Data = rtqName;
break;
}
case ConstantType.RTQNameL:
case ConstantType.RTQNameLA:
Data = new RTQNameL(abc, multinameType);
break;
case ConstantType.Multiname:
case ConstantType.MultinameA:
{
var multiname = new Multiname(abc, reader, multinameType);
ObjNameIndex = multiname.ObjNameIndex;
Data = multiname;
break;
}
case ConstantType.MultinameL:
case ConstantType.MultinameLA:
Data = new MultinameL(abc, reader, multinameType);
break;
case ConstantType.Typename:
Data = new Typename(abc, reader);
break;
default:
throw new Exception("Invalid multiname: " + multinameType);
}
}
public ASMetadata(ABCFile abc, FlashReader reader)
{
_abc = abc;
NameIndex = reader.Read7BitEncodedInt();
int itemInfoCount = reader.Read7BitEncodedInt();
Elements = new Dictionary<int, int>(itemInfoCount);
for (int i = 0; i < itemInfoCount; i++)
{
Elements.Add(reader.Read7BitEncodedInt(),
reader.Read7BitEncodedInt());
}
}
public ASMethod(ABCFile abc, int returnTypeIndex, IList<ASParameter> parameters) :
this(abc, returnTypeIndex)
{
Parameters.AddRange(parameters);
if (Parameters.Count > 0)
{
ASParameter lastParameter =
Parameters[(Parameters.Count) - 1];
if (lastParameter.NameIndex != 0)
MethodInfo |= MethodFlags.HasParamNames;
if (lastParameter.IsOptional)
MethodInfo |= MethodFlags.HasOptional;
}
}
public ASInstance(ABCFile abc, FlashReader reader)
{
_abc = abc;
NameIndex = reader.Read7BitEncodedInt();
SuperNameIndex = reader.Read7BitEncodedInt();
ClassInfo = (ClassFlags)reader.ReadByte();
if ((ClassInfo & ClassFlags.ProtectedNamespace) != 0)
ProtectedNamespaceIndex = reader.Read7BitEncodedInt();
InterfaceIndices = new List<int>(reader.Read7BitEncodedInt());
for (int i = 0; i < InterfaceIndices.Capacity; i++)
InterfaceIndices.Add(reader.Read7BitEncodedInt());
ConstructorIndex = reader.Read7BitEncodedInt();
Traits = new List<ASTrait>(reader.Read7BitEncodedInt());
for (int i = 0; i < Traits.Capacity; i++)
Traits.Add(new ASTrait(abc, reader));
}
public ASMethodBody(ABCFile abc, FlashReader reader)
{
_abc = abc;
MethodIndex = reader.Read7BitEncodedInt();
MaxStack = reader.Read7BitEncodedInt();
LocalCount = reader.Read7BitEncodedInt();
InitialScopeDepth = reader.Read7BitEncodedInt();
MaxScopeDepth = reader.Read7BitEncodedInt();
Code = new ASCode(abc, this,
reader.ReadBytes(reader.Read7BitEncodedInt()));
Exceptions = new List<ASException>(reader.Read7BitEncodedInt());
for (int i = 0; i < Exceptions.Capacity; i++)
Exceptions.Add(new ASException(abc, reader));
Traits = new List<ASTrait>(reader.Read7BitEncodedInt());
for (int i = 0; i < Traits.Capacity; i++)
Traits.Add(new ASTrait(abc, reader));
Method.Body = this;
}
public ASMethod(ABCFile abc, FlashReader reader)
{
_abc = abc;
Parameters = new List<ASParameter>(reader.Read7BitEncodedInt());
ReturnTypeIndex = reader.Read7BitEncodedInt();
for (int i = 0; i < Parameters.Capacity; i++)
{
int parameterTypeIndex = reader.Read7BitEncodedInt();
Parameters.Add(new ASParameter(abc, parameterTypeIndex));
}
NameIndex = reader.Read7BitEncodedInt();
MethodInfo = (MethodFlags)reader.ReadByte();
if ((MethodInfo & MethodFlags.HasOptional) != 0)
{
int optionalParamCount = reader.Read7BitEncodedInt();
while (optionalParamCount > 0)
{
int paramIndex = ((Parameters.Count - 1) - (--optionalParamCount));
ASParameter optionalParameter = Parameters[paramIndex];
optionalParameter.IsOptional = true;
optionalParameter.ValueIndex = reader.Read7BitEncodedInt();
optionalParameter.ValueType = (ConstantType)reader.ReadByte();
}
}
if ((MethodInfo & MethodFlags.HasParamNames) != 0)
{
foreach (ASParameter parameter in Parameters)
parameter.NameIndex = reader.Read7BitEncodedInt();
}
}
public ASClass(ABCFile abc, int constructorIndex) :
this(abc)
{
ConstructorIndex = constructorIndex;
}
public SetPropertyIns(ABCFile abc, int propertyNameIndex)
: this(abc)
{
PropertyNameIndex = propertyNameIndex;
}
public SetPropertyIns(ABCFile abc)
: base(OPCode.SetProperty, abc)
{
}
public QName(ABCFile abc, FlashReader reader)
: this(abc, reader, ConstantType.QName)
{
}
public CallPropVoidIns(ABCFile abc, int propertyNameIndex, int argCount)
: this(abc)
{
PropertyNameIndex = propertyNameIndex;
ArgCount = argCount;
}
public CoerceIns(ABCFile abc)
: base(OPCode.Coerce, abc)
{
}
public CallSuperIns(ABCFile abc, FlashReader input)
: this(abc)
{
MethodNameIndex = input.ReadInt30();
ArgCount = input.ReadInt30();
}
public CallSuperIns(ABCFile abc)
: base(OPCode.CallSuper, abc)
{
}
private PacketValue[] GetIncomingStructure(ASInstance instance, ASMethod method)
{
if (method.Body.Exceptions.Count > 0)
{
return(null);
}
ASCode code = method.Body.ParseCode();
if (code.JumpExits.Count > 0 || code.SwitchExits.Count > 0)
{
return(null);
}
List <PacketValue> structure = new List <PacketValue>();
ABCFile abc = method.GetABC();
for (int i = 0; i < code.Count; i++)
{
ASInstruction instruction = code[i];
if (instruction.OP != OPCode.GetLocal_1)
{
continue;
}
ASInstruction next = code[++i];
switch (next.OP)
{
case OPCode.CallProperty:
{
CallPropertyIns callProperty = (CallPropertyIns)next;
if (callProperty.ArgCount > 0)
{
ASMultiname propertyName = null;
ASInstruction previous = code[i - 2];
switch (previous.OP)
{
case OPCode.GetLex:
{
GetLexIns getLex = (GetLexIns)previous;
propertyName = getLex.TypeName;
break;
}
case OPCode.ConstructProp:
{
ConstructPropIns constructProp = (ConstructPropIns)previous;
propertyName = constructProp.PropertyName;
break;
}
case OPCode.GetLocal_0:
{
propertyName = instance.QName;
break;
}
}
ASInstance innerInstance = abc.GetInstance(propertyName);
ASMethod innerMethod = innerInstance.GetMethod(callProperty.PropertyName.Name, null, callProperty.ArgCount);
if (innerMethod == null)
{
ASClass innerClass = abc.GetClass(propertyName);
innerMethod = innerClass.GetMethod(callProperty.PropertyName.Name, null, callProperty.ArgCount);
}
PacketValue[] innerStructure = GetIncomingStructure(innerInstance, innerMethod);
if (innerStructure == null)
{
return(null);
}
structure.AddRange(innerStructure);
}
else
{
if (!TryGetPacketValue(callProperty.PropertyName, null, out PacketValue piece))
{
return(null);
}
structure.Add(piece);
}
break;
}
case OPCode.ConstructProp:
{
ConstructPropIns constructProp = (ConstructPropIns)next;
ASInstance innerInstance = abc.GetInstance(constructProp.PropertyName);
PacketValue[] innerStructure = GetIncomingStructure(innerInstance, innerInstance.Constructor);
if (innerStructure == null)
{
return(null);
}
structure.AddRange(innerStructure);
break;
}
case OPCode.ConstructSuper:
{
ASInstance superInstance = abc.GetInstance(instance.Super);
PacketValue[] innerStructure = GetIncomingStructure(superInstance, superInstance.Constructor);
if (innerStructure == null)
{
return(null);
}
structure.AddRange(innerStructure);
break;
}
case OPCode.CallSuper:
{
CallSuperIns callSuper = (CallSuperIns)next;
ASInstance superInstance = abc.GetInstance(instance.Super);
ASMethod superMethod = superInstance.GetMethod(callSuper.MethodName.Name, null, callSuper.ArgCount);
PacketValue[] innerStructure = GetIncomingStructure(superInstance, superMethod);
if (innerStructure == null)
{
return(null);
}
structure.AddRange(innerStructure);
break;
}
case OPCode.CallPropVoid:
{
CallPropVoidIns callPropVoid = (CallPropVoidIns)next;
if (callPropVoid.ArgCount != 0)
{
return(null);
}
if (!TryGetPacketValue(callPropVoid.PropertyName, null, out PacketValue piece))
{
return(null);
}
structure.Add(piece);
break;
}
default: return(null);
}
}
return(structure.Count == 0 ? null : structure.ToArray());
}
private List <HReference> FindMessageReferences(ASClass fromClass, ASContainer fromContainer, ASMethod fromMethod)
{
int instructionRank = 0;
ABCFile abc = fromMethod.GetABC();
Stack <ASMultiname> nameStack = new Stack <ASMultiname>();
List <HReference> references = new List <HReference>();
ASContainer container = null;
ASCode code = fromMethod.Body.ParseCode();
for (int i = 0; i < code.Count; i++)
{
ASInstruction instruction = code[i];
switch (instruction.OP)
{
default: continue;
case OPCode.NewFunction:
{
NewFunctionIns newFunction = (NewFunctionIns)instruction;
references.AddRange(FindMessageReferences(fromClass, fromContainer, newFunction.Method));
continue;
}
case OPCode.GetProperty:
{
GetPropertyIns getProperty = (GetPropertyIns)instruction;
nameStack.Push(getProperty.PropertyName);
continue;
}
case OPCode.GetLex:
{
GetLexIns getLex = (GetLexIns)instruction;
container = abc.GetClass(getLex.TypeName.Name);
continue;
}
case OPCode.GetLocal_0:
{
container = fromContainer;
continue;
}
case OPCode.ConstructProp:
{
ConstructPropIns constructProp = (ConstructPropIns)instruction;
nameStack.Push(constructProp.PropertyName);
break;
}
}
ASMultiname messageQName = nameStack.Pop();
if (string.IsNullOrWhiteSpace(messageQName.Name))
{
continue;
}
ASClass messageClass = abc.GetClass(messageQName.Name);
if (messageClass == null)
{
continue;
}
if (!_messages.TryGetValue(messageClass, out HMessage message))
{
continue;
}
if (message.References.Any(r => r.FromMethod == fromMethod))
{
continue;
}
HReference reference = new HReference();
message.References.Add(reference);
if (message.IsOutgoing)
{
reference.FromClass = fromClass;
reference.FromMethod = fromMethod;
reference.InstructionRank = ++instructionRank;
reference.IsAnonymous = (!fromMethod.IsConstructor && fromMethod.Trait == null);
references.Add(reference);
}
else
{
ASMultiname methodName = nameStack.Pop();
ASMethod callbackMethod = fromContainer.GetMethod(methodName.Name);
if (callbackMethod == null)
{
callbackMethod = container.GetMethod(methodName.Name);
if (callbackMethod == null)
{
ASMultiname slotName = nameStack.Pop();
ASTrait hostTrait = container.GetTraits(TraitKind.Slot)
.FirstOrDefault(st => st.QName == slotName);
container = abc.GetInstance(hostTrait.Type.Name);
callbackMethod = container.GetMethod(methodName.Name);
}
}
reference.FromMethod = callbackMethod;
}
}
return(references);
}
private void FindMessagesReferences()
{
int classRank = 1;
ABCFile abc = ABCFiles.Last();
foreach (ASClass @class in abc.Classes)
{
ASInstance instance = @class.Instance;
if (_messages.ContainsKey(@class))
{
continue;
}
if (instance.Flags.HasFlag(ClassFlags.Interface))
{
continue;
}
IEnumerable <ASMethod> methods = (new[] { @class.Constructor, instance.Constructor })
.Concat(instance.GetMethods())
.Concat(@class.GetMethods());
int methodRank = 0;
foreach (ASMethod fromMethod in methods)
{
bool isStatic = (fromMethod.Trait?.IsStatic ?? @class.Constructor == fromMethod);
ASContainer fromContainer = (isStatic ? (ASContainer)@class : instance);
List <HReference> refernces = FindMessageReferences(@class, fromContainer, fromMethod);
if (refernces.Count > 0)
{
methodRank++;
}
foreach (HReference reference in refernces)
{
reference.IsStatic = isStatic;
reference.ClassRank = classRank;
reference.MethodRank = methodRank;
reference.GroupCount = refernces.Count;
}
}
if (methodRank > 0)
{
classRank++;
}
}
Dictionary <ASContainer, List <HReference> > froms = new Dictionary <ASContainer, List <HReference> >();
foreach (HMessage incomingMsg in InMessages.Values)
{
foreach (HReference reference in incomingMsg.References)
{
if (!froms.TryGetValue(reference.FromMethod.Container, out List <HReference> references))
{
references = new List <HReference>();
froms.Add(reference.FromMethod.Container, references);
}
if (!references.Contains(reference))
{
references.Add(reference);
}
}
}
classRank = 1;
foreach (ASClass @class in abc.Classes)
{
ASContainer container = null;
if (froms.TryGetValue(@class, out List <HReference> references))
{
container = @class;
}
else if (froms.TryGetValue(@class.Instance, out references))
{
container = @class.Instance;
}
if (container != null)
{
Dictionary <ASMethod, List <HReference> > methodReferenceGroups = new Dictionary <ASMethod, List <HReference> >();
foreach (HReference reference in references)
{
reference.FromClass = @class;
reference.InstructionRank = -1;
reference.ClassRank = classRank;
reference.IsStatic = container.IsStatic;
reference.GroupCount = references.Count;
if (!methodReferenceGroups.TryGetValue(reference.FromMethod, out List <HReference> methodReferences))
{
methodReferences = new List <HReference>();
methodReferenceGroups.Add(reference.FromMethod, methodReferences);
}
methodReferences.Add(reference);
}
int methodRank = 1;
foreach (ASMethod method in container.GetMethods())
{
if (methodReferenceGroups.TryGetValue(method, out List <HReference> methodReferences))
{
foreach (HReference reference in methodReferences)
{
reference.MethodRank = methodRank;
}
methodRank++;
}
}
classRank++;
}
}
}
public NewFunctionIns(ABCFile abc, FlashReader input)
: this(abc)
{
MethodIndex = input.ReadInt30();
}
public NewFunctionIns(ABCFile abc)
: base(OPCode.NewFunction, abc)
{
}
public CoerceIns(ABCFile abc, int typeNameIndex)
: this(abc)
{
TypeNameIndex = typeNameIndex;
}
public CoerceIns(ABCFile abc, FlashReader input)
: this(abc)
{
TypeNameIndex = input.ReadInt30();
}
public CallPropVoidIns(ABCFile abc)
: base(OPCode.CallPropVoid, abc)
{
}
public Primitive(OPCode op, ABCFile abc)
: base(op, abc)
{
}
public DebugFileIns(ABCFile abc)
: base(OPCode.DebugFile, abc)
{
}
public QName(ABCFile abc, FlashReader reader, ConstantType multinameType)
: this(abc, multinameType)
{
NamespaceIndex = reader.Read7BitEncodedInt();
ObjNameIndex = reader.Read7BitEncodedInt();
}
public ConstructPropIns(ABCFile abc)
: base(OPCode.ConstructProp, abc)
{
}
public SetPropertyIns(ABCFile abc, FlashReader input)
: this(abc)
{
PropertyNameIndex = input.ReadInt30();
}
public static string AnalyzePackets(IToolInstance tool, long ts, ABCFile abc)
{
var zip = abc.instances.Zip(abc.classes, (inst, cls) => new { Instance = inst, Class = cls });
// Find version
var parameter = zip
.SingleOrDefault(type =>
{
var qName = abc.multinames[type.Instance.name];
return(abc.strings[abc.namespaces[qName.QName.ns].name] == "com.company.assembleegameclient.parameters");
});
if (parameter == null)
{
return(null);
}
var stringTraits = parameter.Class.traits
.Where(trait => trait.kind == TraitKind.Const && trait.Slot.vkind == ASType.Utf8)
.ToList();
var versionTrait = stringTraits.Single(trait => trait.Slot.slotId == 1);
string version = abc.strings[versionTrait.Slot.vindex];
var buildTrait = stringTraits.Single(trait => trait.Slot.slotId == 2);
string build = abc.strings[buildTrait.Slot.vindex];
// Find gsc_
var gscTrait = abc.instances
.SelectMany(inst => inst.traits)
.Single(trait =>
{
var qName = abc.multinames[trait.name];
return(abc.strings[qName.QName.name] == "gsc_");
});
var handlerType = zip.Single(type => type.Instance.name == gscTrait.Slot.typeName);
var table = new PacketTable(ts);
var tableType = typeof(PacketTable);
foreach (
var packetEntry in
handlerType.Class.traits.Where(trait => trait.kind == TraitKind.Const && trait.Slot.vkind == ASType.Integer))
{
int packetIndex = (int)packetEntry.Slot.slotId - 1;
var packetId = (int)abc.ints[packetEntry.Slot.vindex];
string name = null;
if (packetIndex < packetNames.Length && packetIndex >= 0)
{
name = packetNames[packetIndex];
}
if (name == null)
{
name = string.Format("_PACKET{0:X2}", packetIndex);
}
tableType.GetField(name).SetValue(table, (byte)packetId);
}
tool.PacketTable = table;
return(version + "." + build);
}
public ASTrait(ABCFile abc, int nameIndex, TraitAttributes attributes, IList<int> metadataIndices) :
this(abc, nameIndex, attributes)
{
MetadataIndices.AddRange(metadataIndices);
}
public CallPropertyIns(ABCFile abc)
: base(OPCode.CallProperty, abc)
{
}
public ASClass(ABCFile abc)
{
_abc = abc;
Traits = new List<ASTrait>();
}
public ASParameter(ABCFile abc)
{
_abc = abc;
}
public ASClass(ABCFile abc, int constructorIndex, IList<ASTrait> traits) :
this(abc, constructorIndex)
{
Traits.AddRange(traits);
}
public ASParameter(ABCFile abc, int typeIndex, bool isOptional) :
this(abc, typeIndex)
{
IsOptional = isOptional;
}
public NewFunctionIns(ABCFile abc, int methodIndex)
: this(abc)
{
MethodIndex = methodIndex;
}
public ASException(ABCFile abc, int variableNameIndex, int exceptionTypeIndex) :
this(abc)
{
VariableNameIndex = variableNameIndex;
ExceptionTypeIndex = exceptionTypeIndex;
}
public RTQName(ABCFile abc, FlashReader reader)
: this(abc, reader, ConstantType.RTQName)
{ }
public CallPropVoidIns(ABCFile abc, int propertyNameIndex)
: this(abc)
{
PropertyNameIndex = propertyNameIndex;
}
public RTQName(ABCFile abc, FlashReader reader, ConstantType multinameType)
: this(abc, multinameType)
{
ObjNameIndex = reader.Read7BitEncodedInt();
}
public static ASInstruction Create(ABCFile abc, FlashReader input)
{
var op = (OPCode)input.ReadByte();
switch (op)
{
#region Arithmetic
case OPCode.Add_i:
return(new AddIIns());
case OPCode.Add:
return(new AddIns());
case OPCode.Decrement_i:
return(new DecrementIIns());
case OPCode.Decrement:
return(new DecrementIns());
case OPCode.Divide:
return(new DivideIns());
case OPCode.Equals:
return(new EqualsIns());
case OPCode.GreaterEquals:
return(new GreaterEqualsIns());
case OPCode.GreaterThan:
return(new GreaterThanIns());
case OPCode.Increment_i:
return(new IncrementIIns());
case OPCode.Increment:
return(new IncrementIns());
case OPCode.In:
return(new InIns());
case OPCode.IsTypeLate:
return(new IsTypeLateIns());
case OPCode.LessEquals:
return(new LessEqualsIns());
case OPCode.LessThan:
return(new LessThanIns());
case OPCode.Modulo:
return(new ModuloIns());
case OPCode.Multiply_i:
return(new MultiplyIIns());
case OPCode.Multiply:
return(new MultiplyIns());
case OPCode.Negate_i:
return(new NegateIIns());
case OPCode.Negate:
return(new NegateIns());
case OPCode.StrictEquals:
return(new StrictEqualsIns());
case OPCode.Subtract_i:
return(new SubtractIIns());
case OPCode.Subtract:
return(new SubtractIns());
#endregion
#region Bit Manipulation
case OPCode.BitAnd:
return(new BitAndIns());
case OPCode.BitNot:
return(new BitNotIns());
case OPCode.BitOr:
return(new BitOrIns());
case OPCode.BitXor:
return(new BitXorIns());
case OPCode.LShift:
return(new LShiftIns());
case OPCode.RShift:
return(new RShiftIns());
case OPCode.URShift:
return(new URShiftIns());
#endregion
#region Control Transfer
case OPCode.IfEq:
return(new IfEqualIns(input));
case OPCode.IfFalse:
return(new IfFalseIns(input));
case OPCode.IfGe:
return(new IfGreaterEqualIns(input));
case OPCode.IfGt:
return(new IfGreaterThanIns(input));
case OPCode.IfLe:
return(new IfLessEqualIns(input));
case OPCode.IfLt:
return(new IfLessThanIns(input));
case OPCode.IfNe:
return(new IfNotEqualIns(input));
case OPCode.IfNGe:
return(new IfNotGreaterEqualIns(input));
case OPCode.IfNGt:
return(new IfNotGreaterThanIns(input));
case OPCode.IfNLe:
return(new IfNotLessEqualIns(input));
case OPCode.IfNLt:
return(new IfNotLessThanIns(input));
case OPCode.IfStrictEq:
return(new IfStrictEqualIns(input));
case OPCode.IfStrictNE:
return(new IfStrictNotEqualIns(input));
case OPCode.IfTrue:
return(new IfTrueIns(input));
case OPCode.Jump:
return(new JumpIns(input));
#endregion
#region Register Management
case OPCode.DecLocal_i:
return(new DecLocalIIns(input));
case OPCode.DecLocal:
return(new DecLocalIns(input));
case OPCode.GetLocal_0:
return(new GetLocal0Ins());
case OPCode.GetLocal_1:
return(new GetLocal1Ins());
case OPCode.GetLocal_2:
return(new GetLocal2Ins());
case OPCode.GetLocal_3:
return(new GetLocal3Ins());
case OPCode.GetLocal:
return(new GetLocalIns(input));
case OPCode.IncLocal_i:
return(new IncLocalIIns(input));
case OPCode.IncLocal:
return(new IncLocalIns(input));
case OPCode.Kill:
return(new KillIns(input));
case OPCode.SetLocal_0:
return(new SetLocal0Ins());
case OPCode.SetLocal_1:
return(new SetLocal1Ins());
case OPCode.SetLocal_2:
return(new SetLocal2Ins());
case OPCode.SetLocal_3:
return(new SetLocal3Ins());
case OPCode.SetLocal:
return(new SetLocalIns(input));
#endregion
#region Stack Management
case OPCode.PushByte:
return(new PushByteIns(input));
case OPCode.PushDouble:
return(new PushDoubleIns(abc, input));
case OPCode.PushFalse:
return(new PushFalseIns());
case OPCode.PushInt:
return(new PushIntIns(abc, input));
case OPCode.PushNan:
return(new PushNaNIns());
case OPCode.PushNull:
return(new PushNullIns());
case OPCode.PushShort:
return(new PushShortIns(input));
case OPCode.PushString:
return(new PushStringIns(abc, input));
case OPCode.PushTrue:
return(new PushTrueIns());
case OPCode.PushUInt:
return(new PushUIntIns(abc, input));
#endregion
#region Type Conversion
case OPCode.Coerce_a:
return(new CoerceAIns());
case OPCode.Coerce:
return(new CoerceIns(abc, input));
case OPCode.Coerce_s:
return(new CoerceSIns());
case OPCode.Convert_b:
return(new ConvertBIns());
case OPCode.Convert_d:
return(new ConvertDIns());
case OPCode.Convert_i:
return(new ConvertIIns());
case OPCode.Convert_o:
return(new ConvertOIns());
case OPCode.Convert_s:
return(new ConvertSIns());
case OPCode.Convert_u:
return(new ConvertUIns());
#endregion
#region Miscellaneous
case OPCode.ApplyType:
return(new ApplyTypeIns(input));
case OPCode.AsType:
return(new AsTypeIns(abc, input));
case OPCode.AsTypeLate:
return(new AsTypeLateIns());
case OPCode.Call:
return(new CallIns(input));
case OPCode.CallProperty:
return(new CallPropertyIns(abc, input));
case OPCode.CallPropLex:
return(new CallPropLexIns(abc, input));
case OPCode.CallPropVoid:
return(new CallPropVoidIns(abc, input));
case OPCode.CallSuper:
return(new CallSuperIns(abc, input));
case OPCode.CallSuperVoid:
return(new CallSuperVoidIns(abc, input));
case OPCode.CheckFilter:
return(new CheckFilterIns());
case OPCode.Construct:
return(new ConstructIns(input));
case OPCode.ConstructProp:
return(new ConstructPropIns(abc, input));
case OPCode.ConstructSuper:
return(new ConstructSuperIns(input));
case OPCode.DebugFile:
return(new DebugFileIns(abc, input));
case OPCode.Debug:
return(new DebugIns(abc, input));
case OPCode.DebugLine:
return(new DebugLineIns(input));
case OPCode.DeleteProperty:
return(new DeletePropertyIns(abc, input));
case OPCode.Dup:
return(new DupIns());
case OPCode.DxnsLate:
return(new DxnsLateIns());
case OPCode.Esc_XElem:
return(new EscXElemIns());
case OPCode.Esc_XAttr:
return(new EscXAttrIns());
case OPCode.FindProperty:
return(new FindPropertyIns(abc, input));
case OPCode.FindPropStrict:
return(new FindPropStrictIns(abc, input));
case OPCode.GetDescendants:
return(new GetDescendantsIns(abc, input));
case OPCode.GetGlobalScope:
return(new GetGlobalScopeIns());
case OPCode.GetLex:
return(new GetLexIns(abc, input));
case OPCode.GetProperty:
return(new GetPropertyIns(abc, input));
case OPCode.GetScopeObject:
return(new GetScopeObjectIns(input));
case OPCode.GetSlot:
return(new GetSlotIns(input));
case OPCode.GetSuper:
return(new GetSuperIns(abc, input));
case OPCode.HasNext2:
return(new HasNext2Ins(input));
case OPCode.HasNext:
return(new HasNextIns());
case OPCode.InitProperty:
return(new InitPropertyIns(abc, input));
case OPCode.InstanceOf:
return(new InstanceOfIns());
case OPCode.Label:
return(new LabelIns());
case OPCode.LookUpSwitch:
return(new LookUpSwitchIns(input));
case OPCode.NewActivation:
return(new NewActivationIns());
case OPCode.NewArray:
return(new NewArrayIns(input));
case OPCode.NewCatch:
return(new NewCatchIns(input));
case OPCode.NewClass:
return(new NewClassIns(abc, input));
case OPCode.NewFunction:
return(new NewFunctionIns(abc, input));
case OPCode.NewObject:
return(new NewObjectIns(input));
case OPCode.NextName:
return(new NextNameIns());
case OPCode.NextValue:
return(new NextValueIns());
case OPCode.Nop:
return(new NopIns());
case OPCode.Not:
return(new NotIns());
case OPCode.Pop:
return(new PopIns());
case OPCode.PopScope:
return(new PopScopeIns());
case OPCode.PushScope:
return(new PushScopeIns());
case OPCode.PushUndefined:
return(new PushUndefinedIns());
case OPCode.PushWith:
return(new PushWithIns());
case OPCode.ReturnValue:
return(new ReturnValueIns());
case OPCode.ReturnVoid:
return(new ReturnVoidIns());
case OPCode.SetProperty:
return(new SetPropertyIns(abc, input));
case OPCode.SetSlot:
return(new SetSlotIns(input));
case OPCode.SetSuper:
return(new SetSuperIns(abc, input));
case OPCode.Swap:
return(new SwapIns());
case OPCode.Throw:
return(new ThrowIns());
case OPCode.TypeOf:
return(new TypeOfIns());
#endregion
}
throw new Exception("Unhandled OPCode: " + op);
}
public MethodGetterSetterTrait(ABCFile abc, FlashReader reader, string objName, TraitType traitType) :
this(abc, objName, traitType)
{
DispId = reader.Read7BitEncodedInt();
MethodIndex = reader.Read7BitEncodedInt();
}
public DebugFileIns(ABCFile abc, FlashReader input)
: this(abc)
{
FileNameIndex = input.ReadInt30();
}
public ASParameter(ABCFile abc, int typeIndex) :
this(abc)
{
TypeIndex = typeIndex;
}
public CallPropertyIns(ABCFile abc, int propertyNameIndex, int argCount)
: this(abc, propertyNameIndex)
{
ArgCount = argCount;
}
public ASException(ABCFile abc)
{
_abc = abc;
}
public GetSuperIns(ABCFile abc)
: base(OPCode.GetSuper, abc)
{
}
public CallPropertyIns(ABCFile abc, FlashReader input)
: this(abc)
{
PropertyNameIndex = input.ReadInt30();
ArgCount = input.ReadInt30();
}
protected ASInstruction(OPCode op, ABCFile abc)
: this(op)
{
ABC = abc;
}
