| /* |
| * |
| * 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.CONSTANT_Decimal; |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.CONSTANT_Double; |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.CONSTANT_ExplicitNamespace; |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.CONSTANT_False; |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.CONSTANT_Integer; |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.CONSTANT_Multiname; |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.CONSTANT_MultinameA; |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.CONSTANT_MultinameL; |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.CONSTANT_MultinameLA; |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.CONSTANT_TypeName; |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.CONSTANT_Namespace; |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.CONSTANT_Namespace_Set; |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.CONSTANT_Null; |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.CONSTANT_PackageInternalNs; |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.CONSTANT_PackageNamespace; |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.CONSTANT_PrivateNamespace; |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.CONSTANT_ProtectedNamespace; |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.CONSTANT_Qname; |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.CONSTANT_QnameA; |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.CONSTANT_RTQname; |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.CONSTANT_RTQnameA; |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.CONSTANT_RTQnameL; |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.CONSTANT_RTQnameLA; |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.CONSTANT_StaticProtectedNs; |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.CONSTANT_True; |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.CONSTANT_UInteger; |
| import static macromedia.asc.embedding.avmplus.ActionBlockConstants.CONSTANT_Utf8; |
| |
| import java.io.IOException; |
| import java.io.OutputStream; |
| import java.util.ArrayList; |
| |
| import macromedia.asc.util.Decimal128; |
| import macromedia.asc.util.IntegerPool; |
| import macromedia.asc.util.IntList; |
| |
| |
| /** |
| * Constant { |
| * U8 kind |
| * union { |
| * kind=1 { // CONSTANT_utf8 |
| * U16 length |
| * U8[length] |
| * } |
| * kind=2 { // CONSTANT_Decimal |
| * U8[16] value |
| * } |
| * kind=3 { // CONSTANT_Integer |
| * S32 value |
| * } |
| * kind=4 { // CONSTANT_UInteger |
| * U32 value |
| * } |
| * kind=6 { // CONSTANT_Double |
| * U64 doublebits (little endian) |
| * } |
| * 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 |
| * } |
| * } |
| * |
| * @author Clement Wong |
| */ |
| public class ConstantPool |
| { |
| public static final Object NULL = new Object(); |
| |
| public boolean poolHasDecimal; |
| |
| public static ConstantPool merge(ConstantPool[] pools) |
| { |
| // create a new ConstantPool big enough for the combined pools. |
| int preferredSize = 0; |
| boolean hasDecimal = false; |
| |
| for (int i = 0, size = pools.length; i < size; i++) |
| { |
| if (pools[i].decimalpositions.length > 0) |
| hasDecimal = true; |
| preferredSize += pools[i].mnEnd; |
| } |
| |
| ConstantPool newPool = new ConstantPool(hasDecimal); // make room for decimal in the one we create |
| newPool.in = new BytecodeBuffer(preferredSize); |
| newPool.history = new IndexHistory(pools, hasDecimal); |
| |
| return newPool; |
| } |
| |
| ConstantPool(boolean hasDecimal) |
| { |
| poolHasDecimal = hasDecimal; |
| } |
| |
| public ConstantPool(BytecodeBuffer in, boolean hasDecimal) throws DecoderException |
| { |
| this.in = in; |
| poolHasDecimal = hasDecimal; |
| scan(); |
| } |
| |
| private void scan() throws DecoderException |
| { |
| intpositions = Scanner.scanIntConstants(in); |
| intEnd = in.pos(); |
| uintpositions = Scanner.scanUIntConstants(in); |
| uintEnd = in.pos(); |
| doublepositions = Scanner.scanDoubleConstants(in); |
| doubleEnd = in.pos(); |
| if (poolHasDecimal) { |
| decimalpositions = Scanner.scanDecimalConstants(in); |
| decimalEnd = in.pos(); |
| } else { |
| decimalpositions = new int[0]; |
| decimalEnd = in.pos(); |
| } |
| strpositions = Scanner.scanStrConstants(in); |
| strEnd = in.pos(); |
| nspositions = Scanner.scanNsConstants(in); |
| nsEnd = in.pos(); |
| nsspositions = Scanner.scanNsSetConstants(in); |
| nssEnd = in.pos(); |
| mnpositions = Scanner.scanMultinameConstants(in); |
| mnEnd = in.pos(); |
| |
| size = ((intpositions.length == 0) ? 0 : (intpositions.length - 1)) + |
| ((uintpositions.length == 0) ? 0: (uintpositions.length - 1)) + |
| ((doublepositions.length == 0) ? 0 : (doublepositions.length - 1)) + |
| ((decimalpositions.length == 0) ? 0 : (decimalpositions.length - 1)) + |
| ((strpositions.length == 0) ? 0 : (strpositions.length - 1)) + |
| ((nspositions.length == 0) ? 0 : (nspositions.length - 1)) + |
| ((nsspositions.length == 0) ? 0 : (nsspositions.length - 1)) + |
| ((mnpositions.length == 0) ? 0 : (mnpositions.length - 1)); |
| } |
| |
| BytecodeBuffer in; |
| IndexHistory history; |
| private int size; |
| |
| int[] intpositions; |
| int[] uintpositions; |
| int[] doublepositions; |
| int[] decimalpositions; |
| int[] strpositions; |
| int[] nspositions; |
| int[] nsspositions; |
| int[] mnpositions; |
| |
| int intEnd; |
| int uintEnd; |
| int doubleEnd; |
| int decimalEnd; |
| int strEnd; |
| int nsEnd; |
| int nssEnd; |
| int mnEnd; |
| |
| public int size() |
| { |
| return size; |
| } |
| |
| public int getInt(int index) |
| { |
| if (index == 0) |
| { |
| return 0; |
| } |
| |
| int pos = intpositions[index]; |
| int originalPos = in.pos(); |
| in.seek(pos); |
| |
| int value = in.readU32(); |
| in.seek(originalPos); |
| return value; |
| |
| } |
| |
| public long getLong(int index) |
| { |
| if (index == 0) |
| { |
| return 0; |
| } |
| |
| int pos = uintpositions[index]; |
| int originalPos = in.pos(); |
| in.seek(pos); |
| long value = in.readU32(); |
| in.seek(originalPos); |
| return value; |
| } |
| |
| public double getDouble(int index) |
| { |
| if (index == 0) |
| { |
| return 0; |
| } |
| |
| int pos = doublepositions[index]; |
| int originalPos = in.pos(); |
| in.seek(pos); |
| double value = in.readDouble(); |
| in.seek(originalPos); |
| return value; |
| } |
| |
| public Decimal128 getDecimal(int index) |
| { |
| if (index == 0) |
| { |
| return Decimal128.ZERO; |
| } |
| |
| int pos = decimalpositions[index]; |
| int originalPos = in.pos(); |
| in.seek(pos); |
| byte[] valbytes = in.readBytes(16); |
| in.seek(originalPos); |
| return new Decimal128(valbytes); // perhaps need to change endian |
| } |
| |
| public String getString(int index) throws DecoderException |
| { |
| if (index == 0) |
| { |
| return null; |
| } |
| |
| int pos = strpositions[index]; |
| int originalPos = in.pos(); |
| in.seek(pos); |
| String value = in.readString(in.readU32()); |
| in.seek(originalPos); |
| if (value != null) |
| { |
| return value; |
| } |
| else |
| { |
| throw new DecoderException("abc Decoder Erro: problem reading UTF-8 encoded strings."); |
| } |
| } |
| |
| public String getNamespaceName(int index) throws DecoderException |
| { |
| if( index == 0 ) |
| { |
| return null; |
| } |
| int pos = nspositions[index]; |
| int originalPos = in.pos(); |
| in.seek(pos); |
| int kind = in.readU8(); |
| String value = ""; |
| switch(kind) |
| { |
| case CONSTANT_PrivateNamespace: |
| case CONSTANT_Namespace: |
| case CONSTANT_PackageNamespace: |
| case CONSTANT_PackageInternalNs: |
| case CONSTANT_ProtectedNamespace: |
| case CONSTANT_ExplicitNamespace: |
| case CONSTANT_StaticProtectedNs: |
| value = getString(in.readU32()); |
| break; |
| default: |
| throw new DecoderException("abc Decoder Error: constant pool index '" + index + "' is not a Namespace type. The actual type is '" + kind + "'"); |
| } |
| in.seek(originalPos); |
| return value; |
| } |
| |
| public String[] getNamespaceSet(int index) throws DecoderException |
| { |
| if (index == 0) |
| { |
| return null; |
| } |
| |
| int pos = nsspositions[index]; |
| int originalPos = in.pos(); |
| in.seek(pos); |
| int count = in.readU32(); |
| String[] value = new String[count]; |
| for (int j = 0; j < count; j++) |
| { |
| value[j] = getNamespaceName(in.readU32()); |
| } |
| in.seek(originalPos); |
| if (value != null) |
| { |
| return value; |
| } |
| else |
| { |
| throw new DecoderException("abc Decoder Erro: problem reading namespace set."); |
| } |
| } |
| |
| public int getNamespaceIndexForQName(int index) throws DecoderException { |
| if (index == 0) |
| { |
| return 0; |
| } |
| |
| int pos = mnpositions[index]; |
| int originalPos = in.pos(); |
| in.seek(pos); |
| int kind = in.readU8(); |
| |
| switch (kind) |
| { |
| case CONSTANT_Qname: |
| case CONSTANT_QnameA: |
| int namespaceIndex = in.readU32(); |
| in.seek(originalPos); |
| return namespaceIndex; |
| default: |
| in.seek(originalPos); |
| throw new DecoderException("abc Decoder Error: constant pool index '" + index + "' is not a QName type. The actual type is '" + kind + "'"); |
| } |
| } |
| |
| public int getNamespaceKind(int namespaceIndex) { |
| if(namespaceIndex == 0) |
| return -1; |
| |
| int pos = nspositions[namespaceIndex]; |
| int originalPos = in.pos(); |
| in.seek(pos); |
| int kind = in.readU8(); |
| in.seek(originalPos); |
| return kind; |
| } |
| |
| public QName getQName(int index) throws DecoderException |
| { |
| if (index == 0) |
| { |
| return null; |
| } |
| |
| int pos = mnpositions[index]; |
| int originalPos = in.pos(); |
| in.seek(pos); |
| int kind = in.readU8(); |
| |
| switch (kind) |
| { |
| case CONSTANT_Qname: |
| case CONSTANT_QnameA: |
| { |
| int namespaceIndex = in.readU32(); |
| int nameIndex = in.readU32(); |
| QName value = createQName(getNamespaceName(namespaceIndex), getString(nameIndex)); |
| in.seek(originalPos); |
| return value; |
| } |
| case CONSTANT_TypeName: |
| { |
| int nameIndex = in.readU32(); |
| int count = in.readU32(); |
| String params = ".<"; |
| QName base = getQName(nameIndex); |
| for(int i = 0; i < count; ++i) |
| { |
| params += (i>0?",":"") + getQName(in.readU32()); |
| } |
| params+=">"; |
| QName value = createQName(base.getNamespace(), base.getLocalPart()+params); |
| in.seek(originalPos); |
| return value; |
| } |
| default: |
| in.seek(originalPos); |
| throw new DecoderException("abc Decoder Error: constant pool index '" + index + "' is not a QName type. The actual type is '" + kind + "'"); |
| } |
| } |
| |
| public MultiName getMultiName(int index) throws DecoderException |
| { |
| if (index == 0) |
| { |
| return null; |
| } |
| |
| int pos = mnpositions[index]; |
| int originalPos = in.pos(); |
| in.seek(pos); |
| int kind = in.readU8(); |
| |
| switch (kind) |
| { |
| case CONSTANT_Multiname: |
| case CONSTANT_MultinameA: |
| String name = getString(in.readU32()); |
| int namespace_set = in.readU32(); |
| String[] namespaces = getNamespaceSet(namespace_set); |
| MultiName value = createMultiName(name, namespaces); |
| in.seek(originalPos); |
| return value; |
| default: |
| in.seek(originalPos); |
| throw new DecoderException("abc Decoder Error: constant constantPool index '" + index + "' is not a MultiName type. The actual type is '" + kind + "'"); |
| } |
| } |
| |
| public Object getGeneralMultiname(int index) throws DecoderException |
| { |
| if (index == 0) |
| { |
| return null; |
| } |
| |
| int pos = mnpositions[index]; |
| int originalPos = in.pos(); |
| in.seek(pos); |
| int kind = in.readU8(); |
| |
| switch (kind) |
| { |
| case CONSTANT_Qname: |
| case CONSTANT_QnameA: |
| { |
| int namespaceIndex = in.readU32(); |
| int nameIndex = in.readU32(); |
| QName value = createQName(getNamespaceName(namespaceIndex), getString(nameIndex)); |
| in.seek(originalPos); |
| return value; |
| } |
| case CONSTANT_Multiname: |
| case CONSTANT_MultinameA: |
| { |
| String name = getString(in.readU32()); |
| int namespace_set = in.readU32(); |
| String[] namespaces = getNamespaceSet(namespace_set); |
| MultiName value = createMultiName(name, namespaces); |
| in.seek(originalPos); |
| return value; |
| } |
| case CONSTANT_RTQnameL: |
| in.seek(originalPos); |
| return "CONSTANT_RTQnameL"; // Boolean.FALSE; |
| case CONSTANT_RTQnameLA: |
| in.seek(originalPos); |
| return "CONSTANT_RTQnameLA"; // Boolean.TRUE; |
| case CONSTANT_MultinameL: |
| case CONSTANT_MultinameLA: |
| { |
| int namespacesetIndex = in.readU32(); |
| String[] value = getNamespaceSet(namespacesetIndex); |
| ArrayList<String> a = new ArrayList<String>(); |
| for (int k = 0; k < value.length; k++) |
| { |
| a.add(value[k]); |
| } |
| in.seek(originalPos); |
| return a; |
| } |
| case CONSTANT_RTQname: |
| case CONSTANT_RTQnameA: |
| { |
| int idx = in.readU32(); |
| String s = getString(idx); |
| in.seek(originalPos); |
| return s; |
| } |
| default: |
| in.seek(originalPos); |
| throw new DecoderException("abc Decoder Error: constant pool index '" + index + "' is not a QName type. The actual type is '" + kind + "'"); |
| } |
| } |
| |
| public Object get(int index, int kind) throws DecoderException |
| { |
| if (index == 0) |
| { |
| return null; |
| } |
| |
| Object value; |
| switch(kind) |
| { |
| case CONSTANT_Utf8: |
| value = getString(index); |
| return value; |
| case CONSTANT_Integer: |
| value = createInteger(getInt(index)); |
| return value; |
| case CONSTANT_UInteger: |
| value = createLong(getLong(index)); |
| return value; |
| case CONSTANT_Double: |
| value = createDouble(getDouble(index)); |
| return value; |
| case CONSTANT_Decimal: |
| value = getDecimal(index); |
| return value; |
| case CONSTANT_Qname: |
| case CONSTANT_QnameA: |
| value = getQName(index); |
| return value; |
| case CONSTANT_Namespace: |
| case CONSTANT_PrivateNamespace: |
| case CONSTANT_PackageNamespace: |
| case CONSTANT_PackageInternalNs: |
| case CONSTANT_ProtectedNamespace: |
| case CONSTANT_ExplicitNamespace: |
| case CONSTANT_StaticProtectedNs: |
| value = getNamespaceName(index); |
| return value; |
| case CONSTANT_Multiname: |
| case CONSTANT_MultinameA: |
| value = getMultiName(index); |
| return value; |
| case CONSTANT_False: |
| value = Boolean.FALSE; |
| return value; |
| case CONSTANT_True: |
| value = Boolean.TRUE ; |
| return value; |
| case CONSTANT_Null: |
| value = NULL; |
| return value; |
| case CONSTANT_RTQname: |
| case CONSTANT_RTQnameA: |
| value = getGeneralMultiname(index); |
| return value; |
| case CONSTANT_RTQnameL: |
| value = "CONSTANT_RTQnameL"; // Boolean.FALSE; |
| return value; |
| case CONSTANT_RTQnameLA: |
| value = "CONSTANT_RTQnameLA"; // Boolean.TRUE; |
| return value; |
| case CONSTANT_MultinameL: |
| value = getNamespaceSet(getInt(index)); |
| return value; |
| case CONSTANT_MultinameLA: |
| value = getNamespaceSet(getInt(index)); |
| return value; |
| case CONSTANT_Namespace_Set: |
| value = getNamespaceSet(index); |
| return value; |
| default: |
| throw new DecoderException("Error: Unhandled constant type - " + kind); |
| } |
| } |
| |
| private Integer createInteger(int number) |
| { |
| return IntegerPool.getNumber(number); |
| } |
| |
| private Long createLong(long number) |
| { |
| return new Long(number); |
| } |
| |
| private Double createDouble(double number) |
| { |
| return new Double(number); |
| } |
| |
| private QName createQName(String ns, String name) |
| { |
| return new QName(ns, name); |
| } |
| |
| private MultiName createMultiName(String name, String[] ns) |
| { |
| return new MultiName(name, ns); |
| } |
| |
| public void writeTo(OutputStream out) throws IOException |
| { |
| history.writeTo(in); |
| in.writeTo(out); |
| } |
| } |
| |
| final class IndexHistory |
| { |
| public static final int cp_int = 0; |
| public static final int cp_uint = 1; |
| public static final int cp_double = 2; |
| public static final int cp_decimal = 3; |
| public static final int cp_string = 4; |
| public static final int cp_ns = 5; |
| public static final int cp_nsset = 6; |
| public static final int cp_mn = 7; |
| |
| IndexHistory(ConstantPool[] pools, boolean poolHasDecimal) |
| { |
| this.pools = pools; |
| poolSizes = new int[pools.length]; |
| hasDecimal = poolHasDecimal; |
| |
| int size = 0, preferredSize = 0; |
| for (int i = 0, length = pools.length; i < length; i++) |
| { |
| poolSizes[i] = (i == 0) ? 0 : size; |
| size += pools[i].size(); |
| preferredSize += (pools[i].mnEnd - pools[i].strEnd); |
| } |
| |
| map = new int[size]; |
| in_ns = new BytecodeBuffer(preferredSize); |
| in_nsset = new BytecodeBuffer(preferredSize); |
| in_mn = new BytecodeBuffer(preferredSize); |
| |
| intP = new ByteArrayPool(); |
| uintP = new ByteArrayPool(); |
| doubleP = new ByteArrayPool(); |
| if (hasDecimal) |
| decimalP = new ByteArrayPool(); |
| stringP = new ByteArrayPool(); |
| nsP = new NSPool(); |
| nssP = new NSSPool(); |
| mnP = new MultiNamePool(); |
| |
| total = 0; |
| duplicate = 0; |
| totalBytes = 0; |
| duplicateBytes = 0; |
| |
| // nss = new HashSet<Integer>(); |
| } |
| |
| public int total, duplicate, totalBytes, duplicateBytes; |
| |
| private ConstantPool[] pools; |
| private int[] poolSizes; |
| private int[] map; |
| |
| private boolean hasDecimal; |
| |
| private ByteArrayPool intP, uintP, doubleP, decimalP, stringP, nsP, nssP, mnP; |
| private BytecodeBuffer in_ns, in_nsset, in_mn; |
| // private Set<Integer> nss; |
| |
| // Needed so we can strip out the index for all CONSTANT_PrivateNamespace entries |
| // since the name for private namespaces is not important |
| private boolean disableDebuggingInfo = false; |
| void disableDebugging() |
| { |
| disableDebuggingInfo = true; |
| } |
| |
| |
| public int getIndex(int poolIndex, int kind, int index) |
| { |
| if (index == 0) |
| { |
| return 0; |
| } |
| else |
| { |
| int newIndex = calculateIndex(poolIndex, kind, index); |
| |
| if (map[newIndex] == 0) |
| { |
| decodeOnDemand(poolIndex, kind, index, newIndex); |
| } |
| |
| return map[newIndex]; |
| } |
| } |
| |
| public void writeTo(BytecodeBuffer b) |
| { |
| intP.writeTo(b); |
| uintP.writeTo(b); |
| doubleP.writeTo(b); |
| if (hasDecimal) |
| decimalP.writeTo(b); |
| stringP.writeTo(b); |
| nsP.writeTo(b); |
| nssP.writeTo(b); |
| mnP.writeTo(b); |
| } |
| |
| /** |
| * @param poolIndex 0-based |
| * @param kind 0-based |
| * @param oldIndex 1-based |
| */ |
| private final int calculateIndex(final int poolIndex, final int kind, final int oldIndex) |
| { |
| int index = poolSizes[poolIndex]; |
| |
| if (kind > cp_int) |
| { |
| index += (pools[poolIndex].intpositions.length == 0) ? 0 : (pools[poolIndex].intpositions.length - 1); |
| } |
| |
| if (kind > cp_uint) |
| { |
| index += (pools[poolIndex].uintpositions.length == 0) ? 0 : (pools[poolIndex].uintpositions.length - 1); |
| } |
| |
| if (kind > cp_double) |
| { |
| index += (pools[poolIndex].doublepositions.length == 0) ? 0 : (pools[poolIndex].doublepositions.length - 1); |
| } |
| |
| if (hasDecimal && (kind > cp_decimal)) |
| { |
| index += (pools[poolIndex].decimalpositions.length == 0) ? 0 : (pools[poolIndex].decimalpositions.length - 1); |
| } |
| |
| if (kind > cp_string) |
| { |
| index += (pools[poolIndex].strpositions.length == 0) ? 0 : (pools[poolIndex].strpositions.length - 1); |
| } |
| |
| if (kind > cp_ns) |
| { |
| index += (pools[poolIndex].nspositions.length == 0) ? 0 : (pools[poolIndex].nspositions.length - 1); |
| } |
| |
| if (kind > cp_nsset) |
| { |
| index += (pools[poolIndex].nsspositions.length == 0) ? 0 : (pools[poolIndex].nsspositions.length - 1); |
| } |
| |
| if (kind > cp_mn) |
| { |
| index += (pools[poolIndex].mnpositions.length == 0) ? 0 : (pools[poolIndex].mnpositions.length - 1); |
| } |
| |
| index += (oldIndex - 1); |
| |
| return index; |
| } |
| |
| private final void decodeOnDemand(final int poolIndex, final int kind, final int j, final int j2) |
| { |
| ConstantPool pool = pools[poolIndex]; |
| ByteArrayPool baPool = null; |
| BytecodeBuffer poolIn = null; |
| int[] positions = null; |
| int length = 0, endPos = 0; |
| |
| if (kind == cp_int) |
| { |
| positions = pool.intpositions; |
| length = positions.length; |
| endPos = pool.intEnd; |
| baPool = intP; |
| poolIn = pool.in; |
| } |
| else if (kind == cp_uint) |
| { |
| positions = pool.uintpositions; |
| length = positions.length; |
| endPos = pool.uintEnd; |
| baPool = uintP; |
| poolIn = pool.in; |
| } |
| else if (kind == cp_double) |
| { |
| positions = pool.doublepositions; |
| length = positions.length; |
| endPos = pool.doubleEnd; |
| baPool = doubleP; |
| poolIn = pool.in; |
| } |
| else if (kind == cp_decimal) |
| { |
| assert(hasDecimal); |
| positions = pool.decimalpositions; |
| length = positions.length; |
| endPos = pool.decimalEnd; |
| baPool = decimalP; |
| poolIn = pool.in; |
| } |
| else if (kind == cp_string) |
| { |
| positions = pool.strpositions; |
| length = positions.length; |
| endPos = pool.strEnd; |
| baPool = stringP; |
| poolIn = pool.in; |
| } |
| else if (kind == cp_ns) |
| { |
| positions = pool.nspositions; |
| length = positions.length; |
| endPos = pool.nsEnd; |
| baPool = nsP; |
| poolIn = pool.in; |
| } |
| else if (kind == cp_nsset) |
| { |
| positions = pool.nsspositions; |
| length = positions.length; |
| endPos = pool.nssEnd; |
| baPool = nssP; |
| poolIn = pool.in; |
| } |
| else if (kind == cp_mn) |
| { |
| positions = pool.mnpositions; |
| length = positions.length; |
| endPos = pool.mnEnd; |
| baPool = mnP; |
| poolIn = pool.in; |
| } |
| |
| int start = positions[j]; |
| int end = (j != length - 1) ? positions[j + 1] : endPos; |
| |
| if (kind == cp_ns) |
| { |
| int pos = positions[j]; |
| int originalPos = poolIn.pos(); |
| poolIn.seek(pos); |
| start = in_ns.size(); |
| int nsKind = poolIn.readU8(); |
| in_ns.writeU8(nsKind); |
| switch (nsKind) |
| { |
| case CONSTANT_PrivateNamespace: |
| if( this.disableDebuggingInfo ) |
| { |
| in_ns.writeU32(0); // name not important for private namespace |
| break; |
| } |
| // else fall through and treat like a normal namespace |
| case CONSTANT_Namespace: |
| case CONSTANT_PackageNamespace: |
| case CONSTANT_PackageInternalNs: |
| case CONSTANT_ProtectedNamespace: |
| case CONSTANT_ExplicitNamespace: |
| case CONSTANT_StaticProtectedNs: |
| int index = poolIn.readU32(); |
| int newIndex = getIndex(poolIndex, cp_string, index); |
| in_ns.writeU32(newIndex); |
| break; |
| default: |
| assert false; // can't possibly happen... |
| } |
| poolIn.seek(originalPos); |
| end = in_ns.size(); |
| poolIn = in_ns; |
| } |
| else if (kind == cp_nsset) |
| { |
| int pos = positions[j]; |
| int originalPos = poolIn.pos(); |
| poolIn.seek(pos); |
| start = in_nsset.size(); |
| |
| /* |
| nss.clear(); |
| int count = (int) poolIn.readU32(); |
| for (int k = 0; k < count; k++) |
| { |
| nss.add((int) poolIn.readU32()); |
| } |
| count = nss.size(); |
| in5.writeU32(count); |
| for (Iterator<Integer> k = nss.iterator(); k.hasNext();) |
| { |
| int index = k.next(); |
| int newIndex = getIndex(poolIndex, 4, index); |
| in_nsset.writeU32(newIndex); |
| } |
| */ |
| |
| int count = poolIn.readU32(); |
| in_nsset.writeU32(count); |
| for (int k = 0; k < count; k++) |
| { |
| int index = poolIn.readU32(); |
| int newIndex = getIndex(poolIndex, cp_ns, index); |
| in_nsset.writeU32(newIndex); |
| } |
| |
| poolIn.seek(originalPos); |
| end = in_nsset.size(); |
| poolIn = in_nsset; |
| } |
| else if (kind == cp_mn) |
| { |
| int pos = positions[j]; |
| int originalPos = poolIn.pos(); |
| poolIn.seek(pos); |
| start = in_mn.size(); |
| int constKind = poolIn.readU8(); |
| if( !(constKind==CONSTANT_TypeName)) |
| in_mn.writeU8(constKind); |
| |
| switch (constKind) |
| { |
| case CONSTANT_Qname: |
| case CONSTANT_QnameA: |
| { |
| int namespaceIndex = poolIn.readU32(); |
| int newNamespaceIndex = getIndex(poolIndex, cp_ns, namespaceIndex); |
| in_mn.writeU32(newNamespaceIndex); |
| int nameIndex = poolIn.readU32(); |
| int newNameIndex = getIndex(poolIndex, cp_string, nameIndex); |
| in_mn.writeU32(newNameIndex); |
| break; |
| } |
| case CONSTANT_Multiname: |
| case CONSTANT_MultinameA: |
| { |
| int nameIndex = poolIn.readU32(); |
| int newNameIndex = getIndex(poolIndex, cp_string, nameIndex); |
| in_mn.writeU32(newNameIndex); |
| int namespace_set = poolIn.readU32(); |
| int newNamespace_set = getIndex(poolIndex, cp_nsset, namespace_set); |
| in_mn.writeU32(newNamespace_set); |
| break; |
| } |
| case CONSTANT_RTQname: |
| case CONSTANT_RTQnameA: |
| { |
| int index = poolIn.readU32(); |
| int newIndex = getIndex(poolIndex, cp_string, index); |
| in_mn.writeU32(newIndex); |
| break; |
| } |
| case CONSTANT_RTQnameL: |
| case CONSTANT_RTQnameLA: |
| break; |
| case CONSTANT_MultinameL: |
| case CONSTANT_MultinameLA: |
| { |
| int namespace_set = poolIn.readU32(); |
| int newNamespace_set = getIndex(poolIndex, cp_nsset, namespace_set); |
| in_mn.writeU32(newNamespace_set); |
| break; |
| } |
| case CONSTANT_TypeName: |
| { |
| int nameIndex = poolIn.readU32(); |
| int newNameIndex = getIndex(poolIndex, cp_mn, nameIndex); |
| int count = poolIn.readU32(); |
| IntList newParams = new IntList(); |
| for( int i = 0; i<count;++i) { |
| newParams.add(getIndex(poolIndex, cp_mn, poolIn.readU32())); |
| } |
| start = in_mn.size(); |
| in_mn.writeU8(constKind); |
| in_mn.writeU32(newNameIndex); |
| in_mn.writeU32(count); |
| for( int i =0; i < count; ++i ) { |
| in_mn.writeU32(newParams.at(i)); |
| } |
| break; |
| } |
| |
| default: |
| assert false; // can't possibly happen... |
| } |
| |
| poolIn.seek(originalPos); |
| end = in_mn.size(); |
| poolIn = in_mn; |
| } |
| |
| int newIndex = baPool.contains(poolIn, start, end); |
| if (newIndex == -1) |
| { |
| newIndex = baPool.store(poolIn, start, end); |
| } |
| else |
| { |
| duplicate++; |
| duplicateBytes += (end - start); |
| } |
| |
| total++; |
| totalBytes += (end - start); |
| |
| if (j != 0) |
| { |
| map[j2] = newIndex; |
| } |
| } |
| } |
| |
| final class NSPool extends ByteArrayPool |
| { |
| NSPool() |
| { |
| super(); |
| } |
| |
| ByteArray newByteArray() |
| { |
| return new NS(); |
| } |
| } |
| |
| final class NS extends ByteArray |
| { |
| int nsKind = 0, index = 0; |
| |
| void init() |
| { |
| super.init(); |
| |
| int originalPos = b.pos(); |
| b.seek(start); |
| nsKind = b.readU8(); |
| switch (nsKind) |
| { |
| case CONSTANT_PrivateNamespace: |
| case CONSTANT_Namespace: |
| case CONSTANT_PackageNamespace: |
| case CONSTANT_PackageInternalNs: |
| case CONSTANT_ProtectedNamespace: |
| case CONSTANT_ExplicitNamespace: |
| case CONSTANT_StaticProtectedNs: |
| index = b.readU32(); |
| break; |
| default: |
| assert false; // can't possibly happen... |
| } |
| b.seek(originalPos); |
| |
| long num = 1234 ^ nsKind ^ index; |
| hash = (int) ((num >> 32) ^ num); |
| } |
| |
| void clear() |
| { |
| super.clear(); |
| nsKind = 0; |
| index = 0; |
| } |
| |
| public boolean equals(Object obj) |
| { |
| boolean equal = false; |
| if (obj instanceof NS) |
| { |
| NS ns = (NS) obj; |
| if( this.nsKind == CONSTANT_PrivateNamespace ) |
| { |
| // Private namespaces are only equal if they are literally the same namespace, |
| // the name is not important. |
| equal = (this.b == ns.b) && (this.start == ns.start) && (this.end == ns.end); |
| } |
| else |
| { |
| equal = (ns.nsKind == this.nsKind) && (ns.index == this.index); |
| } |
| } |
| return equal; |
| } |
| } |
| |
| |
| final class NSSPool extends ByteArrayPool |
| { |
| NSSPool() |
| { |
| super(); |
| } |
| |
| ByteArray newByteArray() |
| { |
| return new NSS(); |
| } |
| } |
| |
| final class NSS extends ByteArray |
| { |
| int[] set = null; |
| int size = 0; |
| |
| void init() |
| { |
| super.init(); |
| |
| int originalPos = b.pos(); |
| b.seek(start); |
| int count = b.readU32(); |
| |
| if (set == null || count > set.length) |
| { |
| set = new int[count]; |
| } |
| size = count; |
| |
| for (int k = 0; k < count; k++) |
| { |
| set[k] = b.readU32(); |
| } |
| b.seek(originalPos); |
| |
| long num = 1234; |
| for (int k = 0; k < count; k++) |
| { |
| num ^= set[k]; |
| } |
| hash = (int) ((num >> 32) ^ num); |
| } |
| |
| void clear() |
| { |
| super.clear(); |
| size = 0; |
| } |
| |
| public boolean equals(Object obj) |
| { |
| if (obj instanceof NSS) |
| { |
| NSS nss = (NSS) obj; |
| if (size == nss.size) |
| { |
| for (int i = 0; i < size; i++) |
| { |
| if (set[i] != nss.set[i]) |
| { |
| return false; |
| } |
| } |
| return true; |
| } |
| else |
| { |
| return false; |
| } |
| } |
| else |
| { |
| return false; |
| } |
| } |
| } |
| |
| final class MultiNamePool extends ByteArrayPool |
| { |
| MultiNamePool() |
| { |
| super(); |
| } |
| |
| ByteArray newByteArray() |
| { |
| return new MN(); |
| } |
| } |
| |
| final class MN extends ByteArray |
| { |
| int constKind = 0, index1 = 1, index2 = 1; |
| |
| void init() |
| { |
| super.init(); |
| |
| int originalPos = b.pos(); |
| b.seek(start); |
| constKind = b.readU8(); |
| |
| switch (constKind) |
| { |
| case CONSTANT_Qname: |
| case CONSTANT_QnameA: |
| { |
| index1 = b.readU32(); |
| index2 = b.readU32(); |
| long num = 1234 ^ constKind ^ index1 ^ index2; |
| hash = (int) ((num >> 32) ^ num); |
| break; |
| } |
| case CONSTANT_Multiname: |
| case CONSTANT_MultinameA: |
| { |
| index1 = b.readU32(); |
| index2 = b.readU32(); |
| long num = 1234 ^ constKind ^ index1 ^ index2; |
| hash = (int) ((num >> 32) ^ num); |
| break; |
| } |
| case CONSTANT_RTQname: |
| case CONSTANT_RTQnameA: |
| { |
| index1 = b.readU32(); |
| long num = 1234 ^ constKind ^ index1; |
| hash = (int) ((num >> 32) ^ num); |
| break; |
| } |
| case CONSTANT_RTQnameL: |
| case CONSTANT_RTQnameLA: |
| { |
| long num = 1234 ^ constKind; |
| hash = (int) ((num >> 32) ^ num); |
| break; |
| } |
| case CONSTANT_MultinameL: |
| case CONSTANT_MultinameLA: |
| { |
| index1 = b.readU32(); |
| long num = 1234 ^ constKind ^ index1; |
| hash = (int) ((num >> 32) ^ num); |
| break; |
| } |
| case CONSTANT_TypeName: |
| { |
| index1 = b.readU32(); |
| int count = b.readU32(); |
| // Only 1 typeparam for now. |
| index2 = b.readU32(); |
| long num = 1234 ^ constKind ^ index1 ^ index2; |
| hash = (int) ((num >> 32) ^ num); |
| break; |
| } |
| default: |
| assert false; // can't possibly happen... |
| } |
| |
| b.seek(originalPos); |
| } |
| |
| void clear() |
| { |
| super.clear(); |
| constKind = 0; |
| index1 = 0; |
| index2 = 0; |
| } |
| |
| public boolean equals(Object obj) |
| { |
| if (obj instanceof MN) |
| { |
| MN mn = (MN) obj; |
| |
| switch (constKind) |
| { |
| case CONSTANT_Qname: |
| case CONSTANT_QnameA: |
| case CONSTANT_Multiname: |
| case CONSTANT_MultinameA: |
| { |
| return (constKind == mn.constKind) && (index1 == mn.index1) && (index2 == mn.index2); |
| } |
| case CONSTANT_RTQname: |
| case CONSTANT_RTQnameA: |
| { |
| return (constKind == mn.constKind) && (index1 == mn.index1); |
| } |
| case CONSTANT_RTQnameL: |
| case CONSTANT_RTQnameLA: |
| return (constKind == mn.constKind); |
| case CONSTANT_MultinameL: |
| case CONSTANT_MultinameLA: |
| { |
| return (constKind == mn.constKind) && (index1 == mn.index1); |
| } |
| case CONSTANT_TypeName: |
| { |
| return ( constKind == mn.constKind && index1 == mn.index1 && index2 == mn.index2 ); |
| } |
| default: |
| return false; |
| } |
| } |
| else |
| { |
| return false; |
| } |
| } |
| } |
