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