| /* |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| */ |
| |
| package macromedia.abc; |
| |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.*; |
| import java.util.HashSet; |
| |
| /** |
| * |
| This file stays synchronized with the source code. To view |
| previous formats that we don't support, sync backwards in |
| perforce. |
| |
| AbcFile { |
| U16 minor_version // = 10 |
| U16 major_version // = 46 |
| U16 constant_pool_count |
| Constant[constant_pool_count] |
| U16 methods_count |
| MethodInfo[methods_count] |
| U16 metadata_count |
| MetadataInfo[metadata_count] |
| U16 class_count |
| InstanceInfo[class_count] |
| ClassInfo[class_count] |
| U16 script_count |
| ScriptInfo[script_count] // ScriptInfo[script_count-1] is main entry point |
| U16 bodies_count |
| MethodBody[bodies_count] |
| } |
| |
| Constant { |
| U8 kind |
| union { |
| kind=1 { // CONSTANT_utf8 |
| U16 length |
| U8[length] |
| } |
| kind=3 { // CONSTANT_Integer |
| S32 value |
| } |
| kind=4 { // CONSTANT_UInteger |
| U32 value |
| } |
| kind=6 { // CONSTANT_Double |
| U64 doublebits (little endian) |
| } |
| kind=2 { // CONSTANT_Decimal |
| U8[16] |
| } |
| kind=7,13 { // CONSTANT_Qname + CONSTANT_QnameA |
| U16 namespace_index // CONSTANT_Namespace, 0=AnyNamespace wildcard |
| U16 name_index // CONSTANT_Utf8, 0=AnyName wildcard |
| } |
| kind=8,5 { // CONSTANT_Namespace, CONSTANT_PrivateNamespace |
| U16 name_index // CONSTANT_Utf8 uri (maybe 0) |
| } |
| kind=9,14 { // CONSTANT_Multiname, CONSTANT_MultinameA |
| U16 name_index // CONSTANT_Utf8 simple name. 0=AnyName wildcard |
| U16 namespaces_count // (256 may seem like enough, but 64K use to seem like a lot of memory) |
| U16 namespaces[namespaces_count] // CONSTANT_Namespace (0 = error) |
| } |
| kind=10 // CONSTANT_False |
| kind=11 // CONSTANT_True |
| kind=12 // CONSTANT_Null |
| kind=15,16 { // CONSTANT_RTQname + CONSTANT_RTQnameA |
| U16 name_index // CONSTANT_utf8, 0=AnyName wildcard |
| } |
| kind=17,18 // CONSTANT_RTQnameL + CONSTANT_RTQnameLA |
| } |
| } |
| |
| Traits { |
| U16 count |
| Trait[count] { |
| U16 name_index // CONSTANT_QName |
| U8 kind // hi 4 bits are flags, 0x04: (1=has_metadata, 0=no metadata) |
| union { |
| kind=0,6 { // slot, const |
| U16 slot_id // 0=autoassign |
| U16 type_index // CONSTANT_Multiname, 0=Object |
| U16 value_index // CONSTANT or 0 for undefined |
| } |
| kind=1,2,3 { // method, getter, setter |
| U16 disp_id // 0=autoassign |
| U16 method_info // method must be parsed already |
| // attrs are stored in the hi 4 bits of the kind byte |
| // 0x01: (1=final,0=virtual), 0x02: (1=override,0=new) |
| } |
| kind=4 { // class |
| U16 slot_id // 0=autoassign |
| U16 class_info // class must have been parsed already |
| } |
| kind=5 { // function |
| U16 slot_index // 0=autoassign |
| U16 method_info // method_info of function residing in this slot |
| } |
| } |
| if ( (kind >> 4) & 0x04 ) // these are only present when the kind contains the has_metadata flag |
| { |
| U16 metadata_count // Number of metadata |
| U16 metadata[count] // MetadataInfo indices |
| } |
| } |
| } |
| |
| MetadataInfo { |
| U16 name_index // CONSTANT_utf8 |
| U16 values_count // # of values in this metadata |
| U16 keys[values_count] // CONSTANT_utf8, 0 = keyless |
| U16 values[values_count] // CONSTANT_utf8 |
| } |
| |
| InstanceInfo { |
| U16 name_index // CONSTANT_QName (definition) |
| U16 super_index // CONSTANT_Multiname (reference) |
| U8 sealed // 1 = sealed, 0 = dynamic |
| U32 protected_namespace // CONSTANT_Namespace |
| U16 interfaces_count |
| U16 interfaces[interfaces_count] // CONSTANT_Multiname (references) |
| U16 iinit_index // MethodInfo |
| Traits instance_traits |
| } |
| |
| ClassInfo { |
| U16 cinit_index // MethodInfo |
| Traits static_traits |
| } |
| |
| ScriptInfo { |
| U16 init_index // MethodInfo |
| Traits traits |
| } |
| |
| // A MethodInfo describes the method signature |
| MethodInfo { |
| U16 param_count |
| U16 ret_type // CONSTANT_Multiname, 0=Object |
| U16 param_types[param_count] // CONSTANT_Multiname, 0=Object |
| U16 name_index // 0=no name. |
| // 1=need_arguments, 2=need_activation, 4=need_rest 8=has_optional 16=ignore_rest, 32=explicit |
| U8 flags |
| U16 optional_count // if has_optional |
| U16 value_index[optional_count] // if has_optional |
| } |
| |
| // A MethodBody describes the method implementation. |
| // not required for native methods or interface methods. |
| MethodBody { |
| U16 method_info |
| U16 max_stack |
| U16 max_regs |
| U16 scope_depth |
| U16 max_scope |
| U32 code_length |
| U8 code[code_length] |
| U16 ex_count |
| Exception[ex_count] |
| Traits traits // activation traits |
| } |
| |
| Exception { |
| U32 start // Offsets of beginning and |
| U32 end // end of the try block |
| U32 target // Target PC to transfer control to (catch) |
| U16 type_index // Type matched by this exception handler |
| } |
| * |
| * @author Clement Wong |
| */ |
| public final class Decoder |
| { |
| public Decoder(BytecodeBuffer in) throws DecoderException |
| { |
| minorVersion = in.readU16(); |
| majorVersion = in.readU16(); |
| constantPool = new ConstantPool(in, minorVersion >= MINORwithDECIMAL); |
| |
| int pos = in.pos(); |
| methodInfo = new MethodInfo(in); |
| methodInfo.estimatedSize = in.pos() - pos; |
| |
| pos = in.pos(); |
| metadataInfo = new MetaDataInfo(in); |
| metadataInfo.estimatedSize = in.pos() - pos; |
| |
| pos = in.pos(); |
| classInfo = new ClassInfo(in); |
| classInfo.estimatedSize = in.pos() - pos; |
| |
| pos = in.pos(); |
| scriptInfo = new ScriptInfo(in); |
| scriptInfo.estimatedSize = in.pos() - pos; |
| |
| pos = in.pos(); |
| methodBodies = new MethodBodies(in); |
| methodBodies.estimatedSize = in.pos() - pos; |
| |
| opcodes = new Opcodes(in); |
| |
| this.in = in; |
| } |
| |
| public final int minorVersion; |
| public final int majorVersion; |
| public final ConstantPool constantPool; |
| public final MethodInfo methodInfo; |
| public final MetaDataInfo metadataInfo; |
| public final ClassInfo classInfo; |
| public final ScriptInfo scriptInfo; |
| public final MethodBodies methodBodies; |
| public final Opcodes opcodes; |
| |
| private final BytecodeBuffer in; |
| |
| public int pos() |
| { |
| return in.pos(); |
| } |
| |
| public final class MethodInfo |
| { |
| MethodInfo(BytecodeBuffer in) |
| { |
| this(in, Scanner.scanMethods(in)); |
| } |
| |
| MethodInfo(BytecodeBuffer in, int[] positions) |
| { |
| this.in = in; |
| this.positions = positions; |
| } |
| |
| BytecodeBuffer in; |
| int estimatedSize; |
| private int[] positions; |
| |
| public int size() |
| { |
| return positions.length; |
| } |
| |
| public void decode(int index, Visitor visitor) throws DecoderException |
| { |
| int pos = positions[index]; |
| int originalPos = in.pos(); |
| in.seek(pos); |
| |
| int paramCount = in.readU32(); |
| int returnType = in.readU32(); |
| |
| int[] paramTypes = null; |
| if (paramCount > 0) |
| { |
| paramTypes = new int[paramCount]; |
| for (int j = 0; j < paramCount; j++) |
| { |
| paramTypes[j] = in.readU32(); |
| } |
| } |
| |
| int nativeName = in.readU32(); |
| int flags = in.readU8(); |
| |
| int optionalCount = ((flags & METHOD_HasOptional) != 0) ? in.readU32() : 0; |
| |
| int[] values = null; |
| int[] value_kinds = null; |
| if (optionalCount > 0) |
| { |
| values = new int[optionalCount]; |
| value_kinds = new int[optionalCount]; |
| for (int j = 0; j < optionalCount; j++) |
| { |
| values[j] = in.readU32(); |
| value_kinds[j] = in.readU8(); |
| } |
| } |
| |
| int[] paramNames = null; |
| int paramNameCount = ((flags & METHOD_HasParamNames) != 0 ) ? paramCount : 0; |
| if( paramNameCount > 0) |
| { |
| paramNames = new int[paramNameCount]; |
| for(int j = 0; j < paramNameCount; ++j) |
| { |
| paramNames[j] = in.readU32(); |
| } |
| } |
| in.seek(originalPos); |
| |
| visitor.methodInfo(returnType, paramTypes, nativeName, flags, values, value_kinds, paramNames); |
| } |
| } |
| |
| public final class MetaDataInfo |
| { |
| MetaDataInfo(BytecodeBuffer in) |
| { |
| this(in, Scanner.scanMetadata(in)); |
| } |
| |
| MetaDataInfo(BytecodeBuffer in, int[] positions) |
| { |
| this.in = in; |
| this.positions = positions; |
| } |
| |
| BytecodeBuffer in; |
| int estimatedSize; |
| private int[] positions; |
| |
| public int size() |
| { |
| return positions.length; |
| } |
| |
| public void decode(int index, Visitor visitor) throws DecoderException |
| { |
| int pos = positions[index]; |
| int originalPos = in.pos(); |
| in.seek(pos); |
| |
| int nameIndex = in.readU32(); |
| int valueCount = in.readU32(); |
| |
| int[] keys = null; |
| int[] values = null; |
| if (valueCount > 0) |
| { |
| keys = new int[valueCount]; |
| values = new int[valueCount]; |
| for (int j = 0; j < valueCount; j++) |
| { |
| keys[j] = in.readU32(); |
| } |
| for (int j = 0; j < valueCount; j++) |
| { |
| values[j] = in.readU32(); |
| } |
| } |
| |
| in.seek(originalPos); |
| |
| visitor.metadataInfo(index, nameIndex, keys, values); |
| } |
| } |
| |
| public final class ClassInfo |
| { |
| ClassInfo(BytecodeBuffer in) |
| { |
| this.in = in; |
| int size = in.readU32(); |
| iPositions = Scanner.scanInstances(in, size); |
| iTraits = new Traits(in); |
| cPositions = Scanner.scanClasses(in, size); |
| cTraits = new Traits(in); |
| } |
| |
| BytecodeBuffer in; |
| int estimatedSize; |
| private int[] cPositions; |
| private int[] iPositions; |
| private Traits cTraits; |
| private Traits iTraits; |
| |
| public int size() |
| { |
| return cPositions.length; |
| } |
| |
| public void decode(int index, Visitor visitor) throws DecoderException |
| { |
| int name = decodeInstance(index, visitor); |
| decodeClass(index, name, visitor); |
| } |
| |
| public int decodeInstance(int index, Visitor visitor) throws DecoderException |
| { |
| int pos = iPositions[index]; |
| int originalPos = in.pos(); |
| in.seek(pos); |
| |
| int name = in.readU32(); |
| int superName = in.readU32(); |
| |
| int flags = in.readU8(); |
| boolean isFinal = (flags & CLASS_FLAG_final) != 0; |
| boolean isDynamic = ( flags & CLASS_FLAG_sealed ) == 0; |
| boolean isInterface = (flags & CLASS_FLAG_interface) != 0; |
| boolean hasProtected = (flags & CLASS_FLAG_protected) != 0; |
| |
| int protectedNamespace = hasProtected ? in.readU32() : 0; |
| |
| int interfaceCount = in.readU32(); |
| int[] interfaces = new int[interfaceCount]; |
| if (interfaceCount > 0) |
| { |
| for (int j = 0; j < interfaceCount; j++) |
| { |
| interfaces[j] = in.readU32(); |
| } |
| } |
| |
| int iinit = in.readU32(); |
| visitor.startInstance(name, superName, isDynamic, isFinal, isInterface, interfaces, iinit, protectedNamespace); |
| iTraits.decode(visitor); |
| visitor.endInstance(); |
| |
| in.seek(originalPos); |
| |
| return name; |
| } |
| |
| public void decodeClass(int index, int name, Visitor visitor) throws DecoderException |
| { |
| int pos = cPositions[index]; |
| int originalPos = in.pos(); |
| in.seek(pos); |
| |
| int cinit = in.readU32(); |
| visitor.startClass(name, cinit); |
| cTraits.decode(visitor); |
| visitor.endClass(); |
| |
| in.seek(originalPos); |
| } |
| } |
| |
| public final class ScriptInfo |
| { |
| ScriptInfo(BytecodeBuffer in) |
| { |
| this(in, Scanner.scanScripts(in)); |
| } |
| |
| ScriptInfo(BytecodeBuffer in, int[] positions) |
| { |
| this.in = in; |
| this.positions = positions; |
| traits = new Traits(in); |
| } |
| |
| BytecodeBuffer in; |
| int estimatedSize; |
| private int[] positions; |
| private Traits traits; |
| |
| public int size() |
| { |
| return positions.length; |
| } |
| |
| public void decode(int index, Visitor visitor) throws DecoderException |
| { |
| int pos = positions[index]; |
| int originalPos = in.pos(); |
| in.seek(pos); |
| |
| int initID = in.readU32(); |
| visitor.startScript(initID); |
| traits.decode(visitor); |
| visitor.endScript(); |
| |
| in.seek(originalPos); |
| } |
| } |
| |
| public final class MethodBodies |
| { |
| MethodBodies(BytecodeBuffer in) |
| { |
| this(in, Scanner.scanMethodBodies(in)); |
| } |
| |
| MethodBodies(BytecodeBuffer in, int[] positions) |
| { |
| this.in = in; |
| this.positions = positions; |
| traits = new Traits(in); |
| } |
| |
| BytecodeBuffer in; |
| int estimatedSize; |
| private int[] positions; |
| private Traits traits; |
| |
| public int size() |
| { |
| return positions.length; |
| } |
| |
| public void decode(int index, Visitor visitor) throws DecoderException |
| { |
| decode(index, 1, visitor); |
| } |
| |
| public void decode(int index, int opcodePass, Visitor visitor) throws DecoderException |
| { |
| int pos = positions[index]; |
| int originalPos = in.pos(); |
| in.seek(pos); |
| |
| int methodInfo = in.readU32(); |
| int maxStack = in.readU32(); |
| int maxRegs = in.readU32(); |
| int scopeDepth = in.readU32(); |
| int maxScope = in.readU32(); |
| |
| long codeLength = in.readU32(); |
| int codeStart = in.pos(); |
| in.skip((int) codeLength); |
| |
| visitor.startMethodBody(methodInfo, maxStack, maxRegs, scopeDepth, maxScope, codeStart, codeLength); |
| |
| int exPos = in.pos(); |
| for (int i = 0; i < opcodePass; i++) |
| { |
| opcodes.reset(); |
| in.seek(exPos); |
| int exCount = in.readU32(); |
| |
| visitor.startOpcodes(methodInfo); |
| visitor.startExceptions(exCount); |
| |
| decodeExceptions(in, codeStart, visitor, exCount); |
| opcodes.decode(codeStart, codeLength, visitor); |
| |
| visitor.endOpcodes(); |
| visitor.endExceptions(); |
| } |
| traits.decode(visitor); |
| visitor.endMethodBody(); |
| |
| in.seek(originalPos); |
| } |
| |
| private void decodeExceptions(BytecodeBuffer in, int codeStart, Visitor visitor, int exCount) |
| { |
| boolean hasNames = (in.minorVersion() != 15); |
| |
| for (int i = 0; i < exCount; i++) |
| { |
| long start = codeStart + in.readU32(); |
| long end = codeStart + in.readU32(); |
| long target = codeStart + in.readU32(); |
| |
| int type = in.readU32(); // multiname |
| |
| int nameIndex = hasNames ? in.readU32() : 0; |
| |
| opcodes.addTarget((int) start); |
| opcodes.addTarget((int) end); |
| opcodes.addTarget((int) target); |
| |
| visitor.exception(start, end, target, type, nameIndex); |
| } |
| } |
| } |
| |
| class Traits |
| { |
| Traits(BytecodeBuffer in) |
| { |
| this.in = in; |
| } |
| |
| BytecodeBuffer in; |
| |
| void decode(Visitor visitor) throws DecoderException |
| { |
| int count = in.readU32(); |
| visitor.traitCount(count); |
| |
| for (int i = 0; i < count; i++) |
| { |
| int name = in.readU32(); |
| int kind = in.readU8(); |
| int slotID, typeID, valueID, methInfo, dispID, classID; |
| int value_kind = 0; |
| |
| switch (kind & 0x0f) |
| { |
| case TRAIT_Var: |
| case TRAIT_Const: |
| slotID = in.readU32(); |
| typeID = in.readU32(); |
| valueID = in.readU32(); |
| if(valueID != 0 ) |
| value_kind = in.readU8(); |
| visitor.slotTrait(kind, name, slotID, typeID, valueID, value_kind, decodeMetaData(kind)); |
| break; |
| case TRAIT_Method: |
| case TRAIT_Getter: |
| case TRAIT_Setter: |
| dispID = in.readU32(); |
| methInfo = in.readU32(); |
| visitor.methodTrait(kind, name, dispID, methInfo, decodeMetaData(kind)); |
| break; |
| case TRAIT_Class: |
| slotID = in.readU32(); |
| classID = in.readU32(); |
| visitor.classTrait(kind, name, slotID, classID, decodeMetaData(kind)); |
| break; |
| case TRAIT_Function: |
| slotID = in.readU32(); |
| methInfo = in.readU32(); |
| visitor.functionTrait(kind, name, slotID, methInfo, decodeMetaData(kind)); |
| break; |
| default: |
| // do nothing. macromedia.abc.Scanner would throw an exception. |
| // bad abc code will not reach here. |
| } |
| } |
| } |
| |
| private int[] decodeMetaData(int kind) |
| { |
| int[] md = null; |
| |
| if (((kind >> 4) & TRAIT_FLAG_metadata) != 0) |
| { |
| int length = in.readU32(); |
| if (length > 0) |
| { |
| md = new int[length]; |
| for (int i = 0; i < length; i++) |
| { |
| md[i] = in.readU32(); |
| } |
| } |
| } |
| |
| return md; |
| } |
| } |
| |
| public class Opcodes |
| { |
| public Opcodes(BytecodeBuffer in) |
| { |
| this.in = in; |
| } |
| |
| BytecodeBuffer in; |
| |
| private HashSet<Integer> targetSet; |
| public void addTarget(int pos) |
| { |
| if (targetSet == null) |
| targetSet = new HashSet<Integer>(); |
| targetSet.add(pos); |
| } |
| public void reset() |
| { |
| targetSet = null; |
| } |
| |
| public void decode(int start, long length, int passes, Visitor v) throws DecoderException |
| { |
| for (int i = 0; i < passes; i++) |
| { |
| decode(start, length, v); |
| } |
| } |
| |
| public void decode(int start, long length, Visitor v) throws DecoderException |
| { |
| int originalPos = in.pos(); |
| in.seek(start); |
| |
| for (long end = start + length; in.pos() < end;) |
| { |
| int pos = in.pos(); |
| int opcode = in.readU8(); |
| |
| if (opcode == OP_label) |
| addTarget(pos); |
| |
| if (targetSet != null && targetSet.contains(pos)) |
| v.target(pos); |
| |
| switch (opcode) |
| { |
| case OP_ifnlt: |
| { |
| int offset = in.readS24(); |
| addTarget(offset + in.pos()); |
| v.OP_ifnlt(offset, in.pos()); |
| continue; |
| } |
| case OP_ifnle: |
| { |
| int offset = in.readS24(); |
| addTarget(offset + in.pos()); |
| v.OP_ifnle(offset, in.pos()); |
| continue; |
| } |
| case OP_ifngt: |
| { |
| int offset = in.readS24(); |
| addTarget(offset + in.pos()); |
| v.OP_ifngt(offset, in.pos()); |
| continue; |
| } |
| case OP_ifnge: |
| { |
| int offset = in.readS24(); |
| addTarget(offset + in.pos()); |
| v.OP_ifnge(offset, in.pos()); |
| continue; |
| } |
| case OP_pushscope: |
| { |
| v.OP_pushscope(); |
| continue; |
| } |
| case OP_newactivation: |
| { |
| v.OP_newactivation(); |
| continue; |
| } |
| case OP_newcatch: |
| { |
| int index = in.readU32(); |
| v.OP_newcatch(index); |
| continue; |
| } |
| case OP_deldescendants: |
| { |
| v.OP_deldescendants(); |
| continue; |
| } |
| case OP_getglobalscope: |
| { |
| v.OP_getglobalscope(); |
| continue; |
| } |
| case OP_getlocal0: |
| { |
| v.OP_getlocal0(); |
| continue; |
| } |
| case OP_getlocal1: |
| { |
| v.OP_getlocal1(); |
| continue; |
| } |
| case OP_getlocal2: |
| { |
| v.OP_getlocal2(); |
| continue; |
| } |
| case OP_getlocal3: |
| { |
| v.OP_getlocal3(); |
| continue; |
| } |
| case OP_setlocal0: |
| { |
| v.OP_setlocal0(); |
| continue; |
| } |
| case OP_setlocal1: |
| { |
| v.OP_setlocal1(); |
| continue; |
| } |
| case OP_setlocal2: |
| { |
| v.OP_setlocal2(); |
| continue; |
| } |
| case OP_setlocal3: |
| { |
| v.OP_setlocal3(); |
| continue; |
| } |
| case OP_returnvoid: |
| { |
| v.OP_returnvoid(); |
| continue; |
| } |
| case OP_returnvalue: |
| { |
| v.OP_returnvalue(); |
| continue; |
| } |
| case OP_nop: |
| { |
| v.OP_nop(); |
| continue; |
| } |
| case OP_bkpt: |
| { |
| v.OP_bkpt(); |
| continue; |
| } |
| case OP_timestamp: |
| { |
| v.OP_timestamp(); |
| continue; |
| } |
| case OP_debugline: |
| { |
| int linenum = in.readU32(); |
| v.OP_debugline(linenum); |
| continue; |
| } |
| case OP_bkptline: |
| { |
| in.readU32(); |
| v.OP_bkptline(); |
| continue; |
| } |
| case OP_debug: |
| { |
| int di_local = in.readU8(); // DI_LOCAL |
| int index = in.readU32(); // constant pool index... |
| int slot = in.readU8(); |
| int linenum = in.readU32(); |
| v.OP_debug(di_local, index, slot, linenum); |
| continue; |
| } |
| case OP_debugfile: |
| { |
| int index = in.readU32(); // constant pool index... |
| // String file = constantPool.getString(index); |
| v.OP_debugfile(index); |
| continue; |
| } |
| case OP_jump: |
| { |
| int jump = in.readS24(); // readjust jump... |
| addTarget(jump + in.pos()); |
| v.OP_jump(jump, in.pos()); |
| continue; |
| } |
| case OP_pushnull: |
| { |
| v.OP_pushnull(); |
| continue; |
| } |
| case OP_pushundefined: |
| { |
| v.OP_pushundefined(); |
| continue; |
| } |
| case OP_pushstring: |
| { |
| int index = in.readU32(); // constant pool index... |
| v.OP_pushstring(index); |
| continue; |
| } |
| case OP_pushnamespace: |
| { |
| int index = in.readU32(); |
| v.OP_pushnamespace(index); |
| continue; |
| } |
| case OP_pushint: |
| { |
| int index = in.readU32(); // constant pool index... |
| v.OP_pushint(index); |
| continue; |
| } |
| case OP_pushuint: |
| { |
| int index = in.readU32(); // constant pool index... |
| v.OP_pushuint(index); |
| continue; |
| } |
| case OP_pushdouble: |
| { |
| int index = in.readU32(); // constant pool index... |
| v.OP_pushdouble(index); |
| continue; |
| } |
| case OP_pushdecimal: |
| { |
| int index = in.readU32(); // constant pool index... |
| v.OP_pushdecimal(index); |
| continue; |
| } |
| case OP_getlocal: |
| { |
| int index = in.readU32(); |
| v.OP_getlocal(index); |
| continue; |
| } |
| case OP_pushtrue: |
| { |
| v.OP_pushtrue(); |
| continue; |
| } |
| case OP_pushfalse: |
| { |
| v.OP_pushfalse(); |
| continue; |
| } |
| case OP_pushnan: |
| { |
| v.OP_pushnan(); |
| continue; |
| } |
| case OP_pushdnan: |
| { |
| v.OP_pushdnan(); |
| continue; |
| } |
| case OP_pop: |
| { |
| v.OP_pop(); |
| continue; |
| } |
| case OP_dup: |
| { |
| v.OP_dup(); |
| continue; |
| } |
| case OP_swap: |
| { |
| v.OP_swap(); |
| continue; |
| } |
| case OP_convert_s: |
| { |
| v.OP_convert_s(); |
| continue; |
| } |
| case OP_esc_xelem: |
| { |
| v.OP_esc_xelem(); |
| continue; |
| } |
| case OP_esc_xattr: |
| { |
| v.OP_esc_xattr(); |
| continue; |
| } |
| case OP_checkfilter: |
| { |
| v.OP_checkfilter(); |
| continue; |
| } |
| case OP_convert_d: |
| { |
| v.OP_convert_d(); |
| continue; |
| } |
| case OP_convert_b: |
| { |
| v.OP_convert_b(); |
| continue; |
| } |
| case OP_convert_o: |
| { |
| v.OP_convert_o(); |
| continue; |
| } |
| case OP_convert_m: |
| { |
| v.OP_convert_m(); |
| continue; |
| } |
| case OP_convert_m_p: |
| { |
| int param = in.readU32(); |
| v.OP_convert_m_p(param); |
| continue; |
| } |
| case OP_negate: |
| { |
| v.OP_negate(); |
| continue; |
| } |
| case OP_negate_p: |
| { |
| int param = in.readU32(); |
| v.OP_negate_p(param); |
| continue; |
| } |
| case OP_negate_i: |
| { |
| v.OP_negate_i(); |
| continue; |
| } |
| case OP_increment: |
| { |
| v.OP_increment(); |
| continue; |
| } |
| case OP_increment_p: |
| { |
| int param = in.readU32(); |
| v.OP_increment_p(param); |
| continue; |
| } |
| case OP_increment_i: |
| { |
| v.OP_increment_i(); |
| continue; |
| } |
| case OP_inclocal: |
| { |
| int index = in.readU32(); |
| v.OP_inclocal(index); |
| continue; |
| } |
| case OP_inclocal_p: |
| { |
| int param = in.readU32(); |
| int index = in.readU32(); |
| v.OP_inclocal_p(param, index); |
| continue; |
| } |
| case OP_kill: |
| { |
| int index = in.readU32(); |
| v.OP_kill(index); |
| continue; |
| } |
| case OP_label: |
| { |
| v.OP_label(); |
| continue; |
| } |
| case OP_inclocal_i: |
| { |
| int index = in.readU32(); |
| v.OP_inclocal_i(index); |
| continue; |
| } |
| case OP_decrement: |
| { |
| v.OP_decrement(); |
| continue; |
| } |
| case OP_decrement_p: |
| { |
| int param = in.readU32(); |
| v.OP_decrement_p(param); |
| continue; |
| } |
| case OP_decrement_i: |
| { |
| v.OP_decrement_i(); |
| continue; |
| } |
| case OP_declocal: |
| { |
| int index = in.readU32(); |
| v.OP_declocal(index); |
| continue; |
| } |
| case OP_declocal_p: |
| { |
| int param = in.readU32(); |
| int index = in.readU32(); |
| v.OP_declocal_p(param, index); |
| continue; |
| } |
| case OP_declocal_i: |
| { |
| int index = in.readU32(); |
| v.OP_declocal_i(index); |
| continue; |
| } |
| case OP_typeof: |
| { |
| v.OP_typeof(); |
| continue; |
| } |
| case OP_not: |
| { |
| v.OP_not(); |
| continue; |
| } |
| case OP_bitnot: |
| { |
| v.OP_bitnot(); |
| continue; |
| } |
| case OP_setlocal: |
| { |
| int index = in.readU32(); |
| v.OP_setlocal(index); |
| continue; |
| } |
| case OP_add: |
| { |
| v.OP_add(); |
| continue; |
| } |
| case OP_add_p: |
| { |
| int param = in.readU32(); |
| v.OP_add_p(param); |
| continue; |
| } |
| case OP_add_i: |
| { |
| v.OP_add_i(); |
| continue; |
| } |
| case OP_subtract: |
| { |
| v.OP_subtract(); |
| continue; |
| } |
| case OP_subtract_p: |
| { |
| int param = in.readU32(); |
| v.OP_subtract_p(param); |
| continue; |
| } |
| case OP_subtract_i: |
| { |
| v.OP_subtract_i(); |
| continue; |
| } |
| case OP_multiply: |
| { |
| v.OP_multiply(); |
| continue; |
| } |
| case OP_multiply_p: |
| { |
| int param = in.readU32(); |
| v.OP_multiply_p(param); |
| continue; |
| } |
| case OP_multiply_i: |
| { |
| v.OP_multiply_i(); |
| continue; |
| } |
| case OP_divide: |
| { |
| v.OP_divide(); |
| continue; |
| } |
| case OP_divide_p: |
| { |
| int param = in.readU32(); |
| v.OP_divide_p(param); |
| continue; |
| } |
| case OP_modulo: |
| { |
| v.OP_modulo(); |
| continue; |
| } |
| case OP_modulo_p: |
| { |
| int param = in.readU32(); |
| v.OP_modulo_p(param); |
| continue; |
| } |
| case OP_lshift: |
| { |
| v.OP_lshift(); |
| continue; |
| } |
| case OP_rshift: |
| { |
| v.OP_rshift(); |
| continue; |
| } |
| case OP_urshift: |
| { |
| v.OP_urshift(); |
| continue; |
| } |
| case OP_bitand: |
| { |
| v.OP_bitand(); |
| continue; |
| } |
| case OP_bitor: |
| { |
| v.OP_bitor(); |
| continue; |
| } |
| case OP_bitxor: |
| { |
| v.OP_bitxor(); |
| continue; |
| } |
| case OP_equals: |
| { |
| v.OP_equals(); |
| continue; |
| } |
| case OP_strictequals: |
| { |
| v.OP_strictequals(); |
| continue; |
| } |
| case OP_lookupswitch: |
| { |
| int opPos = in.pos() - 1; // OP_lookupswtich position... |
| int defaultPos = in.readS24(); |
| addTarget(defaultPos + opPos); |
| int size_1 = in.readU32(); // size - 1 |
| int[] casePos = new int[size_1 + 1]; |
| int caseTablePos = in.pos(); // case position |
| for (int i = 0, size = casePos.length; i < size; i++) |
| { |
| casePos[i] = in.readS24(); |
| addTarget(casePos[i] + opPos); |
| } |
| v.OP_lookupswitch(defaultPos, casePos, opPos, caseTablePos); |
| continue; |
| } |
| case OP_iftrue: |
| { |
| int offset = in.readS24(); |
| addTarget(offset+in.pos()); |
| v.OP_iftrue(offset, in.pos()); |
| continue; |
| } |
| case OP_iffalse: |
| { |
| int offset = in.readS24(); |
| addTarget(offset+in.pos()); |
| v.OP_iffalse(offset, in.pos()); |
| continue; |
| } |
| case OP_ifeq: |
| { |
| int offset = in.readS24(); |
| addTarget(offset+in.pos()); |
| v.OP_ifeq(offset, in.pos()); |
| continue; |
| } |
| case OP_ifne: |
| { |
| int offset = in.readS24(); |
| addTarget(offset+in.pos()); |
| v.OP_ifne(offset, in.pos()); |
| continue; |
| } |
| case OP_ifstricteq: |
| { |
| int offset = in.readS24(); |
| addTarget(offset+in.pos()); |
| v.OP_ifstricteq(offset, in.pos()); |
| continue; |
| } |
| case OP_ifstrictne: |
| { |
| int offset = in.readS24(); |
| addTarget(offset+in.pos()); |
| v.OP_ifstrictne(offset, in.pos()); |
| continue; |
| } |
| case OP_iflt: |
| { |
| int offset = in.readS24(); |
| addTarget(offset+in.pos()); |
| v.OP_iflt(offset, in.pos()); |
| continue; |
| } |
| case OP_ifle: |
| { |
| int offset = in.readS24(); |
| addTarget(offset+in.pos()); |
| v.OP_ifle(offset, in.pos()); |
| continue; |
| } |
| case OP_ifgt: |
| { |
| int offset = in.readS24(); |
| addTarget(offset+in.pos()); |
| v.OP_ifgt(offset, in.pos()); |
| continue; |
| } |
| case OP_ifge: |
| { |
| int offset = in.readS24(); |
| addTarget(offset+in.pos()); |
| v.OP_ifge(offset, in.pos()); |
| continue; |
| } |
| case OP_lessthan: |
| { |
| v.OP_lessthan(); |
| continue; |
| } |
| case OP_lessequals: |
| { |
| v.OP_lessequals(); |
| continue; |
| } |
| case OP_greaterthan: |
| { |
| v.OP_greaterthan(); |
| continue; |
| } |
| case OP_greaterequals: |
| { |
| v.OP_greaterequals(); |
| continue; |
| } |
| case OP_newobject: |
| { |
| int size = in.readU32(); |
| v.OP_newobject(size); |
| continue; |
| } |
| case OP_newarray: |
| { |
| int size = in.readU32(); |
| v.OP_newarray(size); |
| continue; |
| } |
| // get a property using a multiname ref |
| case OP_getproperty: |
| { |
| int index = in.readU32(); // constant pool index... |
| v.OP_getproperty(index); |
| continue; |
| } |
| // set a property using a multiname ref |
| case OP_setproperty: |
| { |
| int index = in.readU32(); // constant pool index... |
| v.OP_setproperty(index); |
| continue; |
| } |
| // set a property using a multiname ref |
| case OP_initproperty: |
| { |
| int index = in.readU32(); // constant pool index... |
| v.OP_initproperty(index); |
| continue; |
| } |
| case OP_getdescendants: |
| { |
| int index = in.readU32(); // constant pool index... |
| v.OP_getdescendants(index); |
| continue; |
| } |
| // search the scope chain for a given property and return the object |
| // that contains it. the next instruction will usually be getpropname |
| // or setpropname. |
| case OP_findpropstrict: |
| { |
| int index = in.readU32(); // constant pool index... |
| v.OP_findpropstrict(index); |
| continue; |
| } |
| case OP_getlex: |
| { |
| int index = in.readU32(); // constant pool index... |
| v.OP_getlex(index); |
| continue; |
| } |
| case OP_findproperty: |
| { |
| // stack in: [ns [name]] |
| // stack out: obj |
| int index = in.readU32(); // constant pool index... |
| v.OP_findproperty(index); |
| continue; |
| } |
| case OP_finddef: |
| { |
| // stack in: |
| // stack out: obj |
| int index = in.readU32(); // constant pool index... |
| v.OP_finddef(index); |
| continue; |
| } |
| case OP_nextname: |
| { |
| v.OP_nextname(); |
| continue; |
| } |
| case OP_nextvalue: |
| { |
| v.OP_nextvalue(); |
| continue; |
| } |
| case OP_hasnext: |
| { |
| v.OP_hasnext(); |
| continue; |
| } |
| case OP_hasnext2: |
| { |
| int objectRegister = in.readU32(); |
| int indexRegister = in.readU32(); |
| v.OP_hasnext2(objectRegister, indexRegister); |
| continue; |
| } |
| // delete property using multiname |
| case OP_deleteproperty: |
| { |
| int index = in.readU32(); // constant pool index... |
| v.OP_deleteproperty(index); |
| continue; |
| } |
| case OP_setslot: |
| { |
| int index = in.readU32(); |
| v.OP_setslot(index); |
| continue; |
| } |
| case OP_getslot: |
| { |
| int index = in.readU32(); |
| v.OP_getslot(index); |
| continue; |
| } |
| case OP_setglobalslot: |
| { |
| int index = in.readU32(); |
| v.OP_setglobalslot(index); |
| continue; |
| } |
| case OP_getglobalslot: |
| { |
| int index = in.readU32(); |
| v.OP_getglobalslot(index); |
| continue; |
| } |
| case OP_call: |
| { |
| int size = in.readU32(); |
| v.OP_call(size); |
| continue; |
| } |
| case OP_construct: |
| { |
| int size = in.readU32(); |
| v.OP_construct(size); |
| continue; |
| } |
| case OP_applytype: |
| { |
| int size = in.readU32(); |
| v.OP_applytype(size); |
| continue; |
| } |
| case OP_newfunction: |
| { |
| int id = in.readU32(); // method info... |
| v.OP_newfunction(id); |
| continue; |
| } |
| case OP_newclass: |
| { |
| int id = in.readU32(); // class info... |
| v.OP_newclass(id); |
| continue; |
| } |
| case OP_callstatic: |
| { |
| // stack in: receiver, arg1..N |
| // stack out: result |
| int id = in.readU32(); // method info... |
| int argc = in.readU32(); |
| v.OP_callstatic(id, argc); |
| continue; |
| } |
| case OP_callmethod: |
| { |
| // stack in: receiver, arg1..N |
| // stack out: result |
| int id = in.readU32(); // disp_id... |
| int argc = in.readU32(); |
| v.OP_callmethod(id, argc); |
| continue; |
| } |
| case OP_callproperty: |
| { |
| // stack in: obj [ns [name]] arg1..N |
| // stack out: result |
| int index = in.readU32(); // constant pool index... |
| int argc = in.readU32(); |
| v.OP_callproperty(index, argc); |
| continue; |
| } |
| case OP_callproplex: |
| { |
| // stack in: obj [ns [name]] arg1..N |
| // stack out: result |
| int index = in.readU32(); // constant pool index... |
| int argc = in.readU32(); |
| v.OP_callproplex(index, argc); |
| continue; |
| } |
| case OP_constructprop: |
| { |
| // stack in: obj [ns [name]] arg1..N |
| // stack out: result |
| int index = in.readU32(); // constant pool index... |
| int argc = in.readU32(); |
| v.OP_constructprop(index, argc); |
| continue; |
| } |
| case OP_callsuper: |
| { |
| // stack in: obj [ns [name]] arg1..N |
| int index = in.readU32(); // constant pool index... |
| int argc = in.readU32(); |
| v.OP_callsuper(index, argc); |
| continue; |
| } |
| case OP_getsuper: |
| { |
| int index = in.readU32(); // constant pool index... |
| v.OP_getsuper(index); |
| continue; |
| } |
| case OP_setsuper: |
| { |
| int index = in.readU32(); // constant pool index... |
| v.OP_setsuper(index); |
| continue; |
| } |
| // obj arg1 arg2 |
| // sp |
| case OP_constructsuper: |
| { |
| // stack in: obj arg1..N |
| // stack out: |
| int argc = in.readU32(); |
| v.OP_constructsuper(argc); |
| continue; |
| } |
| case OP_pushshort: |
| { |
| // fixme this just pushes an integer since we dont have short atoms yet |
| int n = in.readU32(); |
| v.OP_pushshort(n); |
| continue; |
| } |
| case OP_astype: |
| { |
| int index = in.readU32(); // constant pool index... |
| v.OP_astype(index); |
| continue; |
| } |
| case OP_astypelate: |
| v.OP_astypelate(); |
| continue; |
| |
| case OP_coerce: |
| { |
| // expects a CONSTANT_Multiname cpool index |
| // this is the ES4 implicit coersion |
| int index = in.readU32(); // constant pool index... |
| v.OP_coerce(index); |
| continue; |
| } |
| case OP_coerce_b: |
| { |
| v.OP_coerce_b(); |
| continue; |
| } |
| case OP_coerce_o: |
| { |
| v.OP_coerce_o(); |
| continue; |
| } |
| case OP_coerce_a: |
| { |
| v.OP_coerce_a(); |
| continue; |
| } |
| case OP_coerce_i: |
| { |
| v.OP_coerce_i(); |
| continue; |
| } |
| case OP_coerce_u: |
| { |
| v.OP_coerce_u(); |
| continue; |
| } |
| case OP_coerce_d: |
| { |
| v.OP_coerce_d(); |
| continue; |
| } |
| case OP_coerce_s: |
| { |
| v.OP_coerce_s(); |
| continue; |
| } |
| case OP_istype: |
| { |
| // expects a CONSTANT_Multiname cpool index |
| // used when operator "is" RHS is a compile-time type constant |
| int index = in.readU32(); // constant pool index... |
| v.OP_istype(index); |
| continue; |
| } |
| case OP_istypelate: |
| { |
| v.OP_istypelate(); |
| continue; |
| } |
| case OP_pushbyte: |
| { |
| int n = in.readU8(); |
| v.OP_pushbyte(n); |
| continue; |
| } |
| case OP_getscopeobject: |
| { |
| int index = in.readU8(); |
| v.OP_getscopeobject(index); |
| continue; |
| } |
| case OP_pushwith: |
| { |
| v.OP_pushwith(); |
| continue; |
| } |
| case OP_popscope: |
| { |
| v.OP_popscope(); |
| continue; |
| } |
| case OP_convert_i: |
| { |
| v.OP_convert_i(); |
| continue; |
| } |
| case OP_convert_u: |
| { |
| v.OP_convert_u(); |
| continue; |
| } |
| case OP_throw: |
| { |
| v.OP_throw(); |
| continue; |
| } |
| case OP_instanceof: |
| { |
| v.OP_instanceof(); |
| continue; |
| } |
| case OP_in: |
| { |
| v.OP_in(); |
| continue; |
| } |
| case OP_dxns: |
| { |
| int index = in.readU32(); // constant pool index... |
| v.OP_dxns(index); |
| continue; |
| } |
| case OP_dxnslate: |
| { |
| v.OP_dxnslate(); |
| continue; |
| } |
| case OP_pushuninitialized: |
| { |
| int id = in.readU32(); |
| v.OP_pushconstant(id); |
| continue; |
| } |
| case OP_callsupervoid: |
| { |
| // stack in: obj [ns [name]] arg1..N |
| int index = in.readU32(); // constant pool index... |
| int argc = in.readU32(); |
| v.OP_callsupervoid(index, argc); |
| continue; |
| } |
| case OP_callpropvoid: |
| { |
| // stack in: obj [ns [name]] arg1..N |
| // stack out: result |
| int index = in.readU32(); // constant pool index... |
| int argc = in.readU32(); |
| v.OP_callpropvoid(index, argc); |
| continue; |
| } |
| case OP_li8: |
| { |
| v.OP_li8(); |
| continue; |
| } |
| case OP_li16: |
| { |
| v.OP_li16(); |
| continue; |
| } |
| case OP_li32: |
| { |
| v.OP_li32(); |
| continue; |
| } |
| case OP_lf32: |
| { |
| v.OP_lf32(); |
| continue; |
| } |
| case OP_lf64: |
| { |
| v.OP_lf64(); |
| continue; |
| } |
| case OP_si8: |
| { |
| v.OP_si8(); |
| continue; |
| } |
| case OP_si16: |
| { |
| v.OP_si16(); |
| continue; |
| } |
| case OP_si32: |
| { |
| v.OP_si32(); |
| continue; |
| } |
| case OP_sf32: |
| { |
| v.OP_sf32(); |
| continue; |
| } |
| case OP_sf64: |
| { |
| v.OP_sf64(); |
| continue; |
| } |
| case OP_sxi1: |
| { |
| v.OP_sxi1(); |
| continue; |
| } |
| case OP_sxi8: |
| { |
| v.OP_sxi8(); |
| continue; |
| } |
| case OP_sxi16: |
| { |
| v.OP_sxi16(); |
| continue; |
| } |
| |
| default: |
| { |
| throw new DecoderException("unknown opcode?? " + opcode); |
| } |
| } |
| } |
| |
| in.seek(originalPos); |
| } |
| } |
| } |
