com.sun.java.util.jar.pack.ConstantPool.Entry

Here are the examples of the java api class com.sun.java.util.jar.pack.ConstantPool.Entry taken from open source projects.

1. ClassReader#readCode()

Project: openjdk
File: ClassReader.java
void readCode(Code code) throws IOException {
    code.max_stack = readUnsignedShort();
    code.max_locals = readUnsignedShort();
    code.bytes = new byte[readInt()];
    in.readFully(code.bytes);
    Entry[] cpMap = cls.getCPMap();
    Instruction.opcodeChecker(code.bytes, cpMap, this.cls.version);
    int nh = readUnsignedShort();
    code.setHandlerCount(nh);
    for (int i = 0; i < nh; i++) {
        code.handler_start[i] = readUnsignedShort();
        code.handler_end[i] = readUnsignedShort();
        code.handler_catch[i] = readUnsignedShort();
        code.handler_class[i] = readClassRefOrNull();
    }
    readAttributes(ATTR_CONTEXT_CODE, code);
}

2. ClassReader#fixUnresolvedEntries()

Project: openjdk
File: ClassReader.java
private void fixUnresolvedEntries() {
    if (!haveUnresolvedEntry)
        return;
    Entry[] cpMap = cls.getCPMap();
    for (int i = 0; i < cpMap.length; i++) {
        Entry e = cpMap[i];
        if (e instanceof UnresolvedEntry) {
            cpMap[i] = e = ((UnresolvedEntry) e).resolve();
            assert (!(e instanceof UnresolvedEntry));
        }
    }
    haveUnresolvedEntry = false;
}

3. PackageReader#reconstructLocalCPMap()

Project: jdk7u-jdk
File: PackageReader.java
Entry[] reconstructLocalCPMap(Class cls) {
    Set<Entry> ldcRefs = ldcRefMap.get(cls);
    Set<Entry> cpRefs = new HashSet<>();
    // look for constant pool entries:
    cls.visitRefs(VRM_CLASSIC, cpRefs);
    // flesh out the local constant pool
    ConstantPool.completeReferencesIn(cpRefs, true);
    // Now that we know all our local class references,
    // compute the InnerClasses attribute.
    int changed = cls.expandLocalICs();
    if (changed != 0) {
        if (changed > 0) {
            // Just visit the expanded InnerClasses attr.
            cls.visitInnerClassRefs(VRM_CLASSIC, cpRefs);
        } else {
            // Have to recompute from scratch, because of deletions.
            cpRefs.clear();
            cls.visitRefs(VRM_CLASSIC, cpRefs);
        }
        // flesh out the local constant pool, again
        ConstantPool.completeReferencesIn(cpRefs, true);
    }
    // construct a local constant pool
    int numDoubles = 0;
    for (Entry e : cpRefs) {
        if (e.isDoubleWord())
            numDoubles++;
        assert (e.tag != CONSTANT_Signature) : (e);
    }
    Entry[] cpMap = new Entry[1 + numDoubles + cpRefs.size()];
    int fillp = 1;
    // Add all ldc operands first.
    if (ldcRefs != null) {
        assert (cpRefs.containsAll(ldcRefs));
        for (Entry e : ldcRefs) {
            cpMap[fillp++] = e;
        }
        assert (fillp == 1 + ldcRefs.size());
        cpRefs.removeAll(ldcRefs);
        // done with it
        ldcRefs = null;
    }
    // Next add all the two-byte references.
    Set<Entry> wideRefs = cpRefs;
    // do not use!
    cpRefs = null;
    int narrowLimit = fillp;
    for (Entry e : wideRefs) {
        cpMap[fillp++] = e;
    }
    assert (fillp == narrowLimit + wideRefs.size());
    Arrays.sort(cpMap, 1, narrowLimit, entryOutputOrder);
    Arrays.sort(cpMap, narrowLimit, fillp, entryOutputOrder);
    if (verbose > 3) {
        Utils.log.fine("CP of " + this + " {");
        for (int i = 0; i < fillp; i++) {
            Entry e = cpMap[i];
            Utils.log.fine("  " + ((e == null) ? -1 : getOutputIndex(e)) + " : " + e);
        }
        Utils.log.fine("}");
    }
    // Now repack backwards, introducing null elements.
    int revp = cpMap.length;
    for (int i = fillp; --i >= 1; ) {
        Entry e = cpMap[i];
        if (e.isDoubleWord())
            cpMap[--revp] = null;
        cpMap[--revp] = e;
    }
    // do not process the initial null
    assert (revp == 1);
    return cpMap;
}

4. Fixups#growEntries()

Project: openjdk
File: Fixups.java
private void growEntries(int newSize) {
    Entry[] oldEntries = entries;
    entries = new Entry[Math.max(3, newSize)];
    System.arraycopy(oldEntries, 0, entries, 0, oldEntries.length);
}

5. ClassWriter#writeConstantPool()

Project: openjdk
File: ClassWriter.java
void writeConstantPool() throws IOException {
    Entry[] cpMap = cls.cpMap;
    writeShort(cpMap.length);
    for (int i = 0; i < cpMap.length; i++) {
        Entry e = cpMap[i];
        assert ((e == null) == (i == 0 || cpMap[i - 1] != null && cpMap[i - 1].isDoubleWord()));
        if (e == null)
            continue;
        byte tag = e.getTag();
        if (verbose > 2)
            Utils.log.fine("   CP[" + i + "] = " + e);
        out.write(tag);
        switch(tag) {
            case CONSTANT_Signature:
                throw new AssertionError("CP should have Signatures remapped to Utf8");
            case CONSTANT_Utf8:
                out.writeUTF(e.stringValue());
                break;
            case CONSTANT_Integer:
                out.writeInt(((NumberEntry) e).numberValue().intValue());
                break;
            case CONSTANT_Float:
                float fval = ((NumberEntry) e).numberValue().floatValue();
                out.writeInt(Float.floatToRawIntBits(fval));
                break;
            case CONSTANT_Long:
                out.writeLong(((NumberEntry) e).numberValue().longValue());
                break;
            case CONSTANT_Double:
                double dval = ((NumberEntry) e).numberValue().doubleValue();
                out.writeLong(Double.doubleToRawLongBits(dval));
                break;
            case CONSTANT_Class:
            case CONSTANT_String:
            case CONSTANT_MethodType:
                writeRef(e.getRef(0));
                break;
            case CONSTANT_MethodHandle:
                MethodHandleEntry mhe = (MethodHandleEntry) e;
                out.writeByte(mhe.refKind);
                writeRef(mhe.getRef(0));
                break;
            case CONSTANT_Fieldref:
            case CONSTANT_Methodref:
            case CONSTANT_InterfaceMethodref:
            case CONSTANT_NameandType:
                writeRef(e.getRef(0));
                writeRef(e.getRef(1));
                break;
            case CONSTANT_InvokeDynamic:
                writeRef(e.getRef(0), bsmIndex);
                writeRef(e.getRef(1));
                break;
            case CONSTANT_BootstrapMethod:
                throw new AssertionError("CP should have BootstrapMethods moved to side-table");
            default:
                throw new IOException("Bad constant pool tag " + tag);
        }
    }
}

6. ClassReader#readConstantPool()

Project: openjdk
File: ClassReader.java
void readConstantPool() throws IOException {
    int length = in.readUnsignedShort();
    //System.err.println("reading CP, length="+length);
    int[] fixups = new int[length * 4];
    int fptr = 0;
    Entry[] cpMap = new Entry[length];
    cpMap[0] = null;
    for (int i = 1; i < length; i++) {
        //System.err.println("reading CP elt, i="+i);
        int tag = in.readByte();
        switch(tag) {
            case CONSTANT_Utf8:
                cpMap[i] = ConstantPool.getUtf8Entry(in.readUTF());
                break;
            case CONSTANT_Integer:
                {
                    cpMap[i] = ConstantPool.getLiteralEntry(in.readInt());
                }
                break;
            case CONSTANT_Float:
                {
                    cpMap[i] = ConstantPool.getLiteralEntry(in.readFloat());
                }
                break;
            case CONSTANT_Long:
                {
                    cpMap[i] = ConstantPool.getLiteralEntry(in.readLong());
                    cpMap[++i] = null;
                }
                break;
            case CONSTANT_Double:
                {
                    cpMap[i] = ConstantPool.getLiteralEntry(in.readDouble());
                    cpMap[++i] = null;
                }
                break;
            // just read the refs; do not attempt to resolve while reading
            case CONSTANT_Class:
            case CONSTANT_String:
            case CONSTANT_MethodType:
                fixups[fptr++] = i;
                fixups[fptr++] = tag;
                fixups[fptr++] = in.readUnsignedShort();
                // empty ref2
                fixups[fptr++] = -1;
                break;
            case CONSTANT_Fieldref:
            case CONSTANT_Methodref:
            case CONSTANT_InterfaceMethodref:
            case CONSTANT_NameandType:
                fixups[fptr++] = i;
                fixups[fptr++] = tag;
                fixups[fptr++] = in.readUnsignedShort();
                fixups[fptr++] = in.readUnsignedShort();
                break;
            case CONSTANT_InvokeDynamic:
                fixups[fptr++] = i;
                fixups[fptr++] = tag;
                // not a ref
                fixups[fptr++] = -1 ^ in.readUnsignedShort();
                fixups[fptr++] = in.readUnsignedShort();
                break;
            case CONSTANT_MethodHandle:
                fixups[fptr++] = i;
                fixups[fptr++] = tag;
                fixups[fptr++] = -1 ^ in.readUnsignedByte();
                fixups[fptr++] = in.readUnsignedShort();
                break;
            default:
                throw new ClassFormatException("Bad constant pool tag " + tag + " in File: " + cls.file.nameString + " at pos: " + inPos);
        }
    }
    constantPoolLimit = inPos;
    // Fix up refs, which might be out of order.
    while (fptr > 0) {
        if (verbose > 3)
            Utils.log.fine("CP fixups [" + fptr / 4 + "]");
        int flimit = fptr;
        fptr = 0;
        for (int fi = 0; fi < flimit; ) {
            int cpi = fixups[fi++];
            int tag = fixups[fi++];
            int ref = fixups[fi++];
            int ref2 = fixups[fi++];
            if (verbose > 3)
                Utils.log.fine("  cp[" + cpi + "] = " + ConstantPool.tagName(tag) + "{" + ref + "," + ref2 + "}");
            if (ref >= 0 && cpMap[ref] == null || ref2 >= 0 && cpMap[ref2] == null) {
                // Defer.
                fixups[fptr++] = cpi;
                fixups[fptr++] = tag;
                fixups[fptr++] = ref;
                fixups[fptr++] = ref2;
                continue;
            }
            switch(tag) {
                case CONSTANT_Class:
                    cpMap[cpi] = ConstantPool.getClassEntry(cpMap[ref].stringValue());
                    break;
                case CONSTANT_String:
                    cpMap[cpi] = ConstantPool.getStringEntry(cpMap[ref].stringValue());
                    break;
                case CONSTANT_Fieldref:
                case CONSTANT_Methodref:
                case CONSTANT_InterfaceMethodref:
                    ClassEntry mclass = (ClassEntry) checkTag(cpMap[ref], CONSTANT_Class);
                    DescriptorEntry mdescr = (DescriptorEntry) checkTag(cpMap[ref2], CONSTANT_NameandType);
                    cpMap[cpi] = ConstantPool.getMemberEntry((byte) tag, mclass, mdescr);
                    break;
                case CONSTANT_NameandType:
                    Utf8Entry mname = (Utf8Entry) checkTag(cpMap[ref], CONSTANT_Utf8);
                    Utf8Entry mtype = (Utf8Entry) checkTag(cpMap[ref2], CONSTANT_Signature);
                    cpMap[cpi] = ConstantPool.getDescriptorEntry(mname, mtype);
                    break;
                case CONSTANT_MethodType:
                    cpMap[cpi] = ConstantPool.getMethodTypeEntry((Utf8Entry) checkTag(cpMap[ref], CONSTANT_Signature));
                    break;
                case CONSTANT_MethodHandle:
                    byte refKind = (byte) (-1 ^ ref);
                    MemberEntry memRef = (MemberEntry) checkTag(cpMap[ref2], CONSTANT_AnyMember);
                    cpMap[cpi] = ConstantPool.getMethodHandleEntry(refKind, memRef);
                    break;
                case CONSTANT_InvokeDynamic:
                    DescriptorEntry idescr = (DescriptorEntry) checkTag(cpMap[ref2], CONSTANT_NameandType);
                    cpMap[cpi] = new UnresolvedEntry((byte) tag, (-1 ^ ref), idescr);
                    // Note that ref must be resolved later, using the BootstrapMethods attribute.
                    break;
                default:
                    assert (false);
            }
        }
        // Must make progress.
        assert (fptr < flimit);
    }
    cls.cpMap = cpMap;
}

7. ClassReader#readSignatureRef()

Project: openjdk
File: ClassReader.java
private SignatureEntry readSignatureRef() throws IOException {
    // The class file stores a Utf8, but we want a Signature.
    Entry e = readRef(CONSTANT_Signature);
    return (e != null && e.getTag() == CONSTANT_Utf8) ? ConstantPool.getSignatureEntry(e.stringValue()) : (SignatureEntry) e;
}

8. ClassReader#readRefOrNull()

Project: openjdk
File: ClassReader.java
private Entry readRefOrNull(byte tag) throws IOException {
    Entry e = readRef();
    checkTag(e, tag, true);
    return e;
}

9. ClassReader#readRef()

Project: openjdk
File: ClassReader.java
private Entry readRef(byte tag) throws IOException {
    Entry e = readRef();
    assert (!(e instanceof UnresolvedEntry));
    checkTag(e, tag);
    return e;
}

10. BandStructure#decodeRef()

Project: openjdk
File: BandStructure.java
Entry decodeRef(int n, Index ix) {
    if (n < 0 || n >= ix.size())
        Utils.log.warning("decoding bad ref " + n + " in " + ix);
    Entry e = ix.getEntry(n);
    if (verbose > 2)
        Utils.log.fine("getRef " + n + " => " + e);
    return e;
}

11. Fixups#growEntries()

Project: jdk7u-jdk
File: Fixups.java
private void growEntries(int newSize) {
    Entry[] oldEntries = entries;
    entries = new Entry[Math.max(3, newSize)];
    System.arraycopy(oldEntries, 0, entries, 0, oldEntries.length);
}

12. ClassWriter#writeConstantPool()

Project: jdk7u-jdk
File: ClassWriter.java
void writeConstantPool() throws IOException {
    Entry[] cpMap = cls.cpMap;
    writeShort(cpMap.length);
    for (int i = 0; i < cpMap.length; i++) {
        Entry e = cpMap[i];
        assert ((e == null) == (i == 0 || cpMap[i - 1] != null && cpMap[i - 1].isDoubleWord()));
        if (e == null)
            continue;
        byte tag = e.getTag();
        if (verbose > 2)
            Utils.log.fine("   CP[" + i + "] = " + e);
        out.write(tag);
        switch(tag) {
            case CONSTANT_Signature:
                // should not reach here
                assert (false);
                break;
            case CONSTANT_Utf8:
                out.writeUTF(e.stringValue());
                break;
            case CONSTANT_Integer:
                out.writeInt(((NumberEntry) e).numberValue().intValue());
                break;
            case CONSTANT_Float:
                float fval = ((NumberEntry) e).numberValue().floatValue();
                out.writeInt(Float.floatToRawIntBits(fval));
                break;
            case CONSTANT_Long:
                out.writeLong(((NumberEntry) e).numberValue().longValue());
                break;
            case CONSTANT_Double:
                double dval = ((NumberEntry) e).numberValue().doubleValue();
                out.writeLong(Double.doubleToRawLongBits(dval));
                break;
            case CONSTANT_Class:
            case CONSTANT_String:
                writeRef(e.getRef(0));
                break;
            case CONSTANT_Fieldref:
            case CONSTANT_Methodref:
            case CONSTANT_InterfaceMethodref:
            case CONSTANT_NameandType:
                writeRef(e.getRef(0));
                writeRef(e.getRef(1));
                break;
            default:
                throw new IOException("Bad constant pool tag " + tag);
        }
    }
}

13. ClassReader#readConstantPool()

Project: jdk7u-jdk
File: ClassReader.java
void readConstantPool() throws IOException {
    int length = in.readUnsignedShort();
    //System.err.println("reading CP, length="+length);
    int[] fixups = new int[length * 4];
    int fptr = 0;
    Entry[] cpMap = new Entry[length];
    cpMap[0] = null;
    for (int i = 1; i < length; i++) {
        //System.err.println("reading CP elt, i="+i);
        int tag = in.readByte();
        switch(tag) {
            case CONSTANT_Utf8:
                cpMap[i] = ConstantPool.getUtf8Entry(in.readUTF());
                break;
            case CONSTANT_Integer:
                {
                    cpMap[i] = ConstantPool.getLiteralEntry(in.readInt());
                }
                break;
            case CONSTANT_Float:
                {
                    cpMap[i] = ConstantPool.getLiteralEntry(in.readFloat());
                }
                break;
            case CONSTANT_Long:
                {
                    cpMap[i] = ConstantPool.getLiteralEntry(in.readLong());
                    cpMap[++i] = null;
                }
                break;
            case CONSTANT_Double:
                {
                    cpMap[i] = ConstantPool.getLiteralEntry(in.readDouble());
                    cpMap[++i] = null;
                }
                break;
            // just read the refs; do not attempt to resolve while reading
            case CONSTANT_Class:
            case CONSTANT_String:
                fixups[fptr++] = i;
                fixups[fptr++] = tag;
                fixups[fptr++] = in.readUnsignedShort();
                // empty ref2
                fixups[fptr++] = -1;
                break;
            case CONSTANT_Fieldref:
            case CONSTANT_Methodref:
            case CONSTANT_InterfaceMethodref:
            case CONSTANT_NameandType:
                fixups[fptr++] = i;
                fixups[fptr++] = tag;
                fixups[fptr++] = in.readUnsignedShort();
                fixups[fptr++] = in.readUnsignedShort();
                break;
            default:
                throw new ClassFormatException("Bad constant pool tag " + tag + " in File: " + cls.file.nameString + " at pos: " + inPos);
        }
    }
    // Fix up refs, which might be out of order.
    while (fptr > 0) {
        if (verbose > 3)
            Utils.log.fine("CP fixups [" + fptr / 4 + "]");
        int flimit = fptr;
        fptr = 0;
        for (int fi = 0; fi < flimit; ) {
            int cpi = fixups[fi++];
            int tag = fixups[fi++];
            int ref = fixups[fi++];
            int ref2 = fixups[fi++];
            if (verbose > 3)
                Utils.log.fine("  cp[" + cpi + "] = " + ConstantPool.tagName(tag) + "{" + ref + "," + ref2 + "}");
            if (cpMap[ref] == null || ref2 >= 0 && cpMap[ref2] == null) {
                // Defer.
                fixups[fptr++] = cpi;
                fixups[fptr++] = tag;
                fixups[fptr++] = ref;
                fixups[fptr++] = ref2;
                continue;
            }
            switch(tag) {
                case CONSTANT_Class:
                    cpMap[cpi] = ConstantPool.getClassEntry(cpMap[ref].stringValue());
                    break;
                case CONSTANT_String:
                    cpMap[cpi] = ConstantPool.getStringEntry(cpMap[ref].stringValue());
                    break;
                case CONSTANT_Fieldref:
                case CONSTANT_Methodref:
                case CONSTANT_InterfaceMethodref:
                    ClassEntry mclass = (ClassEntry) cpMap[ref];
                    DescriptorEntry mdescr = (DescriptorEntry) cpMap[ref2];
                    cpMap[cpi] = ConstantPool.getMemberEntry((byte) tag, mclass, mdescr);
                    break;
                case CONSTANT_NameandType:
                    Utf8Entry mname = (Utf8Entry) cpMap[ref];
                    Utf8Entry mtype = (Utf8Entry) cpMap[ref2];
                    cpMap[cpi] = ConstantPool.getDescriptorEntry(mname, mtype);
                    break;
                default:
                    assert (false);
            }
        }
        // Must make progress.
        assert (fptr < flimit);
    }
    cls.cpMap = cpMap;
}

14. ClassReader#readSignatureRef()

Project: jdk7u-jdk
File: ClassReader.java
private SignatureEntry readSignatureRef() throws IOException {
    // The class file stores a Utf8, but we want a Signature.
    Entry e = readRef(CONSTANT_Utf8);
    return ConstantPool.getSignatureEntry(e.stringValue());
}

15. ClassReader#readRefOrNull()

Project: jdk7u-jdk
File: ClassReader.java
private Entry readRefOrNull(byte tag) throws IOException {
    Entry e = readRef();
    assert (e == null || e.tagMatches(tag));
    return e;
}

16. ClassReader#readRef()

Project: jdk7u-jdk
File: ClassReader.java
private Entry readRef(byte tag) throws IOException {
    Entry e = readRef();
    assert (e != null);
    assert (e.tagMatches(tag));
    return e;
}

17. BandStructure#decodeRef()

Project: jdk7u-jdk
File: BandStructure.java
Entry decodeRef(int n, Index ix) {
    if (n < 0 || n >= ix.size())
        Utils.log.warning("decoding bad ref " + n + " in " + ix);
    Entry e = ix.getEntry(n);
    if (verbose > 2)
        Utils.log.fine("getRef " + n + " => " + e);
    return e;
}