jdk-sandbox: comparison jdk/src/share/classes/com/sun/java/util/jar/pack/PackageReader.java

equal deleted inserted replaced

-:dc77388d186a
+:98021fc612af
 /*
-* Copyright (c) 2001, 2005, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2001, 2010, 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
 import com.sun.java.util.jar.pack.ConstantPool.Entry;
 import com.sun.java.util.jar.pack.ConstantPool.Index;
 import com.sun.java.util.jar.pack.ConstantPool.MemberEntry;
 import com.sun.java.util.jar.pack.ConstantPool.SignatureEntry;
 import com.sun.java.util.jar.pack.ConstantPool.Utf8Entry;
-import java.io.*;
-import java.util.*;
 import com.sun.java.util.jar.pack.Package.Class;
 import com.sun.java.util.jar.pack.Package.File;
 import com.sun.java.util.jar.pack.Package.InnerClass;
+import java.io.ByteArrayOutputStream;
+import java.io.EOFException;
+import java.io.PrintStream;
+import java.io.FilterInputStream;
+import java.io.BufferedInputStream;
+import java.io.InputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Set;
+import static com.sun.java.util.jar.pack.Constants.*;
 /**
 * Reader for a package file.
 *
 * @see PackageWriter
 case CONSTANT_Integer:
 cp_Int.expectLength(cpMap.length);
 cp_Int.readFrom(in);
 for (int i = 0; i < cpMap.length; i++) {
 int x = cp_Int.getInt();  // coding handles signs OK
-cpMap[i] = ConstantPool.getLiteralEntry(new Integer(x));
+cpMap[i] = ConstantPool.getLiteralEntry(x);
 }
 cp_Int.doneDisbursing();
 break;
 case CONSTANT_Float:
 cp_Float.expectLength(cpMap.length);
 cp_Float.readFrom(in);
 for (int i = 0; i < cpMap.length; i++) {
 int x = cp_Float.getInt();
 float fx = Float.intBitsToFloat(x);
-cpMap[i] = ConstantPool.getLiteralEntry(new Float(fx));
+cpMap[i] = ConstantPool.getLiteralEntry(fx);
 }
 cp_Float.doneDisbursing();
 break;
 case CONSTANT_Long:
 //  cp_Long:
 cp_Long_lo.readFrom(in);
 for (int i = 0; i < cpMap.length; i++) {
 long hi = cp_Long_hi.getInt();
 long lo = cp_Long_lo.getInt();
 long x = (hi << 32) + ((lo << 32) >>> 32);
-cpMap[i] = ConstantPool.getLiteralEntry(new Long(x));
+cpMap[i] = ConstantPool.getLiteralEntry(x);
 }
 cp_Long_hi.doneDisbursing();
 cp_Long_lo.doneDisbursing();
 break;
 case CONSTANT_Double:
 for (int i = 0; i < cpMap.length; i++) {
 long hi = cp_Double_hi.getInt();
 long lo = cp_Double_lo.getInt();
 long x = (hi << 32) + ((lo << 32) >>> 32);
 double dx = Double.longBitsToDouble(x);
-cpMap[i] = ConstantPool.getLiteralEntry(new Double(dx));
+cpMap[i] = ConstantPool.getLiteralEntry(dx);
 }
 cp_Double_hi.doneDisbursing();
 cp_Double_lo.doneDisbursing();
 break;
 case CONSTANT_String:
 cp_Utf8_prefix.doneDisbursing();
 cp_Utf8_suffix.doneDisbursing();
 cp_Utf8_big_suffix.doneDisbursing();
 }
-HashMap utf8Signatures;  // Utf8Entry->SignatureEntry
+Map<Utf8Entry, SignatureEntry> utf8Signatures;
 void readSignatureBands(Entry[] cpMap) throws IOException {
 //  cp_Signature:
 //        *cp_Signature_form :DELTA5  (cp_Utf8)
 //        *cp_Signature_classes :UDELTA5  (cp_Class)
 }
 cp_Signature_form.resetForSecondPass();
 cp_Signature_classes.expectLength(getIntTotal(numSigClasses));
 cp_Signature_classes.readFrom(in);
 cp_Signature_classes.setIndex(getCPIndex(CONSTANT_Class));
-utf8Signatures = new HashMap();
+utf8Signatures = new HashMap<>();
 for (int i = 0; i < cpMap.length; i++) {
 Utf8Entry formRef = (Utf8Entry) cp_Signature_form.getRef();
 ClassEntry[] classRefs = new ClassEntry[numSigClasses[i]];
 for (int j = 0; j < classRefs.length; j++) {
 classRefs[j] = (ClassEntry) cp_Signature_classes.getRef();
 ic_outer_class.expectLength(longICCount);
 ic_outer_class.readFrom(in);
 ic_name.expectLength(longICCount);
 ic_name.readFrom(in);
 ic_flags.resetForSecondPass();
-ArrayList icList = new ArrayList(numInnerClasses);
+List<InnerClass> icList = new ArrayList<>(numInnerClasses);
 for (int i = 0; i < numInnerClasses; i++) {
 int flags = ic_flags.getInt();
 boolean longForm = (flags & ACC_IC_LONG_FORM) != 0;
 flags &= ~ACC_IC_LONG_FORM;
 ClassEntry thisClass = (ClassEntry) ic_this_class.getRef();
 if (longForm) {
 outerClass = (ClassEntry) ic_outer_class.getRef();
 thisName   = (Utf8Entry)  ic_name.getRef();
 } else {
 String n = thisClass.stringValue();
-String[] parse = pkg.parseInnerClassName(n);
+String[] parse = Package.parseInnerClassName(n);
 assert(parse != null);
 String pkgOuter = parse[0];
 //String number = parse[1];
 String name     = parse[2];
 if (pkgOuter == null)
 ic_bands.doneDisbursing();
 }
 void readLocalInnerClasses(Class cls) throws IOException {
 int nc = class_InnerClasses_N.getInt();
-ArrayList localICs = new ArrayList(nc);
+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.
 return pkg.cp.untypedIndexOf(se);
 }
 return -1;
 }
-Comparator entryOutputOrder = new Comparator() {
+Comparator<Entry> entryOutputOrder = new Comparator<>() {
-public int compare(Object o0, Object o1) {
+public int compare(Entry  e0, Entry e1) {
-Entry e0 = (Entry) o0;
-Entry e1 = (Entry) o1;
 int k0 = getOutputIndex(e0);
 int k1 = getOutputIndex(e1);
 if (k0 >= 0 && k1 >= 0)
 // If both have keys, use the keys.
 return k0 - k1;
 // record the local cp:
 cls.setCPMap(reconstructLocalCPMap(cls));
 }
 Entry[] reconstructLocalCPMap(Class cls) {
-HashSet ldcRefs = (HashSet) ldcRefMap.get(cls);
+Set<Entry> ldcRefs = ldcRefMap.get(cls);
-HashSet cpRefs = new HashSet();
+Set<Entry> cpRefs = new HashSet<>();
-HashSet sigSet = new HashSet();
 // look for constant pool entries:
 cls.visitRefs(VRM_CLASSIC, cpRefs);
 // flesh out the local constant pool
 ConstantPool.completeReferencesIn(cpRefs, true);
 }
 // construct a local constant pool
 int numDoubles = 0;
-for (Iterator i = cpRefs.iterator(); i.hasNext(); ) {
+for (Entry e : cpRefs) {
-Entry e = (Entry) i.next();
 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 (Iterator i = ldcRefs.iterator(); i.hasNext(); ) {
+for (Entry e : ldcRefs) {
-Entry e = (Entry) i.next();
 cpMap[fillp++] = e;
 }
 assert(fillp == 1+ldcRefs.size());
 cpRefs.removeAll(ldcRefs);
 ldcRefs = null;  // done with it
 }
 // Next add all the two-byte references.
-HashSet wideRefs = cpRefs;
+Set<Entry> wideRefs = cpRefs;
 cpRefs = null;  // do not use!
 int narrowLimit = fillp;
-for (Iterator i = wideRefs.iterator(); i.hasNext(); ) {
+for (Entry e : wideRefs) {
-Entry e = (Entry) i.next();
 cpMap[fillp++] = e;
 }
 assert(fillp == narrowLimit+wideRefs.size());
 Arrays.sort(cpMap, 1, narrowLimit, entryOutputOrder);
 Arrays.sort(cpMap, narrowLimit, fillp, entryOutputOrder);
 int totalNM = class_method_count.getIntTotal();
 field_descr.expectLength(totalNF);
 method_descr.expectLength(totalNM);
 if (verbose > 1)  Utils.log.fine("expecting #fields="+totalNF+" and #methods="+totalNM+" in #classes="+numClasses);
-ArrayList fields = new ArrayList(totalNF);
+List<Class.Field> fields = new ArrayList<>(totalNF);
 field_descr.readFrom(in);
 for (int i = 0; i < classes.length; i++) {
 Class c = classes[i];
 int nf = class_field_count.getInt();
 for (int j = 0; j < nf; j++) {
 class_field_count.doneDisbursing();
 field_descr.doneDisbursing();
 countAndReadAttrs(ATTR_CONTEXT_FIELD, fields);
 fields = null;  // release to GC
-ArrayList methods = new ArrayList(totalNM);
+List<Class.Method> methods = new ArrayList<>(totalNM);
 method_descr.readFrom(in);
 for (int i = 0; i < classes.length; i++) {
 Class c = classes[i];
 int nm = class_method_count.getInt();
 for (int j = 0; j < nm; j++) {
 // attributes stay in the method attribute lists, however.
 allCodes = buildCodeAttrs(methods);
 }
 Code[] allCodes;
-List codesWithFlags;
+List<Code> codesWithFlags;
-HashMap ldcRefMap = new HashMap();  // HashMap<Class, HashSet<Entry>>
+Map<Class, Set<Entry>> ldcRefMap = new HashMap<>();
-Code[] buildCodeAttrs(List methods) {
+Code[] buildCodeAttrs(List<Class.Method> methods) {
-ArrayList codes = new ArrayList(methods.size());
+List<Code> codes = new ArrayList<>(methods.size());
-for (Iterator i = methods.iterator(); i.hasNext(); ) {
+for (Class.Method m : methods) {
-Class.Method m = (Class.Method) i.next();
 if (m.getAttribute(attrCodeEmpty) != null) {
 m.code = new Code(m);
 codes.add(m.code);
 }
 }
 //        ...
 //        code_attr_bands
 boolean attrsOK = testBit(archiveOptions, AO_HAVE_ALL_CODE_FLAGS);
 code_headers.expectLength(allCodes.length);
 code_headers.readFrom(in);
-ArrayList longCodes = new ArrayList(allCodes.length / 10);
+List<Code> longCodes = new ArrayList<>(allCodes.length / 10);
 for (int i = 0; i < allCodes.length; i++) {
 Code c = allCodes[i];
 int sc = code_headers.getByte();
 assert(sc == (sc & 0xFF));
 if (verbose > 2)
 // Do the long headers now.
 code_max_stack.readFrom(in);
 code_max_na_locals.readFrom(in);
 code_handler_count.readFrom(in);
-for (Iterator i = longCodes.iterator(); i.hasNext(); ) {
+for (Code c : longCodes) {
-Code c = (Code) i.next();
 c.setMaxStack(     code_max_stack.getInt() );
 c.setMaxNALocals(  code_max_na_locals.getInt() );
 c.setHandlerCount( code_handler_count.getInt() );
 }
 code_max_stack.doneDisbursing();
 Utils.log.fine("scanning flags and attrs for "+Attribute.contextName(ctype)+"["+holders.size()+"]");
 }
 // Fetch the attribute layout definitions which govern the bands
 // we are about to read.
-Attribute.Layout[] defs = new Attribute.Layout[attrDefs[ctype].size()];
+List<Attribute.Layout> defList = attrDefs.get(ctype);
-attrDefs[ctype].toArray(defs);
+Attribute.Layout[] defs = new Attribute.Layout[defList.size()];
+defList.toArray(defs);
 IntBand xxx_flags_hi = getAttrBand(xxx_attr_bands, AB_FLAGS_HI);
 IntBand xxx_flags_lo = getAttrBand(xxx_attr_bands, AB_FLAGS_LO);
 IntBand xxx_attr_count = getAttrBand(xxx_attr_bands, AB_ATTR_COUNT);
 IntBand xxx_attr_indexes = getAttrBand(xxx_attr_bands, AB_ATTR_INDEXES);
 IntBand xxx_attr_calls = getAttrBand(xxx_attr_bands, AB_ATTR_CALLS);
 for (int ai = 0; bits != 0; ai++) {
 if ((bits & (1L<<ai)) == 0)  continue;
 bits -= (1L<<ai);
 nfa += 1;
 }
-ArrayList ha = new ArrayList(nfa + noa);
+List<Attribute> ha = new ArrayList<>(nfa + noa);
 h.attributes = ha;
 bits = attrBits;  // iterate again
 for (int ai = 0; bits != 0; ai++) {
 if ((bits & (1L<<ai)) == 0)  continue;
 bits -= (1L<<ai);
 Attribute.Layout def = defs[ai];
 if (def == null)  continue;  // unused index
 if (predef != isPredefinedAttr(ctype, ai))
 continue;  // wrong pass
 int totalCount = totalCounts[ai];
-Band[] ab = (Band[]) attrBandTable.get(def);
+Band[] ab = attrBandTable.get(def);
 if (def == attrInnerClassesEmpty) {
 // Special case.
 // Size the bands as if using the following layout:
 //    [RCH TI[ (0)[] ()[RCNH RUNH] ]].
 class_InnerClasses_N.expectLength(totalCount);
 void badAttrIndex(int ai, int ctype) throws IOException {
 throw new IOException("Unknown attribute index "+ai+" for "+
 ATTR_CONTEXT_NAME[ctype]+" attribute");
 }
+@SuppressWarnings("unchecked")
 void readAttrs(int ctype, Collection holders) throws IOException {
 // Decode band values into attributes.
-HashSet sawDefs = new HashSet();
+Set<Attribute.Layout> sawDefs = new HashSet<>();
 ByteArrayOutputStream buf = new ByteArrayOutputStream();
 for (Iterator i = holders.iterator(); i.hasNext(); ) {
 final Attribute.Holder h = (Attribute.Holder) i.next();
 if (h.attributes == null)  continue;
-for (ListIterator j = h.attributes.listIterator(); j.hasNext(); ) {
+for (ListIterator<Attribute> j = h.attributes.listIterator(); j.hasNext(); ) {
-Attribute a = (Attribute) j.next();
+Attribute a = j.next();
 Attribute.Layout def = a.layout();
 if (def.bandCount == 0) {
 if (def == attrInnerClassesEmpty) {
 // Special logic to read this attr.
 readLocalInnerClasses((Class) h);
 sawDefs.add(def);
 boolean isCV = (ctype == ATTR_CONTEXT_FIELD && def == attrConstantValue);
 if (isCV)  setConstantValueIndex((Class.Field)h);
 if (verbose > 2)
 Utils.log.fine("read "+a+" in "+h);
-final Band[] ab = (Band[]) attrBandTable.get(def);
+final Band[] ab = attrBandTable.get(def);
 // Read one attribute of type def from ab into a byte array.
 buf.reset();
 Object fixups = a.unparse(new Attribute.ValueStream() {
 public int getInt(int bandIndex) {
 return ((IntBand) ab[bandIndex]).getInt();
 if (isCV)  setConstantValueIndex(null);  // clean up
 }
 }
 // Mark the bands we just used as done disbursing.
-for (Iterator i = sawDefs.iterator(); i.hasNext(); ) {
+for (Attribute.Layout def : sawDefs) {
-Attribute.Layout def = (Attribute.Layout) i.next();
 if (def == null)  continue;  // unused index
-Band[] ab = (Band[]) attrBandTable.get(def);
+Band[] ab = attrBandTable.get(def);
 for (int j = 0; j < ab.length; j++) {
 ab[j].doneDisbursing();
 }
 }
 private void readByteCodeOps() throws IOException {
 // scratch buffer for collecting code::
 byte[] buf = new byte[1<<12];
 // record of all switch opcodes (these are variable-length)
-ArrayList allSwitchOps = new ArrayList();
+List<Integer> allSwitchOps = new ArrayList<>();
 for (int k = 0; k < allCodes.length; k++) {
 Code c = allCodes[k];
 scanOneMethod:
 for (int i = 0; ; i++) {
 int bc = bc_codes.getByte();
 // Adjust expectations of various band sizes.
 switch (bc) {
 case _tableswitch:
 case _lookupswitch:
 bc_case_count.expectMoreLength(1);
-allSwitchOps.add(new Integer(bc));
+allSwitchOps.add(bc);
 break;
 case _iinc:
 bc_local.expectMoreLength(1);
 if (isWide)
 bc_short.expectMoreLength(1);
 }
 }
 // To size instruction bands correctly, we need info on switches:
 bc_case_count.readFrom(in);
-for (Iterator i = allSwitchOps.iterator(); i.hasNext(); ) {
+for (Integer i : allSwitchOps) {
-int bc = ((Integer)i.next()).intValue();
+int bc = i.intValue();
 int caseCount = bc_case_count.getInt();
 bc_label.expectMoreLength(1+caseCount); // default label + cases
 bc_case_value.expectMoreLength(bc == _tableswitch ? 1 : caseCount);
 }
 bc_case_count.resetForSecondPass();
 byte[] codeOps = code.bytes;
 code.bytes = null;  // just for now, while we accumulate bits
 Class curClass = code.thisClass();
-HashSet ldcRefSet = (HashSet) ldcRefMap.get(curClass);
+Set<Entry> ldcRefSet = ldcRefMap.get(curClass);
 if (ldcRefSet == null)
-ldcRefMap.put(curClass, ldcRefSet = new HashSet());
+ldcRefMap.put(curClass, ldcRefSet = new HashSet<>());
 ClassEntry thisClass  = curClass.thisClass;
 ClassEntry superClass = curClass.superClass;
 ClassEntry newClass   = null;  // class of last _new opcode

changeset 7795	98021fc612af
parent 7192	445c518364c4
child 7816	55a18147b4bf