/* * * 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 java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectInput; import java.io.ObjectInputStream; import java.io.ObjectOutput; import java.io.ObjectOutputStream; import java.util.HashMap; import java.util.Map; import java.util.Set; import java.util.TreeSet; import macromedia.asc.embedding.avmplus.ActionBlockConstants; import macromedia.asc.parser.MetaDataEvaluator; import macromedia.asc.parser.MetaDataNode; import macromedia.asc.semantics.MetaData; import macromedia.asc.semantics.Value; import macromedia.asc.util.Decimal128; @SuppressWarnings("nls") public class AbcData implements java.io.Externalizable { /** * Attempt to read the cache from the persistent store when set. */ static boolean readCache = true; /** * Attempt to write the cache to persistent store when set. */ static boolean saveCache = true; /** * Object used to serialize access to the cache. */ static final Object serializationLock = new Object(); public static boolean contains(String src_name) { return getCache().cache.containsKey(src_name); } public static AbcData getCacheEntry(String src_name) { return getCache().get(src_name); } public void finish() { if ( !( dirty && saveCache) ) { getCache().remove(this); } } private boolean dirty = false; private String scriptName; private static AbcDataCache instance; /** * @return the singleton instance of the cache. */ private static AbcDataCache getCache() { synchronized(serializationLock) { if ( null == instance ) deserializeCache (new File("/tmp/AbcDataCache.ser")); return instance; } } /** * Deserialize the AbcDataCache if feasible. * @param input - the File that holds the serialized cache. * @post The instance field holds a deserialized or new cache. * @throws nothing -- errors dealt with here. */ private static void deserializeCache(File input) { { if ( null == instance && readCache && input.canRead() ) { try { ObjectInputStream objIn = new ObjectInputStream(new FileInputStream(input)); instance = (AbcDataCache)objIn.readObject(); objIn.close(); instance.file = input; } catch ( java.io.InvalidClassException incompatible_serialized_class ) { // Previously serialized class can't be deserialized, // start a new cache. } catch ( Exception ex) { // TODO: Better reporting. ex.printStackTrace(); } } if ( null == instance ) instance = new AbcDataCache(input); } } public static void preload() { new Thread() { @Override public void run() { getCache(); } }.start(); } private static class AbcDataCache implements java.io.Externalizable { private Map cache; private boolean dirty; private File file; AbcDataCache(File f) { cache = new HashMap(); file = f; dirty = false; if ( saveCache ) { Runtime.getRuntime().addShutdownHook( new Thread() { @Override public void run() { // TODO: This shutdown hook should be a last resort! AbcData.instance.flush(); } } ); } } public void flush() { if ( this.dirty ) { try { ObjectOutputStream objOut = new ObjectOutputStream(new FileOutputStream(this.file)); objOut.writeObject(this); objOut.close(); this.dirty = false; System.out.println("Serialized AbcDataCache to " + this.file.getCanonicalPath()); //$NON-NLS-1$ } catch ( Exception ex) { // Better logging would be nice, but a shutdown // hook can't depend on any facilities but the // most basic. ex.printStackTrace(); } } } /** * Retrieve or create cached AbcData for a script. * @param script_name - the script name. * @return the script's AbcData entry. * @post this.dirty set if the AbcData was created. */ AbcData get(String script_name) { if ( !cache.containsKey(script_name) ) { setDirty(); cache.put(script_name, new AbcData(script_name)); cache.get(script_name).dirty = true; } return cache.get(script_name); } /** * Set the cache's dirty bit. * @param is_dirty * @post static maps cleared. */ private void setDirty() { this.dirty = true; } void remove(AbcData data) { if ( !(dirty && saveCache) ) { cache.remove(data.scriptName); } } @SuppressWarnings("unchecked") public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { cache = (Map)in.readObject(); dirty = false; file = new File(in.readObject().toString()); } public void writeExternal(ObjectOutput out) throws IOException { out.writeObject(cache); out.writeObject(file.getCanonicalPath()); } } /* * Housekeeping functions */ public AbcData(String script_name) { this.scriptName = script_name; // see deserialization code, // which resets the dirty bit. this.dirty = true; } public boolean isBuilding() { return this.dirty; } /* * Traits */ public class Trait implements java.io.Externalizable { int nameIndex; int kind; int [] data; int[] metadata; public Trait(int name_index, int kind, int[] data) { this.nameIndex = name_index; this.kind = kind; this.data = data; } public void addMetadata(int[] metadata) { this.metadata = metadata; } public int getNameIndex() { return this.nameIndex; } public int getAttrs() { return kind >> 4; } public int getTag() { return kind & 0xf; } public boolean hasMetadata() { return ( getAttrs() & ActionBlockConstants.TRAIT_FLAG_metadata) != 0; } public boolean isConstTrait() { return (getTag() == ActionBlockConstants.TRAIT_Const); } public int[] getMetadata() { return this.metadata; } public int getSlotId() { assert(getTag() == ActionBlockConstants.TRAIT_Var || getTag() == ActionBlockConstants.TRAIT_Const || getTag() == ActionBlockConstants.TRAIT_Class); return data[0]; } public int getTypeName() { assert(getTag() == ActionBlockConstants.TRAIT_Var || getTag() == ActionBlockConstants.TRAIT_Const); return data[1]; } public int getValueIndex() { assert(getTag() == ActionBlockConstants.TRAIT_Var || getTag() == ActionBlockConstants.TRAIT_Const); return data[2]; } public int getValueKind() { assert(getTag() == ActionBlockConstants.TRAIT_Var || getTag() == ActionBlockConstants.TRAIT_Const); return data[3]; } public int getDispId() { assert(getTag() == ActionBlockConstants.TRAIT_Method || getTag() == ActionBlockConstants.TRAIT_Getter || getTag() == ActionBlockConstants.TRAIT_Setter); return data[0]; } public int getMethodId() { assert(getTag() == ActionBlockConstants.TRAIT_Method || getTag() == ActionBlockConstants.TRAIT_Getter || getTag() == ActionBlockConstants.TRAIT_Setter); return data[1]; } public int getClassId() { assert(getTag() == ActionBlockConstants.TRAIT_Class); return data[1]; } public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { nameIndex = in.readInt(); kind = in.readByte(); data = (int[]) in.readObject(); metadata = (int[]) in.readObject(); } public void writeExternal(ObjectOutput out) throws IOException { out.writeInt(nameIndex); out.writeByte(kind); out.writeObject(data); out.writeObject(metadata); } } /* * NameData is an unstructured view of deserialized name data. */ public class NameData implements java.io.Externalizable { int kind = 0; int[] params; NameData(int kind, int[] params) { this.kind = kind; this.params = params; } public int getKind() { return this.kind; } public int[] getParams() { return this.params; } public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { kind = in.readByte(); params = (int[])in.readObject(); } public void writeExternal(ObjectOutput out) throws IOException { out.writeByte(kind); out.writeObject(params); } Set getVersions() { Namespace ns = null; // If the name's a multiname, get the first namespace // since they all share the same base URI. if ( ActionBlockConstants.CONSTANT_Multiname == kind || ActionBlockConstants.CONSTANT_MultinameA == kind ) { int[] nss = AbcData.this.namespaceSets[this.params[1]].namespaceIds; ns = (nss.length > 0)? namespaces[nss[0]]: null; } else ns = namespaces[params[0]]; switch ( kind ) { case ActionBlockConstants.CONSTANT_Qname: case ActionBlockConstants.CONSTANT_QnameA: ns = namespaces[params[0]]; break; case ActionBlockConstants.CONSTANT_Multiname: case ActionBlockConstants.CONSTANT_MultinameA: int[] nss = AbcData.this.namespaceSets[this.params[1]].namespaceIds; ns = (nss.length > 0)? namespaces[nss[0]]: null; break; default: ns = null; } if ( ns != null ) { String uri = strings[ns.nameOffset]; return getVersion(uri); } return null; } Set getVersion(String uri) { if (uri.length() == 0) return null; int last = uri.codePointAt(uri.length()-1); if(last >= 0xE000 && last <= 0xF000) { Set result = new TreeSet(); result.add(last-0xE000); return result; } return null; } } /** * Names defined in this script. */ private NameData[] nameData; /** * Temporary holder for names read from abc files. * Types are: * QName: namespace id,name id * Typename: QName reference (base), type parameter list of QName references * Multiname: name, namespaceset id */ public class BinaryMN { public int kind = 0; // MultiName type public int nameID = 0; // name CPool string index (not used for CONSTANT_Typename) public int nsID = 0; // namespace or namespaceset id public boolean nsIsSet = false; public int baseMN; // CONSTANT_Typename: base name CPool MN index (e.g. 'Vector' public int[] params; // CONSTANT_TypeName: parameter type CPool MN index (e.g. Vector<'int'>) public Set versions; // optional: supports version gather /** * Construct a non-parameterized name. * @param name_index * @param name_space * @param ns_is_set * @param versions */ BinaryMN(int kind, int name_index, int name_space, boolean ns_is_set, Setversions) { this.kind = kind; this.nameID = name_index; this.nsID = name_space; this.nsIsSet = ns_is_set; this.versions = versions; } /** * Construct a parameterized name. */ BinaryMN(int kind, int base_name, int[] plist) { this.kind = kind; this.baseMN = base_name; this.params = plist; } } private transient BinaryMN[] binaryMultinames; public BinaryMN getName(int idx) { if ( null == this.binaryMultinames[idx] ) { NameData nd = this.nameData[idx]; int name_index = 0; int name_space = 0; boolean ns_is_set = false; switch ( nd.kind ) { case ActionBlockConstants.CONSTANT_Qname: case ActionBlockConstants.CONSTANT_QnameA: name_space = nd.params[0]; name_index = nd.params[1]; ns_is_set = false; this.binaryMultinames[idx] = new BinaryMN(nd.kind, name_index, name_space, ns_is_set, nd.getVersions()); break; case ActionBlockConstants.CONSTANT_TypeName: name_index = nd.params[0]; int count = nd.params.length - 2; assert( count == nd.params[1]); int[] plist = new int[count]; for( int i = 0; i < count; ++i ) plist[i] = nd.params[i+2]; this.binaryMultinames[idx] = new BinaryMN(nd.kind, name_index, plist); break; case ActionBlockConstants.CONSTANT_Multiname: case ActionBlockConstants.CONSTANT_MultinameA: name_index = nd.params[0]; name_space = nd.params[1]; ns_is_set = true; this.binaryMultinames[idx] = new BinaryMN(nd.kind, name_index, name_space, ns_is_set, nd.getVersions()); break; default: throw new IllegalArgumentException("Unexpected multiname type: " + nd.kind); //$NON-NLS-1$ } } return this.binaryMultinames[idx]; } AbcParser parser; public void setParser(AbcParser parser) { this.parser = parser; } /* * Namespace is an ABC-centric view of a namespace. */ public class Namespace implements java.io.Externalizable { int nameOffset; public byte nsKind; Namespace(int name_offset, int ns_kind) { this.nameOffset = name_offset; this.nsKind = (byte)ns_kind; } public String getName() { assert(nameOffset < strings.length); return strings[nameOffset]; } public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { nameOffset = in.readInt(); nsKind = in.readByte(); } public void writeExternal(ObjectOutput out) throws IOException { out.writeInt(nameOffset); out.writeByte(nsKind); } } Namespace[] namespaces; public Namespace getNamespace(int i) { return this.namespaces[i]; } /* * Namespace sets */ public class NamespaceSet implements java.io.Externalizable { int[] namespaceIds; NamespaceSet(int[] nss_ids) { this.namespaceIds = nss_ids; } public int[] getNamespaceIds() { return this.namespaceIds; } public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { namespaceIds = (int[])in.readObject(); } public void writeExternal(ObjectOutput out) throws IOException { out.writeObject(namespaceIds); } } NamespaceSet[] namespaceSets; public void addNamespaceSet(int nss_id, int[] namespaces) { if ( !isBuilding() ) return; assert(this.namespaceSets != null && nss_id < this.namespaceSets.length && null == this.namespaceSets[nss_id]); NamespaceSet nss = new NamespaceSet(namespaces); this.namespaceSets[nss_id] = nss; } public NamespaceSet getNamespaceSet(int id) { assert(id < this.namespaceSets.length); return this.namespaceSets[id]; } /* * Strings */ String[] strings; public String getString(int i) { return this.strings[i]; } /* * Ints */ int[] ints; public int getInt(int i) { return this.ints[i]; } /* * Uints */ long[] uints; public long getUint(int i) { return uints[i]; } /* * Doubles */ double[] doubles; public double getDouble(int i) { return doubles[i]; } /* * Decimals */ private Decimal128[] decimals; public Decimal128 getDecimal(int i) { return decimals[i]; } /* * Methods */ public class Method implements java.io.Externalizable { private int returnType; int[] paramTypes; private int nameIndex; int flags; int[] optionalParamTypes; int[] optionalParamKinds; int[] paramNames; public Method(int return_type, int[] param_types, int name_index, int flags, int[] optional_param_types, int[] optional_param_kinds, int[] param_names) { this.returnType = return_type; this.paramTypes = param_types; this.nameIndex = name_index; this.flags = flags; this.optionalParamTypes = optional_param_types; this.optionalParamKinds = optional_param_kinds; this.paramNames = param_names; } public int getReturnType() { return returnType; } public int[] getParamTypes() { return this.paramTypes; } public int getNameIndex() { return nameIndex; } public int getFlags() { return this.flags; } public int[] getOptionalParamTypes() { return optionalParamTypes; } public int[] getOptionalParamKinds() { return optionalParamKinds; } public String[] getParamNames() { String[] result = new String[paramNames.length]; for ( int i = 0; i < paramNames.length; i++ ) result[i] = strings[paramNames[i]]; return result; } public boolean getNeedsRest() { return (flags & ActionBlockConstants.METHOD_Needrest) != 0 || (flags & ActionBlockConstants.METHOD_IgnoreRest) != 0; } public boolean getHasOptional() { return (flags & ActionBlockConstants.METHOD_HasOptional) != 0; } public boolean getHasParamNames() { return (flags & ActionBlockConstants.METHOD_HasParamNames) != 0; } public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { returnType = in.readInt(); paramTypes = (int[])in.readObject(); nameIndex = in.readInt(); flags = in.readInt(); optionalParamTypes = (int[])in.readObject(); optionalParamKinds = (int[])in.readObject(); paramNames = (int[])in.readObject(); } public void writeExternal(ObjectOutput out) throws IOException { out.writeInt(returnType); out.writeObject(paramTypes); out.writeInt(nameIndex); out.writeInt(flags); out.writeObject(optionalParamTypes); out.writeObject(optionalParamKinds); out.writeObject(paramNames); } } private Method[] methods; public Method getMethod(int index) { assert(index >= 0 && index < this.methods.length); return this.methods[index]; } /* * Metadata */ public class Metadata implements java.io.Externalizable { int nameIndex; int[] keys; int[] values; Metadata(int name_index, int[] keys, int[] values) { this.nameIndex = name_index; this.keys = keys; this.values = values; assert(keys.length == values.length); } public int getDataCount() { return keys.length; } public String getName() { return getString(this.nameIndex); } public String getKey(int idx) { assert(idx >= 0 && idx < keys.length); return getString(keys[idx]); } public String getValue(int idx) { assert(idx >= 0 && idx < values.length); return getString(values[idx]); } public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { nameIndex = in.readInt(); keys = (int[]) in.readObject(); values = (int[]) in.readObject(); } public void writeExternal(ObjectOutput out) throws IOException { out.writeInt(nameIndex); out.writeObject(keys); out.writeObject(values); } } private Metadata[] raw_metadata; private transient MetaData[] semantic_metadata; public MetaData getMetadata(int idx, MetaDataNode metaNode ) { if ( null == this.semantic_metadata[idx] ) { Metadata m = this.raw_metadata[idx]; metaNode.setId(m.getName()); int[] keys = m.keys; int[] raw_values = m.values; Value[] vals = new Value[keys.length]; for(int i = 0; i < keys.length; ++i ) { String value = strings[raw_values[i]]; vals[i] = ( keys[i] == 0 ) ? new MetaDataEvaluator.KeylessValue(value) : new MetaDataEvaluator.KeyValuePair( strings[keys[i]], value); } metaNode.setValues(vals); semantic_metadata[idx] = metaNode.getMetadata(); } return this.semantic_metadata[idx]; } /* * InstanceInfo */ public class InstanceInfo implements java.io.Externalizable { int nameIndex; int superIndex; int flags; int protectedNs; int[] interfaces; int initIndex; Trait[] iTraits; InstanceInfo(int nameIndex, int superIndex, int flags, int protected_ns, int[] interfaces, int init_index, Trait[] itraits) { this.nameIndex = nameIndex; this.superIndex = superIndex; this.flags = flags; this.protectedNs = protected_ns; this.interfaces = interfaces; this.initIndex = init_index; this.iTraits = itraits; } public int getInstanceNameID() { return nameIndex; } public int getSuperID() { return superIndex; } public int getFlags() { return flags; } public int getProtectedNs() { return protectedNs; } public int[] getInterfaces() { return interfaces; } public int getInitIndex() { return initIndex; } public Trait[] getITraits() { return iTraits; } public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { nameIndex = in.readInt(); superIndex = in.readInt(); flags = in.readInt(); protectedNs = in.readInt(); interfaces = (int[]) in.readObject(); initIndex = in.readInt(); iTraits = (Trait[])in.readObject(); } public void writeExternal(ObjectOutput out) throws IOException { out.writeInt(nameIndex); out.writeInt(superIndex); out.writeInt(flags); out.writeInt(protectedNs); out.writeObject(interfaces); out.writeInt(initIndex); out.writeObject(iTraits); } } private InstanceInfo[] instanceInfos; public InstanceInfo getInstanceInfo(int i) { return this.instanceInfos[i]; } /* * ClassInfo */ public class ClassInfo implements java.io.Externalizable { int clinitIndex; Trait[] cTraits; ClassInfo(int clinit_index, Trait[] ctraits) { this.clinitIndex = clinit_index; this.cTraits = ctraits; } public int getClinitIndex() { return clinitIndex; } public Trait[] getCTraits() { return cTraits; } public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { clinitIndex = in.readInt(); cTraits = (Trait[]) in.readObject(); } public void writeExternal(ObjectOutput out) throws IOException { out.writeInt(clinitIndex); out.writeObject(cTraits); } } private ClassInfo[] classInfos; public int getClassInfoSize() { return this.classInfos.length; } public ClassInfo getClassInfo(int idx) { assert(this.classInfos != null && idx >= 0 && idx <= this.classInfos.length); return this.classInfos[idx]; } /* * ScriptInfo */ public class ScriptInfo implements java.io.Externalizable { int initIndex; Trait[] scriptTraits; ScriptInfo(int init_index, Trait[] script_traits) { this.initIndex = init_index; this.scriptTraits = script_traits; } public int getInitIndex() { return this.initIndex; } public Trait[] getScriptTraits() { return this.scriptTraits; } public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { initIndex = in.readInt(); scriptTraits = (Trait[]) in.readObject(); } public void writeExternal(ObjectOutput out) throws IOException { out.writeInt(initIndex); out.writeObject(scriptTraits); } } ScriptInfo[] scriptInfos; public int getScriptInfoSize() { return this.scriptInfos.length; } public ScriptInfo getScriptInfo(int idx) { assert(this.scriptInfos != null && idx >= 0 && idx < this.scriptInfos.length); return this.scriptInfos[idx]; } /** * Serialize the AbcData to an ObjectOutput stream. */ public void writeExternal(ObjectOutput out) throws IOException { out.writeObject(classInfos); out.writeObject(doubles); out.writeObject(instanceInfos); out.writeObject(ints); out.writeObject(raw_metadata); out.writeObject(methods); out.writeObject(namespaces); out.writeObject(namespaceSets); out.writeObject(nameData); out.writeObject(scriptInfos); out.writeObject(scriptName); out.writeObject(strings); out.writeObject(uints); } /** * Deserialize the AbcData. */ public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { classInfos = (ClassInfo[])in.readObject(); doubles = (double[]) in.readObject(); instanceInfos = (InstanceInfo[])in.readObject(); ints = (int[])in.readObject(); raw_metadata = (Metadata[])in.readObject(); semantic_metadata = new MetaData[raw_metadata.length]; methods = (Method[]) in.readObject(); namespaces = (Namespace[]) in.readObject(); namespaceSets = (NamespaceSet[])in.readObject(); nameData = (NameData[])in.readObject(); scriptInfos = (ScriptInfo[])in.readObject(); scriptName = (String)in.readObject(); strings = (String[])in.readObject(); uints = (long[]) in.readObject(); dirty = false; } public void readAbc(byte[] raw_abc) { if (!this.isBuilding() ) return; readAbc(new BytecodeBuffer(raw_abc)); } public void readAbc(BytecodeBuffer buf) { if (!this.isBuilding() ) return; int minor_version = buf.readU16(); /*int major_version =*/ buf.readU16(); // Scan the bytecode for the stuff we care about scanCpool(buf, minor_version >= ActionBlockConstants.MINORwithDECIMAL); scanMethods(buf); scanMetadata(buf); scanClasses(buf); scanScripts(buf); } void scanCpool(BytecodeBuffer buf, boolean hasDecimal) { int size; size = buf.readU32(); this.ints = new int[size]; for (int i = 1; i < size; i++) { this.ints[i] = buf.readU32(); } size = buf.readU32(); this.uints = new long[size]; for (int i = 1; i < size; i++) { this.uints[i] = buf.readU32() & 0xFFFFFFFFL; } size = buf.readU32(); this.doubles = new double[size]; for (int i = 1; i < size; i++) { this.doubles[i] = buf.readDouble(); } if (hasDecimal) { size = buf.readU32(); this.decimals = new Decimal128[size]; for (int i = 1; i < size; i++) { byte[] rep = buf.readBytes(16); decimals[i] = new Decimal128(rep); } } size = buf.readU32(); this.strings = new String[size]; this.strings[0] = "".intern(); for (int i = 1; i < size; i++) { int length = buf.readU32(); this.strings[i] = buf.readString(length).intern(); buf.skip(length); // readString() doesn't reset pos pointer. } size = buf.readU32(); this.namespaces = new Namespace[size]; for (int i = 1; i < size; i++) { int ns_kind = buf.readU8(); // kind byte int name_offset = buf.readU32(); this.namespaces[i] = new Namespace(name_offset, ns_kind); } size = buf.readU32(); this.namespaceSets = new NamespaceSet[size]; for (int i = 1; i < size; i++) { int count = buf.readU32(); // count int[] ns_ids = new int[count]; for(int q =0; q < count; ++q) { ns_ids[q] = buf.readU32(); } this.namespaceSets[i] = new NamespaceSet(ns_ids); } size = buf.readU32(); this.nameData = new NameData[size]; this.binaryMultinames = new BinaryMN[size]; for (int i = 1; i < size; i++) { int kind = buf.readU8(); switch (kind) { case ActionBlockConstants.CONSTANT_Qname: case ActionBlockConstants.CONSTANT_QnameA: this.nameData[i] = new NameData(kind, new int[] {buf.readU32(), buf.readU32()}); break; case ActionBlockConstants.CONSTANT_RTQname: case ActionBlockConstants.CONSTANT_RTQnameA: this.nameData[i] = new NameData(kind, new int[] {buf.readU32()}); break; case ActionBlockConstants.CONSTANT_Multiname: case ActionBlockConstants.CONSTANT_MultinameA: this.nameData[i] = new NameData(kind, new int[] {buf.readU32(), buf.readU32()} ); break; case ActionBlockConstants.CONSTANT_MultinameL: case ActionBlockConstants.CONSTANT_MultinameLA: this.nameData[i] = new NameData(kind, new int[] {buf.readU32()}); break; case ActionBlockConstants.CONSTANT_TypeName: int name_index = buf.readU32(); // name index int count = buf.readU32(); // param count; int[] entries = new int[count+2]; entries[0] = name_index; entries[1] = count; for ( int k = 0; k < count; k++) entries[k+2] = buf.readU32(); this.nameData[i] = new NameData(kind, entries); break; case ActionBlockConstants.CONSTANT_RTQnameL: case ActionBlockConstants.CONSTANT_RTQnameLA: this.nameData[i] = new NameData(kind, null); break; default: throw new RuntimeException("bad multiname type: " + kind); } } } void scanMethods(BytecodeBuffer buf) { int methodEntries = buf.readU32(); this.methods = new Method[methodEntries]; for (int i = 0; i < methodEntries; i++) { int param_count = buf.readU32(); int return_type = buf.readU32(); int[] param_types = new int[param_count]; for ( int j = 0; j < param_count; j++ ) param_types[j] = buf.readU32(); int name_index = buf.readU32(); int flags = buf.readU8(); int optional_param_count = ((flags & ActionBlockConstants.METHOD_HasOptional) != 0)? buf.readU32(): 0; int[] optional_param_types = new int[optional_param_count]; int[] optional_param_kinds = new int[optional_param_count]; for( int q = 0; q < optional_param_count; ++q ) { optional_param_types[q] = buf.readU32(); optional_param_kinds[q] = buf.readU8(); } int param_name_count = ((flags & ActionBlockConstants.METHOD_HasParamNames)!=0) ? param_count : 0; int[] param_names = new int[param_name_count]; for( int q = 0; q < param_name_count; ++q ) { param_names[q] = buf.readU32(); } this.methods[i] = new Method(return_type, param_types, name_index, flags, optional_param_types, optional_param_kinds, param_names); } } void scanMetadata(BytecodeBuffer buf) { int metadataEntries = buf.readU32(); this.raw_metadata = new Metadata[metadataEntries]; this.semantic_metadata = new MetaData[metadataEntries]; for (int i = 0; i < metadataEntries; i++) { int name_index = buf.readU32(); int value_count = buf.readU32(); //returnType int[] keys = new int[value_count]; int[] values = new int[value_count]; for ( int j = 0; j < value_count; j++ ) { keys[j] = buf.readU32(); } for(int j = 0; j < value_count; j++ ) { values[j] = buf.readU32(); } this.raw_metadata[i] = new Metadata( name_index, keys, values ); } } void scanClasses(BytecodeBuffer buf) { int classEntries = buf.readU32(); this.classInfos = new ClassInfo[classEntries]; this.instanceInfos = new InstanceInfo[classEntries]; // InstanceInfos for(int i = 0; i < classEntries; ++i) { int name_index = buf.readU32(); int super_index = buf.readU32(); //super_index int flags = buf.readU8(); int protected_ns = 0; if ((flags & ActionBlockConstants.CLASS_FLAG_protected) != 0) { protected_ns = buf.readU32(); } int interface_count = buf.readU32(); int[] interfaces = new int[interface_count]; for ( int j = 0; j < interface_count; j++ ) interfaces[j] = buf.readU32(); int init_index = buf.readU32(); AbcData.Trait[] itraits = scanTraits(buf); this.instanceInfos[i] = new InstanceInfo(name_index, super_index, flags, protected_ns, interfaces, init_index, itraits); } // ClassInfos for(int i = 0; i < classEntries; ++i) { int clinit_index = buf.readU32(); AbcData.Trait[] ctraits = scanTraits(buf); this.classInfos[i] = new ClassInfo(clinit_index, ctraits); } } void scanScripts(BytecodeBuffer buf) { int script_count = buf.readU32(); this.scriptInfos = new ScriptInfo[script_count]; for(int i = 0 ; i < script_count; ++i ) { this.scriptInfos[i] = new ScriptInfo(buf.readU32(), scanTraits(buf)); } } /** * Read traits from the bytecode into AbcData cache form * @return the deserialized traits. */ AbcData.Trait[] scanTraits(BytecodeBuffer buf) { int count = buf.readU32(); AbcData.Trait[] result = new AbcData.Trait[count]; for (int i = 0; i < count; i++) { int name_index = buf.readU32(); int kind = buf.readU8(); int tag = kind & 0x0f; AbcData.Trait new_trait = null; switch (tag) { case ActionBlockConstants.TRAIT_Var: case ActionBlockConstants.TRAIT_Const: { int slot_id = buf.readU32(); int trait_type = buf.readU32(); int value_index = buf.readU32(); int value_kind = 0; if( value_index > 0 ) value_kind = buf.readU8(); new_trait = this.new Trait(name_index, kind, new int[] { slot_id, trait_type, value_index, value_kind}); break; } case ActionBlockConstants.TRAIT_Method: case ActionBlockConstants.TRAIT_Getter: case ActionBlockConstants.TRAIT_Setter: { int disp_id = buf.readU32(); int method = buf.readU32(); new_trait = this.new Trait(name_index, kind, new int[] {disp_id, method} ); break; } case ActionBlockConstants.TRAIT_Class: case ActionBlockConstants.TRAIT_Function: { int slot_id = buf.readU32(); int class_id = buf.readU32(); new_trait = this.new Trait(name_index, kind, new int[] { slot_id, class_id } ); break; } default: break; //throw new DecoderException("Invalid trait kind: " + kind); } assert(new_trait != null); result[i] = new_trait; if( new_trait.hasMetadata() ) { int metadata_count = buf.readU32(); int[] metadata = new int[metadata_count]; for ( int j = 0; j < metadata_count; j++) metadata[j] = buf.readU32(); new_trait.addMetadata(metadata); } } return result; } }