jdk8-mips64-public/langtools: comparison src/share/classes/com/sun/tools/classfile/Dependencies.java

-:690c41cdab55
+:0c244701188e
 public static Finder getAPIFinder(int access) {
 return new APIDependencyFinder(access);
 }
 /**
+* Get a finder to do class dependency analysis.
+*
+* @return a Class dependency finder
+*/
+public static Finder getClassDependencyFinder() {
+return new ClassDependencyFinder();
+}
+/**
 * Get the finder used to locate the dependencies for a class.
 * @return the finder
 */
 public Finder getFinder() {
 if (finder == null)
 };
 findAllDependencies(classFinder, rootClassNames, transitiveClosure, r);
 return results;
 }
 /**
 * Find the dependencies of a class, using the current
 * {@link Dependencies#getFinder finder} and
 * {@link Dependencies#getFilter filter}.
 * The search may optionally include the transitive closure of all the
 /**
 * A location identifying a class.
 */
 static class SimpleLocation implements Location {
-public SimpleLocation(String className) {
+public SimpleLocation(String name) {
-this.className = className;
+this.name = name;
-}
+this.className = name.replace('/', '.').replace('$', '.');
+}
-/**
-* Get the name of the class being depended on. This name will be used to
+public String getName() {
-* locate the class file for transitive dependency analysis.
+return name;
-* @return the name of the class being depended on
+}
-*/
 public String getClassName() {
 return className;
+}
+public String getPackageName() {
+int i = name.lastIndexOf('/');
+return (i > 0) ? name.substring(0, i).replace('/', '.') : "";
 }
 @Override
 public boolean equals(Object other) {
 if (this == other)
 return true;
 if (!(other instanceof SimpleLocation))
 return false;
-return (className.equals(((SimpleLocation) other).className));
+return (name.equals(((SimpleLocation) other).name));
 }
 @Override
 public int hashCode() {
-return className.hashCode();
+return name.hashCode();
 }
 @Override
 public String toString() {
-return className;
+return name;
 }
+private String name;
 private String className;
 }
 /**
 * A dependency of one class on another.
 this.packageNames = packageNames;
 this.matchSubpackages = matchSubpackages;
 }
 public boolean accepts(Dependency dependency) {
-String cn = dependency.getTarget().getClassName();
+String pn = dependency.getTarget().getPackageName();
-int lastSep = cn.lastIndexOf("/");
-String pn = (lastSep == -1 ? "" : cn.substring(0, lastSep));
 if (packageNames.contains(pn))
 return true;
 if (matchSubpackages) {
 for (String n: packageNames) {
 }
 private final Set<String> packageNames;
 private final boolean matchSubpackages;
 }
 /**
 * This class identifies class names directly or indirectly in the constant pool.
 */
 static class ClassDependencyFinder extends BasicDependencyFinder {
 public Iterable<? extends Dependency> findDependencies(ClassFile classfile) {
 Visitor v = new Visitor(classfile);
 for (CPInfo cpInfo: classfile.constant_pool.entries()) {
 v.scan(cpInfo);
 }
+try {
+v.addClass(classfile.super_class);
+v.addClasses(classfile.interfaces);
+v.scan(classfile.attributes);
+for (Field f : classfile.fields) {
+v.scan(f.descriptor, f.attributes);
+}
+for (Method m : classfile.methods) {
+v.scan(m.descriptor, m.attributes);
+Exceptions_attribute e =
+(Exceptions_attribute)m.attributes.get(Attribute.Exceptions);
+if (e != null) {
+v.addClasses(e.exception_index_table);
+}
+}
+} catch (ConstantPoolException e) {
+throw new ClassFileError(e);
+}
 return v.deps;
 }
 }
 /**
 }
 void scan(Descriptor d, Attributes attrs) {
 try {
 scan(new Signature(d.index).getType(constant_pool));
-Signature_attribute sa = (Signature_attribute) attrs.get(Attribute.Signature);
+scan(attrs);
-if (sa != null)
-scan(new Signature(sa.signature_index).getType(constant_pool));
 } catch (ConstantPoolException e) {
 throw new ClassFileError(e);
 }
 }
 cpInfo.accept(this, null);
 }
 void scan(Type t) {
 t.accept(this, null);
+}
+void scan(Attributes attrs) {
+try {
+Signature_attribute sa = (Signature_attribute)attrs.get(Attribute.Signature);
+if (sa != null)
+scan(sa.getParsedSignature().getType(constant_pool));
+scan((RuntimeVisibleAnnotations_attribute)
+attrs.get(Attribute.RuntimeVisibleAnnotations));
+scan((RuntimeVisibleParameterAnnotations_attribute)
+attrs.get(Attribute.RuntimeVisibleParameterAnnotations));
+} catch (ConstantPoolException e) {
+throw new ClassFileError(e);
+}
+}
+private void scan(RuntimeAnnotations_attribute attr) throws ConstantPoolException {
+if (attr == null) {
+return;
+}
+for (int i = 0; i < attr.annotations.length; i++) {
+int index = attr.annotations[i].type_index;
+scan(new Signature(index).getType(constant_pool));
+}
+}
+private void scan(RuntimeParameterAnnotations_attribute attr) throws ConstantPoolException {
+if (attr == null) {
+return;
+}
+for (int param = 0; param < attr.parameter_annotations.length; param++) {
+for (int i = 0; i < attr.parameter_annotations[param].length; i++) {
+int index = attr.parameter_annotations[param][i].type_index;
+scan(new Signature(index).getType(constant_pool));
+}
+}
 }
 void addClass(int index) throws ConstantPoolException {
 if (index != 0) {
 String name = constant_pool.getClassInfo(index).getBaseName();
 public Void visitMethodType(MethodType type, Void p) {
 findDependencies(type.paramTypes);
 findDependencies(type.returnType);
 findDependencies(type.throwsTypes);
+findDependencies(type.typeParamTypes);
 return null;
 }
 public Void visitClassSigType(ClassSigType type, Void p) {
 findDependencies(type.superclassType);
 return null;
 }
 public Void visitClassType(ClassType type, Void p) {
 findDependencies(type.outerType);
-addDependency(type.name);
+addDependency(type.getBinaryName());
 findDependencies(type.typeArgs);
 return null;
 }
 public Void visitTypeParamType(TypeParamType type, Void p) {

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: src/share/classes/com/sun/tools/classfile/Dependencies.java

src/share/classes/com/sun/tools/classfile/Dependencies.java