| /* |
| * |
| * 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<String, AbcData> cache; |
| private boolean dirty; |
| |
| private File file; |
| |
| AbcDataCache(File f) |
| { |
| cache = new HashMap<String,AbcData>(); |
| 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<String,AbcData>)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<Integer> 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<Integer> getVersion(String uri) |
| { |
| if (uri.length() == 0) |
| return null; |
| |
| int last = uri.codePointAt(uri.length()-1); |
| if(last >= 0xE000 && last <= 0xF000) |
| { |
| Set<Integer> result = new TreeSet<Integer>(); |
| 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<Integer> 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, Set<Integer>versions) |
| { |
| 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; |
| } |
| |
| |
| |
| } |
