8214971: Replace use of string.equals("") with isEmpty()
Reviewed-by: jlaskey, prappo, lancea, dfuchs, redestad
/*
* Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.sun.java.util.jar.pack;
import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Set;
import static com.sun.java.util.jar.pack.Constants.*;
/**
* Representation of constant pool entries and indexes.
* @author John Rose
*/
abstract
class ConstantPool {
private ConstantPool() {} // do not instantiate
static int verbose() {
return Utils.currentPropMap().getInteger(Utils.DEBUG_VERBOSE);
}
/** Factory for Utf8 string constants.
* Used for well-known strings like "SourceFile", "<init>", etc.
* Also used to back up more complex constant pool entries, like Class.
*/
public static synchronized Utf8Entry getUtf8Entry(String value) {
Map<String, Utf8Entry> utf8Entries = Utils.getTLGlobals().getUtf8Entries();
Utf8Entry e = utf8Entries.get(value);
if (e == null) {
e = new Utf8Entry(value);
utf8Entries.put(e.stringValue(), e);
}
return e;
}
/** Factory for Class constants. */
public static ClassEntry getClassEntry(String name) {
Map<String, ClassEntry> classEntries = Utils.getTLGlobals().getClassEntries();
ClassEntry e = classEntries.get(name);
if (e == null) {
e = new ClassEntry(getUtf8Entry(name));
assert(name.equals(e.stringValue()));
classEntries.put(e.stringValue(), e);
}
return e;
}
/** Factory for literal constants (String, Integer, etc.). */
public static LiteralEntry getLiteralEntry(Comparable<?> value) {
Map<Object, LiteralEntry> literalEntries = Utils.getTLGlobals().getLiteralEntries();
LiteralEntry e = literalEntries.get(value);
if (e == null) {
if (value instanceof String)
e = new StringEntry(getUtf8Entry((String)value));
else
e = new NumberEntry((Number)value);
literalEntries.put(value, e);
}
return e;
}
/** Factory for literal constants (String, Integer, etc.). */
public static StringEntry getStringEntry(String value) {
return (StringEntry) getLiteralEntry(value);
}
/** Factory for signature (type) constants. */
public static SignatureEntry getSignatureEntry(String type) {
Map<String, SignatureEntry> signatureEntries = Utils.getTLGlobals().getSignatureEntries();
SignatureEntry e = signatureEntries.get(type);
if (e == null) {
e = new SignatureEntry(type);
assert(e.stringValue().equals(type));
signatureEntries.put(type, e);
}
return e;
}
// Convenience overloading.
public static SignatureEntry getSignatureEntry(Utf8Entry formRef, ClassEntry[] classRefs) {
return getSignatureEntry(SignatureEntry.stringValueOf(formRef, classRefs));
}
/** Factory for descriptor (name-and-type) constants. */
public static DescriptorEntry getDescriptorEntry(Utf8Entry nameRef, SignatureEntry typeRef) {
Map<String, DescriptorEntry> descriptorEntries = Utils.getTLGlobals().getDescriptorEntries();
String key = DescriptorEntry.stringValueOf(nameRef, typeRef);
DescriptorEntry e = descriptorEntries.get(key);
if (e == null) {
e = new DescriptorEntry(nameRef, typeRef);
assert(e.stringValue().equals(key))
: (e.stringValue()+" != "+(key));
descriptorEntries.put(key, e);
}
return e;
}
// Convenience overloading.
public static DescriptorEntry getDescriptorEntry(Utf8Entry nameRef, Utf8Entry typeRef) {
return getDescriptorEntry(nameRef, getSignatureEntry(typeRef.stringValue()));
}
/** Factory for member reference constants. */
public static MemberEntry getMemberEntry(byte tag, ClassEntry classRef, DescriptorEntry descRef) {
Map<String, MemberEntry> memberEntries = Utils.getTLGlobals().getMemberEntries();
String key = MemberEntry.stringValueOf(tag, classRef, descRef);
MemberEntry e = memberEntries.get(key);
if (e == null) {
e = new MemberEntry(tag, classRef, descRef);
assert(e.stringValue().equals(key))
: (e.stringValue()+" != "+(key));
memberEntries.put(key, e);
}
return e;
}
/** Factory for MethodHandle constants. */
public static MethodHandleEntry getMethodHandleEntry(byte refKind, MemberEntry memRef) {
Map<String, MethodHandleEntry> methodHandleEntries = Utils.getTLGlobals().getMethodHandleEntries();
String key = MethodHandleEntry.stringValueOf(refKind, memRef);
MethodHandleEntry e = methodHandleEntries.get(key);
if (e == null) {
e = new MethodHandleEntry(refKind, memRef);
assert(e.stringValue().equals(key));
methodHandleEntries.put(key, e);
}
return e;
}
/** Factory for MethodType constants. */
public static MethodTypeEntry getMethodTypeEntry(SignatureEntry sigRef) {
Map<String, MethodTypeEntry> methodTypeEntries = Utils.getTLGlobals().getMethodTypeEntries();
String key = sigRef.stringValue();
MethodTypeEntry e = methodTypeEntries.get(key);
if (e == null) {
e = new MethodTypeEntry(sigRef);
assert(e.stringValue().equals(key));
methodTypeEntries.put(key, e);
}
return e;
}
public static MethodTypeEntry getMethodTypeEntry(Utf8Entry typeRef) {
return getMethodTypeEntry(getSignatureEntry(typeRef.stringValue()));
}
/** Factory for InvokeDynamic constants. */
public static InvokeDynamicEntry getInvokeDynamicEntry(BootstrapMethodEntry bssRef, DescriptorEntry descRef) {
Map<String, InvokeDynamicEntry> invokeDynamicEntries = Utils.getTLGlobals().getInvokeDynamicEntries();
String key = InvokeDynamicEntry.stringValueOf(bssRef, descRef);
InvokeDynamicEntry e = invokeDynamicEntries.get(key);
if (e == null) {
e = new InvokeDynamicEntry(bssRef, descRef);
assert(e.stringValue().equals(key));
invokeDynamicEntries.put(key, e);
}
return e;
}
/** Factory for BootstrapMethod pseudo-constants. */
public static BootstrapMethodEntry getBootstrapMethodEntry(MethodHandleEntry bsmRef, Entry[] argRefs) {
Map<String, BootstrapMethodEntry> bootstrapMethodEntries = Utils.getTLGlobals().getBootstrapMethodEntries();
String key = BootstrapMethodEntry.stringValueOf(bsmRef, argRefs);
BootstrapMethodEntry e = bootstrapMethodEntries.get(key);
if (e == null) {
e = new BootstrapMethodEntry(bsmRef, argRefs);
assert(e.stringValue().equals(key));
bootstrapMethodEntries.put(key, e);
}
return e;
}
/** Entries in the constant pool. */
public abstract static
class Entry implements Comparable<Object> {
protected final byte tag; // a CONSTANT_foo code
protected int valueHash; // cached hashCode
protected Entry(byte tag) {
this.tag = tag;
}
public final byte getTag() {
return tag;
}
public final boolean tagEquals(int tag) {
return getTag() == tag;
}
public Entry getRef(int i) {
return null;
}
public boolean eq(Entry that) { // same reference
assert(that != null);
return this == that || this.equals(that);
}
// Equality of Entries is value-based.
public abstract boolean equals(Object o);
public final int hashCode() {
if (valueHash == 0) {
valueHash = computeValueHash();
if (valueHash == 0) valueHash = 1;
}
return valueHash;
}
protected abstract int computeValueHash();
public abstract int compareTo(Object o);
protected int superCompareTo(Object o) {
Entry that = (Entry) o;
if (this.tag != that.tag) {
return TAG_ORDER[this.tag] - TAG_ORDER[that.tag];
}
return 0; // subclasses must refine this
}
public final boolean isDoubleWord() {
return tag == CONSTANT_Double || tag == CONSTANT_Long;
}
public final boolean tagMatches(int matchTag) {
if (tag == matchTag)
return true;
byte[] allowedTags;
switch (matchTag) {
case CONSTANT_All:
return true;
case CONSTANT_Signature:
return tag == CONSTANT_Utf8; // format check also?
case CONSTANT_LoadableValue:
allowedTags = LOADABLE_VALUE_TAGS;
break;
case CONSTANT_AnyMember:
allowedTags = ANY_MEMBER_TAGS;
break;
case CONSTANT_FieldSpecific:
allowedTags = FIELD_SPECIFIC_TAGS;
break;
default:
return false;
}
for (byte b : allowedTags) {
if (b == tag)
return true;
}
return false;
}
public String toString() {
String valuePrint = stringValue();
if (verbose() > 4) {
if (valueHash != 0)
valuePrint += " hash="+valueHash;
valuePrint += " id="+System.identityHashCode(this);
}
return tagName(tag)+"="+valuePrint;
}
public abstract String stringValue();
}
public static
class Utf8Entry extends Entry {
final String value;
Utf8Entry(String value) {
super(CONSTANT_Utf8);
this.value = value.intern();
hashCode(); // force computation of valueHash
}
protected int computeValueHash() {
return value.hashCode();
}
public boolean equals(Object o) {
// Use reference equality of interned strings:
return (o != null && o.getClass() == Utf8Entry.class
&& ((Utf8Entry) o).value.equals(value));
}
public int compareTo(Object o) {
int x = superCompareTo(o);
if (x == 0) {
x = value.compareTo(((Utf8Entry)o).value);
}
return x;
}
public String stringValue() {
return value;
}
}
static boolean isMemberTag(byte tag) {
switch (tag) {
case CONSTANT_Fieldref:
case CONSTANT_Methodref:
case CONSTANT_InterfaceMethodref:
return true;
}
return false;
}
static byte numberTagOf(Number value) {
if (value instanceof Integer) return CONSTANT_Integer;
if (value instanceof Float) return CONSTANT_Float;
if (value instanceof Long) return CONSTANT_Long;
if (value instanceof Double) return CONSTANT_Double;
throw new RuntimeException("bad literal value "+value);
}
static boolean isRefKind(byte refKind) {
return (REF_getField <= refKind && refKind <= REF_invokeInterface);
}
public abstract static
class LiteralEntry extends Entry {
protected LiteralEntry(byte tag) {
super(tag);
}
public abstract Comparable<?> literalValue();
}
public static
class NumberEntry extends LiteralEntry {
final Number value;
NumberEntry(Number value) {
super(numberTagOf(value));
this.value = value;
hashCode(); // force computation of valueHash
}
protected int computeValueHash() {
return value.hashCode();
}
public boolean equals(Object o) {
return (o != null && o.getClass() == NumberEntry.class
&& ((NumberEntry) o).value.equals(value));
}
public int compareTo(Object o) {
int x = superCompareTo(o);
if (x == 0) {
@SuppressWarnings("unchecked")
Comparable<Number> compValue = (Comparable<Number>)value;
x = compValue.compareTo(((NumberEntry)o).value);
}
return x;
}
public Number numberValue() {
return value;
}
public Comparable<?> literalValue() {
return (Comparable<?>) value;
}
public String stringValue() {
return value.toString();
}
}
public static
class StringEntry extends LiteralEntry {
final Utf8Entry ref;
public Entry getRef(int i) { return i == 0 ? ref : null; }
StringEntry(Entry ref) {
super(CONSTANT_String);
this.ref = (Utf8Entry) ref;
hashCode(); // force computation of valueHash
}
protected int computeValueHash() {
return ref.hashCode() + tag;
}
public boolean equals(Object o) {
return (o != null && o.getClass() == StringEntry.class &&
((StringEntry)o).ref.eq(ref));
}
public int compareTo(Object o) {
int x = superCompareTo(o);
if (x == 0) {
x = ref.compareTo(((StringEntry)o).ref);
}
return x;
}
public Comparable<?> literalValue() {
return ref.stringValue();
}
public String stringValue() {
return ref.stringValue();
}
}
public static
class ClassEntry extends Entry {
final Utf8Entry ref;
public Entry getRef(int i) { return i == 0 ? ref : null; }
protected int computeValueHash() {
return ref.hashCode() + tag;
}
ClassEntry(Entry ref) {
super(CONSTANT_Class);
this.ref = (Utf8Entry) ref;
hashCode(); // force computation of valueHash
}
public boolean equals(Object o) {
return (o != null && o.getClass() == ClassEntry.class
&& ((ClassEntry) o).ref.eq(ref));
}
public int compareTo(Object o) {
int x = superCompareTo(o);
if (x == 0) {
x = ref.compareTo(((ClassEntry)o).ref);
}
return x;
}
public String stringValue() {
return ref.stringValue();
}
}
public static
class DescriptorEntry extends Entry {
final Utf8Entry nameRef;
final SignatureEntry typeRef;
public Entry getRef(int i) {
if (i == 0) return nameRef;
if (i == 1) return typeRef;
return null;
}
DescriptorEntry(Entry nameRef, Entry typeRef) {
super(CONSTANT_NameandType);
if (typeRef instanceof Utf8Entry) {
typeRef = getSignatureEntry(typeRef.stringValue());
}
this.nameRef = (Utf8Entry) nameRef;
this.typeRef = (SignatureEntry) typeRef;
hashCode(); // force computation of valueHash
}
protected int computeValueHash() {
int hc2 = typeRef.hashCode();
return (nameRef.hashCode() + (hc2 << 8)) ^ hc2;
}
public boolean equals(Object o) {
if (o == null || o.getClass() != DescriptorEntry.class) {
return false;
}
DescriptorEntry that = (DescriptorEntry)o;
return this.nameRef.eq(that.nameRef)
&& this.typeRef.eq(that.typeRef);
}
public int compareTo(Object o) {
int x = superCompareTo(o);
if (x == 0) {
DescriptorEntry that = (DescriptorEntry)o;
// Primary key is typeRef, not nameRef.
x = this.typeRef.compareTo(that.typeRef);
if (x == 0)
x = this.nameRef.compareTo(that.nameRef);
}
return x;
}
public String stringValue() {
return stringValueOf(nameRef, typeRef);
}
static
String stringValueOf(Entry nameRef, Entry typeRef) {
return qualifiedStringValue(typeRef, nameRef);
}
public String prettyString() {
return nameRef.stringValue()+typeRef.prettyString();
}
public boolean isMethod() {
return typeRef.isMethod();
}
public byte getLiteralTag() {
return typeRef.getLiteralTag();
}
}
static String qualifiedStringValue(Entry e1, Entry e2) {
return qualifiedStringValue(e1.stringValue(), e2.stringValue());
}
static String qualifiedStringValue(String s1, String s234) {
// Qualification by dot must decompose uniquely. Second string might already be qualified.
assert(s1.indexOf('.') < 0);
return s1+"."+s234;
}
public static
class MemberEntry extends Entry {
final ClassEntry classRef;
final DescriptorEntry descRef;
public Entry getRef(int i) {
if (i == 0) return classRef;
if (i == 1) return descRef;
return null;
}
protected int computeValueHash() {
int hc2 = descRef.hashCode();
return (classRef.hashCode() + (hc2 << 8)) ^ hc2;
}
MemberEntry(byte tag, ClassEntry classRef, DescriptorEntry descRef) {
super(tag);
assert(isMemberTag(tag));
this.classRef = classRef;
this.descRef = descRef;
hashCode(); // force computation of valueHash
}
public boolean equals(Object o) {
if (o == null || o.getClass() != MemberEntry.class) {
return false;
}
MemberEntry that = (MemberEntry)o;
return this.classRef.eq(that.classRef)
&& this.descRef.eq(that.descRef);
}
public int compareTo(Object o) {
int x = superCompareTo(o);
if (x == 0) {
MemberEntry that = (MemberEntry)o;
if (Utils.SORT_MEMBERS_DESCR_MAJOR)
// descRef is transmitted as UDELTA5; sort it first?
x = this.descRef.compareTo(that.descRef);
// Primary key is classRef.
if (x == 0)
x = this.classRef.compareTo(that.classRef);
if (x == 0)
x = this.descRef.compareTo(that.descRef);
}
return x;
}
public String stringValue() {
return stringValueOf(tag, classRef, descRef);
}
static
String stringValueOf(byte tag, ClassEntry classRef, DescriptorEntry descRef) {
assert(isMemberTag(tag));
String pfx;
switch (tag) {
case CONSTANT_Fieldref: pfx = "Field:"; break;
case CONSTANT_Methodref: pfx = "Method:"; break;
case CONSTANT_InterfaceMethodref: pfx = "IMethod:"; break;
default: pfx = tag+"???"; break;
}
return pfx+qualifiedStringValue(classRef, descRef);
}
public boolean isMethod() {
return descRef.isMethod();
}
}
public static
class SignatureEntry extends Entry {
final Utf8Entry formRef;
final ClassEntry[] classRefs;
String value;
Utf8Entry asUtf8Entry;
public Entry getRef(int i) {
if (i == 0) return formRef;
return i-1 < classRefs.length ? classRefs[i-1] : null;
}
SignatureEntry(String value) {
super(CONSTANT_Signature);
value = value.intern(); // always do this
this.value = value;
String[] parts = structureSignature(value);
formRef = getUtf8Entry(parts[0]);
classRefs = new ClassEntry[parts.length-1];
for (int i = 1; i < parts.length; i++) {
classRefs[i - 1] = getClassEntry(parts[i]);
}
hashCode(); // force computation of valueHash
}
protected int computeValueHash() {
stringValue(); // force computation of value
return value.hashCode() + tag;
}
public Utf8Entry asUtf8Entry() {
if (asUtf8Entry == null) {
asUtf8Entry = getUtf8Entry(stringValue());
}
return asUtf8Entry;
}
public boolean equals(Object o) {
return (o != null && o.getClass() == SignatureEntry.class &&
((SignatureEntry)o).value.equals(value));
}
public int compareTo(Object o) {
int x = superCompareTo(o);
if (x == 0) {
SignatureEntry that = (SignatureEntry)o;
x = compareSignatures(this.value, that.value);
}
return x;
}
public String stringValue() {
if (value == null) {
value = stringValueOf(formRef, classRefs);
}
return value;
}
static
String stringValueOf(Utf8Entry formRef, ClassEntry[] classRefs) {
String[] parts = new String[1+classRefs.length];
parts[0] = formRef.stringValue();
for (int i = 1; i < parts.length; i++) {
parts[i] = classRefs[i - 1].stringValue();
}
return flattenSignature(parts).intern();
}
public int computeSize(boolean countDoublesTwice) {
String form = formRef.stringValue();
int min = 0;
int max = 1;
if (isMethod()) {
min = 1;
max = form.indexOf(')');
}
int size = 0;
for (int i = min; i < max; i++) {
switch (form.charAt(i)) {
case 'D':
case 'J':
if (countDoublesTwice) {
size++;
}
break;
case '[':
// Skip rest of array info.
while (form.charAt(i) == '[') {
++i;
}
break;
case ';':
continue;
default:
assert (0 <= JAVA_SIGNATURE_CHARS.indexOf(form.charAt(i)));
break;
}
size++;
}
return size;
}
public boolean isMethod() {
return formRef.stringValue().charAt(0) == '(';
}
public byte getLiteralTag() {
switch (formRef.stringValue().charAt(0)) {
case 'I': return CONSTANT_Integer;
case 'J': return CONSTANT_Long;
case 'F': return CONSTANT_Float;
case 'D': return CONSTANT_Double;
case 'B': case 'S': case 'C': case 'Z':
return CONSTANT_Integer;
case 'L':
/*
switch (classRefs[0].stringValue()) {
case "java/lang/String":
return CONSTANT_String;
case "java/lang/invoke/MethodHandle":
return CONSTANT_MethodHandle;
case "java/lang/invoke/MethodType":
return CONSTANT_MethodType;
default: // java/lang/Object, etc.
return CONSTANT_LoadableValue;
}
*/
return CONSTANT_String; // JDK 7 ConstantValue limited to String
}
assert(false);
return CONSTANT_None;
}
public String prettyString() {
String s;
if (isMethod()) {
s = formRef.stringValue();
s = s.substring(0, 1+s.indexOf(')'));
} else {
s = "/" + formRef.stringValue();
}
int i;
while ((i = s.indexOf(';')) >= 0) {
s = s.substring(0, i) + s.substring(i + 1);
}
return s;
}
}
static int compareSignatures(String s1, String s2) {
return compareSignatures(s1, s2, null, null);
}
static int compareSignatures(String s1, String s2, String[] p1, String[] p2) {
final int S1_COMES_FIRST = -1;
final int S2_COMES_FIRST = +1;
char c1 = s1.charAt(0);
char c2 = s2.charAt(0);
// fields before methods (because there are fewer of them)
if (c1 != '(' && c2 == '(') return S1_COMES_FIRST;
if (c2 != '(' && c1 == '(') return S2_COMES_FIRST;
if (p1 == null) p1 = structureSignature(s1);
if (p2 == null) p2 = structureSignature(s2);
/*
// non-classes before classes (because there are fewer of them)
if (p1.length == 1 && p2.length > 1) return S1_COMES_FIRST;
if (p2.length == 1 && p1.length > 1) return S2_COMES_FIRST;
// all else being equal, use the same comparison as for Utf8 strings
return s1.compareTo(s2);
*/
if (p1.length != p2.length) return p1.length - p2.length;
int length = p1.length;
for (int i = length; --i >= 0; ) {
int res = p1[i].compareTo(p2[i]);
if (res != 0) return res;
}
assert(s1.equals(s2));
return 0;
}
static int countClassParts(Utf8Entry formRef) {
int num = 0;
String s = formRef.stringValue();
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) == 'L') ++num;
}
return num;
}
static String flattenSignature(String[] parts) {
String form = parts[0];
if (parts.length == 1) return form;
int len = form.length();
for (int i = 1; i < parts.length; i++) {
len += parts[i].length();
}
char[] sig = new char[len];
int j = 0;
int k = 1;
for (int i = 0; i < form.length(); i++) {
char ch = form.charAt(i);
sig[j++] = ch;
if (ch == 'L') {
String cls = parts[k++];
cls.getChars(0, cls.length(), sig, j);
j += cls.length();
//sig[j++] = ';';
}
}
assert(j == len);
assert(k == parts.length);
return new String(sig);
}
private static int skipTo(char semi, String sig, int i) {
i = sig.indexOf(semi, i);
return (i >= 0) ? i : sig.length();
}
static String[] structureSignature(String sig) {
int firstl = sig.indexOf('L');
if (firstl < 0) {
String[] parts = { sig };
return parts;
}
// Segment the string like sig.split("L\\([^;<]*\\)").
// N.B.: Previous version of this code did a more complex match,
// to next ch < ' ' or ch in [';'..'@']. The only important
// characters are ';' and '<', since they are part of the
// signature syntax.
// Examples:
// "(Ljava/lang/Object;IJLLoo;)V" => {"(L;IJL;)V", "java/lang/Object", "Loo"}
// "Ljava/util/List<Ljava/lang/String;>;" => {"L<L;>;", "java/util/List", "java/lang/String"}
char[] form = null;
String[] parts = null;
for (int pass = 0; pass <= 1; pass++) {
// pass 0 is a sizing pass, pass 1 packs the arrays
int formPtr = 0;
int partPtr = 1;
int nextsemi = 0, nextangl = 0; // next ';' or '<', or zero, or sigLen
int lastj = 0;
for (int i = firstl + 1, j; i > 0; i = sig.indexOf('L', j) + 1) {
// sig[i-1] is 'L', while sig[j] will be the first ';' or '<' after it
// each part is in sig[i .. j-1]
if (nextsemi < i) nextsemi = skipTo(';', sig, i);
if (nextangl < i) nextangl = skipTo('<', sig, i);
j = (nextsemi < nextangl ? nextsemi : nextangl);
if (pass != 0) {
sig.getChars(lastj, i, form, formPtr);
parts[partPtr] = sig.substring(i, j);
}
formPtr += (i - lastj);
partPtr += 1;
lastj = j;
}
if (pass != 0) {
sig.getChars(lastj, sig.length(), form, formPtr);
break;
}
formPtr += (sig.length() - lastj);
form = new char[formPtr];
parts = new String[partPtr];
}
parts[0] = new String(form);
//assert(flattenSignature(parts).equals(sig));
return parts;
}
/** @since 1.7, JSR 292 */
public static
class MethodHandleEntry extends Entry {
final int refKind;
final MemberEntry memRef;
public Entry getRef(int i) { return i == 0 ? memRef : null; }
protected int computeValueHash() {
int hc2 = refKind;
return (memRef.hashCode() + (hc2 << 8)) ^ hc2;
}
MethodHandleEntry(byte refKind, MemberEntry memRef) {
super(CONSTANT_MethodHandle);
assert(isRefKind(refKind));
this.refKind = refKind;
this.memRef = memRef;
hashCode(); // force computation of valueHash
}
public boolean equals(Object o) {
if (o == null || o.getClass() != MethodHandleEntry.class) {
return false;
}
MethodHandleEntry that = (MethodHandleEntry)o;
return this.refKind == that.refKind
&& this.memRef.eq(that.memRef);
}
public int compareTo(Object o) {
int x = superCompareTo(o);
if (x == 0) {
MethodHandleEntry that = (MethodHandleEntry)o;
if (Utils.SORT_HANDLES_KIND_MAJOR)
// Primary key could be refKind.
x = this.refKind - that.refKind;
// Primary key is memRef, which is transmitted as UDELTA5.
if (x == 0)
x = this.memRef.compareTo(that.memRef);
if (x == 0)
x = this.refKind - that.refKind;
}
return x;
}
public static String stringValueOf(int refKind, MemberEntry memRef) {
return refKindName(refKind)+":"+memRef.stringValue();
}
public String stringValue() {
return stringValueOf(refKind, memRef);
}
}
/** @since 1.7, JSR 292 */
public static
class MethodTypeEntry extends Entry {
final SignatureEntry typeRef;
public Entry getRef(int i) { return i == 0 ? typeRef : null; }
protected int computeValueHash() {
return typeRef.hashCode() + tag;
}
MethodTypeEntry(SignatureEntry typeRef) {
super(CONSTANT_MethodType);
this.typeRef = typeRef;
hashCode(); // force computation of valueHash
}
public boolean equals(Object o) {
if (o == null || o.getClass() != MethodTypeEntry.class) {
return false;
}
MethodTypeEntry that = (MethodTypeEntry)o;
return this.typeRef.eq(that.typeRef);
}
public int compareTo(Object o) {
int x = superCompareTo(o);
if (x == 0) {
MethodTypeEntry that = (MethodTypeEntry)o;
x = this.typeRef.compareTo(that.typeRef);
}
return x;
}
public String stringValue() {
return typeRef.stringValue();
}
}
/** @since 1.7, JSR 292 */
public static
class InvokeDynamicEntry extends Entry {
final BootstrapMethodEntry bssRef;
final DescriptorEntry descRef;
public Entry getRef(int i) {
if (i == 0) return bssRef;
if (i == 1) return descRef;
return null;
}
protected int computeValueHash() {
int hc2 = descRef.hashCode();
return (bssRef.hashCode() + (hc2 << 8)) ^ hc2;
}
InvokeDynamicEntry(BootstrapMethodEntry bssRef, DescriptorEntry descRef) {
super(CONSTANT_InvokeDynamic);
this.bssRef = bssRef;
this.descRef = descRef;
hashCode(); // force computation of valueHash
}
public boolean equals(Object o) {
if (o == null || o.getClass() != InvokeDynamicEntry.class) {
return false;
}
InvokeDynamicEntry that = (InvokeDynamicEntry)o;
return this.bssRef.eq(that.bssRef)
&& this.descRef.eq(that.descRef);
}
public int compareTo(Object o) {
int x = superCompareTo(o);
if (x == 0) {
InvokeDynamicEntry that = (InvokeDynamicEntry)o;
if (Utils.SORT_INDY_BSS_MAJOR)
// Primary key could be bsmRef.
x = this.bssRef.compareTo(that.bssRef);
// Primary key is descriptor, which is transmitted as UDELTA5.
if (x == 0)
x = this.descRef.compareTo(that.descRef);
if (x == 0)
x = this.bssRef.compareTo(that.bssRef);
}
return x;
}
public String stringValue() {
return stringValueOf(bssRef, descRef);
}
static
String stringValueOf(BootstrapMethodEntry bssRef, DescriptorEntry descRef) {
return "Indy:"+bssRef.stringValue()+"."+descRef.stringValue();
}
}
/** @since 1.7, JSR 292 */
public static
class BootstrapMethodEntry extends Entry {
final MethodHandleEntry bsmRef;
final Entry[] argRefs;
public Entry getRef(int i) {
if (i == 0) return bsmRef;
if (i-1 < argRefs.length) return argRefs[i-1];
return null;
}
protected int computeValueHash() {
int hc2 = bsmRef.hashCode();
return (Arrays.hashCode(argRefs) + (hc2 << 8)) ^ hc2;
}
BootstrapMethodEntry(MethodHandleEntry bsmRef, Entry[] argRefs) {
super(CONSTANT_BootstrapMethod);
this.bsmRef = bsmRef;
this.argRefs = argRefs.clone();
hashCode(); // force computation of valueHash
}
public boolean equals(Object o) {
if (o == null || o.getClass() != BootstrapMethodEntry.class) {
return false;
}
BootstrapMethodEntry that = (BootstrapMethodEntry)o;
return this.bsmRef.eq(that.bsmRef)
&& Arrays.equals(this.argRefs, that.argRefs);
}
public int compareTo(Object o) {
int x = superCompareTo(o);
if (x == 0) {
BootstrapMethodEntry that = (BootstrapMethodEntry)o;
if (Utils.SORT_BSS_BSM_MAJOR)
// Primary key is bsmRef.
x = this.bsmRef.compareTo(that.bsmRef);
// Primary key is args array length, which is transmitted as UDELTA5.
if (x == 0)
x = compareArgArrays(this.argRefs, that.argRefs);
if (x == 0)
x = this.bsmRef.compareTo(that.bsmRef);
}
return x;
}
public String stringValue() {
return stringValueOf(bsmRef, argRefs);
}
static
String stringValueOf(MethodHandleEntry bsmRef, Entry[] argRefs) {
StringBuilder sb = new StringBuilder(bsmRef.stringValue());
// Arguments are formatted as "<foo;bar;baz>" instead of "[foo,bar,baz]".
// This ensures there will be no confusion if "[,]" appear inside of names.
char nextSep = '<';
boolean didOne = false;
for (Entry argRef : argRefs) {
sb.append(nextSep).append(argRef.stringValue());
nextSep = ';';
}
if (nextSep == '<') sb.append(nextSep);
sb.append('>');
return sb.toString();
}
static
int compareArgArrays(Entry[] a1, Entry[] a2) {
int x = a1.length - a2.length;
if (x != 0) return x;
for (int i = 0; i < a1.length; i++) {
x = a1[i].compareTo(a2[i]);
if (x != 0) break;
}
return x;
}
}
// Handy constants:
protected static final Entry[] noRefs = {};
protected static final ClassEntry[] noClassRefs = {};
/** An Index is a mapping between CP entries and small integers. */
public static final
class Index extends AbstractList<Entry> {
protected String debugName;
protected Entry[] cpMap;
protected boolean flattenSigs;
protected Entry[] getMap() {
return cpMap;
}
protected Index(String debugName) {
this.debugName = debugName;
}
protected Index(String debugName, Entry[] cpMap) {
this(debugName);
setMap(cpMap);
}
protected void setMap(Entry[] cpMap) {
clearIndex();
this.cpMap = cpMap;
}
protected Index(String debugName, Collection<Entry> cpMapList) {
this(debugName);
setMap(cpMapList);
}
protected void setMap(Collection<Entry> cpMapList) {
cpMap = new Entry[cpMapList.size()];
cpMapList.toArray(cpMap);
setMap(cpMap);
}
public int size() {
return cpMap.length;
}
public Entry get(int i) {
return cpMap[i];
}
public Entry getEntry(int i) {
// same as get(), with covariant return type
return cpMap[i];
}
// Find index of e in cpMap, or return -1 if none.
//
// As a special hack, if flattenSigs, signatures are
// treated as equivalent entries of cpMap. This is wrong
// from a Collection point of view, because contains()
// reports true for signatures, but the iterator()
// never produces them!
private int findIndexOf(Entry e) {
if (indexKey == null) {
initializeIndex();
}
int probe = findIndexLocation(e);
if (indexKey[probe] != e) {
if (flattenSigs && e.tag == CONSTANT_Signature) {
SignatureEntry se = (SignatureEntry) e;
return findIndexOf(se.asUtf8Entry());
}
return -1;
}
int index = indexValue[probe];
assert(e.equals(cpMap[index]));
return index;
}
public boolean contains(Entry e) {
return findIndexOf(e) >= 0;
}
// Find index of e in cpMap. Should not return -1.
public int indexOf(Entry e) {
int index = findIndexOf(e);
if (index < 0 && verbose() > 0) {
System.out.println("not found: "+e);
System.out.println(" in: "+this.dumpString());
Thread.dumpStack();
}
assert(index >= 0);
return index;
}
public int lastIndexOf(Entry e) {
return indexOf(e);
}
public boolean assertIsSorted() {
for (int i = 1; i < cpMap.length; i++) {
if (cpMap[i-1].compareTo(cpMap[i]) > 0) {
System.out.println("Not sorted at "+(i-1)+"/"+i+": "+this.dumpString());
return false;
}
}
return true;
}
// internal hash table
protected Entry[] indexKey;
protected int[] indexValue;
protected void clearIndex() {
indexKey = null;
indexValue = null;
}
private int findIndexLocation(Entry e) {
int size = indexKey.length;
int hash = e.hashCode();
int probe = hash & (size - 1);
int stride = ((hash >>> 8) | 1) & (size - 1);
for (;;) {
Entry e1 = indexKey[probe];
if (e1 == e || e1 == null)
return probe;
probe += stride;
if (probe >= size) probe -= size;
}
}
private void initializeIndex() {
if (verbose() > 2)
System.out.println("initialize Index "+debugName+" ["+size()+"]");
int hsize0 = (int)((cpMap.length + 10) * 1.5);
int hsize = 1;
while (hsize < hsize0) {
hsize <<= 1;
}
indexKey = new Entry[hsize];
indexValue = new int[hsize];
for (int i = 0; i < cpMap.length; i++) {
Entry e = cpMap[i];
if (e == null) continue;
int probe = findIndexLocation(e);
assert(indexKey[probe] == null); // e has unique index
indexKey[probe] = e;
indexValue[probe] = i;
}
}
public Entry[] toArray(Entry[] a) {
int sz = size();
if (a.length < sz) return super.toArray(a);
System.arraycopy(cpMap, 0, a, 0, sz);
if (a.length > sz) a[sz] = null;
return a;
}
public Entry[] toArray() {
return toArray(new Entry[size()]);
}
public Object clone() {
return new Index(debugName, cpMap.clone());
}
public String toString() {
return "Index "+debugName+" ["+size()+"]";
}
public String dumpString() {
String s = toString();
s += " {\n";
for (int i = 0; i < cpMap.length; i++) {
s += " "+i+": "+cpMap[i]+"\n";
}
s += "}";
return s;
}
}
// Index methods.
public static
Index makeIndex(String debugName, Entry[] cpMap) {
return new Index(debugName, cpMap);
}
public static
Index makeIndex(String debugName, Collection<Entry> cpMapList) {
return new Index(debugName, cpMapList);
}
/** Sort this index (destructively) into canonical order. */
public static
void sort(Index ix) {
// %%% Should move this into class Index.
ix.clearIndex();
Arrays.sort(ix.cpMap);
if (verbose() > 2)
System.out.println("sorted "+ix.dumpString());
}
/** Return a set of indexes partitioning these entries.
* The keys array must of length this.size(), and marks entries.
* The result array is as long as one plus the largest key value.
* Entries with a negative key are dropped from the partition.
*/
public static
Index[] partition(Index ix, int[] keys) {
// %%% Should move this into class Index.
List<List<Entry>> parts = new ArrayList<>();
Entry[] cpMap = ix.cpMap;
assert(keys.length == cpMap.length);
for (int i = 0; i < keys.length; i++) {
int key = keys[i];
if (key < 0) continue;
while (key >= parts.size()) {
parts.add(null);
}
List<Entry> part = parts.get(key);
if (part == null) {
parts.set(key, part = new ArrayList<>());
}
part.add(cpMap[i]);
}
Index[] indexes = new Index[parts.size()];
for (int key = 0; key < indexes.length; key++) {
List<Entry> part = parts.get(key);
if (part == null) continue;
indexes[key] = new Index(ix.debugName+"/part#"+key, part);
assert(indexes[key].indexOf(part.get(0)) == 0);
}
return indexes;
}
public static
Index[] partitionByTag(Index ix) {
// Partition by tag.
Entry[] cpMap = ix.cpMap;
int[] keys = new int[cpMap.length];
for (int i = 0; i < keys.length; i++) {
Entry e = cpMap[i];
keys[i] = (e == null)? -1: e.tag;
}
Index[] byTag = partition(ix, keys);
for (int tag = 0; tag < byTag.length; tag++) {
if (byTag[tag] == null) continue;
byTag[tag].debugName = tagName(tag);
}
if (byTag.length < CONSTANT_Limit) {
Index[] longer = new Index[CONSTANT_Limit];
System.arraycopy(byTag, 0, longer, 0, byTag.length);
byTag = longer;
}
return byTag;
}
/** Coherent group of constant pool indexes. */
public static
class IndexGroup {
private Index[] indexByTag = new Index[CONSTANT_Limit];
private Index[] indexByTagGroup;
private int[] untypedFirstIndexByTag;
private int totalSizeQQ;
private Index[][] indexByTagAndClass;
/** Index of all CP entries of all types, in definition order. */
private Index makeTagGroupIndex(byte tagGroupTag, byte[] tagsInGroup) {
if (indexByTagGroup == null)
indexByTagGroup = new Index[CONSTANT_GroupLimit - CONSTANT_GroupFirst];
int which = tagGroupTag - CONSTANT_GroupFirst;
assert(indexByTagGroup[which] == null);
int fillp = 0;
Entry[] cpMap = null;
for (int pass = 1; pass <= 2; pass++) {
untypedIndexOf(null); // warm up untypedFirstIndexByTag
for (byte tag : tagsInGroup) {
Index ix = indexByTag[tag];
if (ix == null) continue;
int ixLen = ix.cpMap.length;
if (ixLen == 0) continue;
assert(tagGroupTag == CONSTANT_All
? fillp == untypedFirstIndexByTag[tag]
: fillp < untypedFirstIndexByTag[tag]);
if (cpMap != null) {
assert(cpMap[fillp] == null);
assert(cpMap[fillp+ixLen-1] == null);
System.arraycopy(ix.cpMap, 0, cpMap, fillp, ixLen);
}
fillp += ixLen;
}
if (cpMap == null) {
assert(pass == 1);
// get ready for pass 2
cpMap = new Entry[fillp];
fillp = 0;
}
}
indexByTagGroup[which] = new Index(tagName(tagGroupTag), cpMap);
return indexByTagGroup[which];
}
public int untypedIndexOf(Entry e) {
if (untypedFirstIndexByTag == null) {
untypedFirstIndexByTag = new int[CONSTANT_Limit+1];
int fillp = 0;
for (int i = 0; i < TAGS_IN_ORDER.length; i++) {
byte tag = TAGS_IN_ORDER[i];
Index ix = indexByTag[tag];
if (ix == null) continue;
int ixLen = ix.cpMap.length;
untypedFirstIndexByTag[tag] = fillp;
fillp += ixLen;
}
untypedFirstIndexByTag[CONSTANT_Limit] = fillp;
}
if (e == null) return -1;
int tag = e.tag;
Index ix = indexByTag[tag];
if (ix == null) return -1;
int idx = ix.findIndexOf(e);
if (idx >= 0)
idx += untypedFirstIndexByTag[tag];
return idx;
}
public void initIndexByTag(byte tag, Index ix) {
assert(indexByTag[tag] == null); // do not init twice
Entry[] cpMap = ix.cpMap;
for (int i = 0; i < cpMap.length; i++) {
// It must be a homogeneous Entry set.
assert(cpMap[i].tag == tag);
}
if (tag == CONSTANT_Utf8) {
// Special case: First Utf8 must always be empty string.
assert(cpMap.length == 0 || cpMap[0].stringValue().isEmpty());
}
indexByTag[tag] = ix;
// decache indexes derived from this one:
untypedFirstIndexByTag = null;
indexByTagGroup = null;
if (indexByTagAndClass != null)
indexByTagAndClass[tag] = null;
}
/** Index of all CP entries of a given tag. */
public Index getIndexByTag(byte tag) {
if (tag >= CONSTANT_GroupFirst)
return getIndexByTagGroup(tag);
Index ix = indexByTag[tag];
if (ix == null) {
// Make an empty one by default.
ix = new Index(tagName(tag), new Entry[0]);
indexByTag[tag] = ix;
}
return ix;
}
private Index getIndexByTagGroup(byte tag) {
// pool groups:
if (indexByTagGroup != null) {
Index ix = indexByTagGroup[tag - CONSTANT_GroupFirst];
if (ix != null) return ix;
}
switch (tag) {
case CONSTANT_All:
return makeTagGroupIndex(CONSTANT_All, TAGS_IN_ORDER);
case CONSTANT_LoadableValue:
return makeTagGroupIndex(CONSTANT_LoadableValue, LOADABLE_VALUE_TAGS);
case CONSTANT_AnyMember:
return makeTagGroupIndex(CONSTANT_AnyMember, ANY_MEMBER_TAGS);
case CONSTANT_FieldSpecific:
// This one does not have any fixed index, since it is context-specific.
return null;
}
throw new AssertionError("bad tag group "+tag);
}
/** Index of all CP entries of a given tag and class. */
public Index getMemberIndex(byte tag, ClassEntry classRef) {
if (classRef == null)
throw new RuntimeException("missing class reference for " + tagName(tag));
if (indexByTagAndClass == null)
indexByTagAndClass = new Index[CONSTANT_Limit][];
Index allClasses = getIndexByTag(CONSTANT_Class);
Index[] perClassIndexes = indexByTagAndClass[tag];
if (perClassIndexes == null) {
// Create the partition now.
// Divide up all entries of the given tag according to their class.
Index allMembers = getIndexByTag(tag);
int[] whichClasses = new int[allMembers.size()];
for (int i = 0; i < whichClasses.length; i++) {
MemberEntry e = (MemberEntry) allMembers.get(i);
int whichClass = allClasses.indexOf(e.classRef);
whichClasses[i] = whichClass;
}
perClassIndexes = partition(allMembers, whichClasses);
for (int i = 0; i < perClassIndexes.length; i++) {
assert (perClassIndexes[i] == null ||
perClassIndexes[i].assertIsSorted());
}
indexByTagAndClass[tag] = perClassIndexes;
}
int whichClass = allClasses.indexOf(classRef);
return perClassIndexes[whichClass];
}
// Given the sequence of all methods of the given name and class,
// produce the ordinal of this particular given overloading.
public int getOverloadingIndex(MemberEntry methodRef) {
Index ix = getMemberIndex(methodRef.tag, methodRef.classRef);
Utf8Entry nameRef = methodRef.descRef.nameRef;
int ord = 0;
for (int i = 0; i < ix.cpMap.length; i++) {
MemberEntry e = (MemberEntry) ix.cpMap[i];
if (e.equals(methodRef))
return ord;
if (e.descRef.nameRef.equals(nameRef))
// Found a different overloading. Increment the ordinal.
ord++;
}
throw new RuntimeException("should not reach here");
}
// Inverse of getOverloadingIndex
public MemberEntry getOverloadingForIndex(byte tag, ClassEntry classRef, String name, int which) {
assert(name.equals(name.intern()));
Index ix = getMemberIndex(tag, classRef);
int ord = 0;
for (int i = 0; i < ix.cpMap.length; i++) {
MemberEntry e = (MemberEntry) ix.cpMap[i];
if (e.descRef.nameRef.stringValue().equals(name)) {
if (ord == which) return e;
ord++;
}
}
throw new RuntimeException("should not reach here");
}
public boolean haveNumbers() {
for (byte tag : NUMBER_TAGS) {
if (getIndexByTag(tag).size() > 0) return true;
}
return false;
}
public boolean haveExtraTags() {
for (byte tag : EXTRA_TAGS) {
if (getIndexByTag(tag).size() > 0) return true;
}
return false;
}
}
/** Close the set cpRefs under the getRef(*) relation.
* Also, if flattenSigs, replace all signatures in cpRefs
* by their equivalent Utf8s.
* Also, discard null from cpRefs.
*/
public static void completeReferencesIn(Set<Entry> cpRefs, boolean flattenSigs) {
completeReferencesIn(cpRefs, flattenSigs, null);
}
public static
void completeReferencesIn(Set<Entry> cpRefs, boolean flattenSigs,
List<BootstrapMethodEntry>bsms) {
cpRefs.remove(null);
for (ListIterator<Entry> work =
new ArrayList<>(cpRefs).listIterator(cpRefs.size());
work.hasPrevious(); ) {
Entry e = work.previous();
work.remove(); // pop stack
assert(e != null);
if (flattenSigs && e.tag == CONSTANT_Signature) {
SignatureEntry se = (SignatureEntry) e;
Utf8Entry ue = se.asUtf8Entry();
// Totally replace e by se.
cpRefs.remove(se);
cpRefs.add(ue);
e = ue; // do not descend into the sig
}
if (bsms != null && e.tag == CONSTANT_BootstrapMethod) {
BootstrapMethodEntry bsm = (BootstrapMethodEntry)e;
cpRefs.remove(bsm);
// move it away to the side table where it belongs
if (!bsms.contains(bsm))
bsms.add(bsm);
// fall through to recursively add refs for this entry
}
// Recursively add the refs of e to cpRefs:
for (int i = 0; ; i++) {
Entry re = e.getRef(i);
if (re == null)
break; // no more refs in e
if (cpRefs.add(re)) // output the ref
work.add(re); // push stack, if a new ref
}
}
}
static double percent(int num, int den) {
return (int)((10000.0*num)/den + 0.5) / 100.0;
}
public static String tagName(int tag) {
switch (tag) {
case CONSTANT_Utf8: return "Utf8";
case CONSTANT_Integer: return "Integer";
case CONSTANT_Float: return "Float";
case CONSTANT_Long: return "Long";
case CONSTANT_Double: return "Double";
case CONSTANT_Class: return "Class";
case CONSTANT_String: return "String";
case CONSTANT_Fieldref: return "Fieldref";
case CONSTANT_Methodref: return "Methodref";
case CONSTANT_InterfaceMethodref: return "InterfaceMethodref";
case CONSTANT_NameandType: return "NameandType";
case CONSTANT_MethodHandle: return "MethodHandle";
case CONSTANT_MethodType: return "MethodType";
case CONSTANT_InvokeDynamic: return "InvokeDynamic";
// pseudo-tags:
case CONSTANT_All: return "**All";
case CONSTANT_None: return "**None";
case CONSTANT_LoadableValue: return "**LoadableValue";
case CONSTANT_AnyMember: return "**AnyMember";
case CONSTANT_FieldSpecific: return "*FieldSpecific";
case CONSTANT_Signature: return "*Signature";
case CONSTANT_BootstrapMethod: return "*BootstrapMethod";
}
return "tag#"+tag;
}
public static String refKindName(int refKind) {
switch (refKind) {
case REF_getField: return "getField";
case REF_getStatic: return "getStatic";
case REF_putField: return "putField";
case REF_putStatic: return "putStatic";
case REF_invokeVirtual: return "invokeVirtual";
case REF_invokeStatic: return "invokeStatic";
case REF_invokeSpecial: return "invokeSpecial";
case REF_newInvokeSpecial: return "newInvokeSpecial";
case REF_invokeInterface: return "invokeInterface";
}
return "refKind#"+refKind;
}
// archive constant pool definition order
static final byte TAGS_IN_ORDER[] = {
CONSTANT_Utf8,
CONSTANT_Integer, // cp_Int
CONSTANT_Float,
CONSTANT_Long,
CONSTANT_Double,
CONSTANT_String, // note that String=8 precedes Class=7
CONSTANT_Class,
CONSTANT_Signature,
CONSTANT_NameandType, // cp_Descr
CONSTANT_Fieldref, // cp_Field
CONSTANT_Methodref, // cp_Method
CONSTANT_InterfaceMethodref, // cp_Imethod
// Constants defined in JDK 7 and later:
CONSTANT_MethodHandle,
CONSTANT_MethodType,
CONSTANT_BootstrapMethod, // pseudo-tag, really stored in a class attribute
CONSTANT_InvokeDynamic
};
static final byte TAG_ORDER[];
static {
TAG_ORDER = new byte[CONSTANT_Limit];
for (int i = 0; i < TAGS_IN_ORDER.length; i++) {
TAG_ORDER[TAGS_IN_ORDER[i]] = (byte)(i+1);
}
/*
System.out.println("TAG_ORDER[] = {");
for (int i = 0; i < TAG_ORDER.length; i++)
System.out.println(" "+TAG_ORDER[i]+",");
System.out.println("};");
*/
}
static final byte[] NUMBER_TAGS = {
CONSTANT_Integer, CONSTANT_Float, CONSTANT_Long, CONSTANT_Double
};
static final byte[] EXTRA_TAGS = {
CONSTANT_MethodHandle, CONSTANT_MethodType,
CONSTANT_BootstrapMethod, // pseudo-tag
CONSTANT_InvokeDynamic
};
static final byte[] LOADABLE_VALUE_TAGS = { // for CONSTANT_LoadableValue
CONSTANT_Integer, CONSTANT_Float, CONSTANT_Long, CONSTANT_Double,
CONSTANT_String, CONSTANT_Class,
CONSTANT_MethodHandle, CONSTANT_MethodType
};
static final byte[] ANY_MEMBER_TAGS = { // for CONSTANT_AnyMember
CONSTANT_Fieldref, CONSTANT_Methodref, CONSTANT_InterfaceMethodref
};
static final byte[] FIELD_SPECIFIC_TAGS = { // for CONSTANT_FieldSpecific
CONSTANT_Integer, CONSTANT_Float, CONSTANT_Long, CONSTANT_Double,
CONSTANT_String
};
static {
assert(
verifyTagOrder(TAGS_IN_ORDER) &&
verifyTagOrder(NUMBER_TAGS) &&
verifyTagOrder(EXTRA_TAGS) &&
verifyTagOrder(LOADABLE_VALUE_TAGS) &&
verifyTagOrder(ANY_MEMBER_TAGS) &&
verifyTagOrder(FIELD_SPECIFIC_TAGS)
);
}
private static boolean verifyTagOrder(byte[] tags) {
int prev = -1;
for (byte tag : tags) {
int next = TAG_ORDER[tag];
assert(next > 0) : "tag not found: "+tag;
assert(TAGS_IN_ORDER[next-1] == tag) : "tag repeated: "+tag+" => "+next+" => "+TAGS_IN_ORDER[next-1];
assert(prev < next) : "tags not in order: "+Arrays.toString(tags)+" at "+tag;
prev = next;
}
return true;
}
}