import com.sun.java.util.jar.pack.ConstantPool.ClassEntry; //导入依赖的package包/类
void readMemberRefs(byte tag, Entry[] cpMap, CPRefBand cp_class, CPRefBand cp_desc) throws IOException {
    //  cp_Field:
    //        *cp_Field_class :DELTA5  (cp_Class)
    //        *cp_Field_desc :UDELTA5  (cp_Descr)
    //  cp_Method:
    //        *cp_Method_class :DELTA5  (cp_Class)
    //        *cp_Method_desc :UDELTA5  (cp_Descr)
    //  cp_Imethod:
    //        *cp_Imethod_class :DELTA5  (cp_Class)
    //        *cp_Imethod_desc :UDELTA5  (cp_Descr)
    cp_class.expectLength(cpMap.length);
    cp_class.readFrom(in);
    cp_class.setIndex(getCPIndex(CONSTANT_Class));
    cp_desc.expectLength(cpMap.length);
    cp_desc.readFrom(in);
    cp_desc.setIndex(getCPIndex(CONSTANT_NameandType));
    for (int i = 0; i < cpMap.length; i++) {
        ClassEntry      mclass = (ClassEntry     ) cp_class.getRef();
        DescriptorEntry mdescr = (DescriptorEntry) cp_desc.getRef();
        cpMap[i] = ConstantPool.getMemberEntry(tag, mclass, mdescr);
    }
    cp_class.doneDisbursing();
    cp_desc.doneDisbursing();
}
 

import com.sun.java.util.jar.pack.ConstantPool.ClassEntry; //导入依赖的package包/类
void readLocalInnerClasses(Class cls) throws IOException {
    int nc = class_InnerClasses_N.getInt();
    List<InnerClass> localICs = new ArrayList<>(nc);
    for (int i = 0; i < nc; i++) {
        ClassEntry thisClass = (ClassEntry) class_InnerClasses_RC.getRef();
        int        flags     =              class_InnerClasses_F.getInt();
        if (flags == 0) {
            // A zero flag means copy a global IC here.
            InnerClass ic = pkg.getGlobalInnerClass(thisClass);
            assert(ic != null);  // must be a valid global IC reference
            localICs.add(ic);
        } else {
            if (flags == ACC_IC_LONG_FORM)
                flags = 0;  // clear the marker bit
            ClassEntry outer = (ClassEntry) class_InnerClasses_outer_RCN.getRef();
            Utf8Entry name   = (Utf8Entry)  class_InnerClasses_name_RUN.getRef();
            localICs.add(new InnerClass(thisClass, outer, name, flags));
        }
    }
    cls.setInnerClasses(localICs);
    // cls.expandLocalICs may add more tuples to ics also,
    // or may even delete tuples.
    // We cannot do that now, because we do not know the
    // full contents of the local constant pool yet.
}
 

import com.sun.java.util.jar.pack.ConstantPool.ClassEntry; //导入依赖的package包/类
Class(int flags, ClassEntry thisClass, ClassEntry superClass, ClassEntry[] interfaces) {
    this.magic      = JAVA_MAGIC;
    this.version    = defaultClassVersion;
    this.flags      = flags;
    this.thisClass  = thisClass;
    this.superClass = superClass;
    this.interfaces = interfaces;

    boolean added = classes.add(this);
    assert(added);
}
 

import com.sun.java.util.jar.pack.ConstantPool.ClassEntry; //导入依赖的package包/类
InnerClass(ClassEntry thisClass, ClassEntry outerClass,
           Utf8Entry name, int flags) {
    this.thisClass = thisClass;
    this.outerClass = outerClass;
    this.name = name;
    this.flags = flags;
    this.predictable = computePredictable();
}
 

import com.sun.java.util.jar.pack.ConstantPool.ClassEntry; //导入依赖的package包/类
void readHeader() throws IOException {
    cls.flags = readUnsignedShort();
    cls.thisClass = readClassRef();
    cls.superClass = readClassRefOrNull();
    int ni = readUnsignedShort();
    cls.interfaces = new ClassEntry[ni];
    for (int i = 0; i < ni; i++) {
        cls.interfaces[i] = readClassRef();
    }
}
 

import com.sun.java.util.jar.pack.ConstantPool.ClassEntry; //导入依赖的package包/类
Class(int flags, ClassEntry thisClass, ClassEntry superClass, ClassEntry[] interfaces) {
    this.magic      = JAVA_MAGIC;
    this.minver     = default_class_minver;
    this.majver     = default_class_majver;
    this.flags      = flags;
    this.thisClass  = thisClass;
    this.superClass = superClass;
    this.interfaces = interfaces;

    boolean added = classes.add(this);
    assert(added);
}
 

import com.sun.java.util.jar.pack.ConstantPool.ClassEntry; //导入依赖的package包/类
void writeClassesAndByteCodes() throws IOException {
    Class[] classes = new Class[pkg.classes.size()];
    pkg.classes.toArray(classes);
    // Note:  This code respects the order in which caller put classes.
    if (verbose > 0)
        Utils.log.info("  ...scanning "+classes.length+" classes...");

    int nwritten = 0;
    for (int i = 0; i < classes.length; i++) {
        // Collect the class body, sans bytecodes.
        Class cls = classes[i];
        if (verbose > 1)
            Utils.log.fine("Scanning "+cls);

        ClassEntry   thisClass  = cls.thisClass;
        ClassEntry   superClass = cls.superClass;
        ClassEntry[] interfaces = cls.interfaces;
        // Encode rare case of null superClass as thisClass:
        assert(superClass != thisClass);  // bad class file!?
        if (superClass == null)  superClass = thisClass;
        class_this.putRef(thisClass);
        class_super.putRef(superClass);
        class_interface_count.putInt(cls.interfaces.length);
        for (int j = 0; j < interfaces.length; j++) {
            class_interface.putRef(interfaces[j]);
        }

        writeMembers(cls);
        writeAttrs(ATTR_CONTEXT_CLASS, cls, cls);

        nwritten++;
        if (verbose > 0 && (nwritten % 1000) == 0)
            Utils.log.info("Have scanned "+nwritten+" classes...");
    }
}
 

import com.sun.java.util.jar.pack.ConstantPool.ClassEntry; //导入依赖的package包/类
private int initOpVariant(Instruction i, Entry newClass) {
    if (i.getBC() != _invokespecial)  return -1;
    MemberEntry ref = (MemberEntry) i.getCPRef(curCPMap);
    if ("<init>".equals(ref.descRef.nameRef.stringValue()) == false)
        return -1;
    ClassEntry refClass = ref.classRef;
    if (refClass == curClass.thisClass)
        return _invokeinit_op+_invokeinit_self_option;
    if (refClass == curClass.superClass)
        return _invokeinit_op+_invokeinit_super_option;
    if (refClass == newClass)
        return _invokeinit_op+_invokeinit_new_option;
    return -1;
}
 

import com.sun.java.util.jar.pack.ConstantPool.ClassEntry; //导入依赖的package包/类
private int selfOpVariant(Instruction i) {
    int bc = i.getBC();
    if (!(bc >= _first_linker_op && bc <= _last_linker_op))  return -1;
    MemberEntry ref = (MemberEntry) i.getCPRef(curCPMap);
    ClassEntry refClass = ref.classRef;
    int self_bc = _self_linker_op + (bc - _first_linker_op);
    if (refClass == curClass.thisClass)
        return self_bc;
    if (refClass == curClass.superClass)
        return self_bc + _self_linker_super_flag;
    return -1;
}