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

--1:000000000000
+:959103a6100f
+/*
+* Copyright (c) 2009, 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.tools.classfile;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Pattern;
+import com.sun.tools.classfile.Dependency.Filter;
+import com.sun.tools.classfile.Dependency.Finder;
+import com.sun.tools.classfile.Dependency.Location;
+import com.sun.tools.classfile.Type.ArrayType;
+import com.sun.tools.classfile.Type.ClassSigType;
+import com.sun.tools.classfile.Type.ClassType;
+import com.sun.tools.classfile.Type.MethodType;
+import com.sun.tools.classfile.Type.SimpleType;
+import com.sun.tools.classfile.Type.TypeParamType;
+import com.sun.tools.classfile.Type.WildcardType;
+import static com.sun.tools.classfile.ConstantPool.*;
+/**
+* A framework for determining {@link Dependency dependencies} between class files.
+*
+* A {@link Dependency.Finder finder} is used to identify the dependencies of
+* individual classes. Some finders may return subtypes of {@code Dependency} to
+* further characterize the type of dependency, such as a dependency on a
+* method within a class.
+*
+* A {@link Dependency.Filter filter} may be used to restrict the set of
+* dependencies found by a finder.
+*
+* Dependencies that are found may be passed to a {@link Dependencies.Recorder
+* recorder} so that the dependencies can be stored in a custom data structure.
+*/
+public class Dependencies {
+/**
+* Thrown when a class file cannot be found.
+*/
+public static class ClassFileNotFoundException extends Exception {
+private static final long serialVersionUID = 3632265927794475048L;
+public ClassFileNotFoundException(String className) {
+super(className);
+this.className = className;
+}
+public ClassFileNotFoundException(String className, Throwable cause) {
+this(className);
+initCause(cause);
+}
+public final String className;
+}
+/**
+* Thrown when an exception is found processing a class file.
+*/
+public static class ClassFileError extends Error {
+private static final long serialVersionUID = 4111110813961313203L;
+public ClassFileError(Throwable cause) {
+initCause(cause);
+}
+}
+/**
+* Service provider interface to locate and read class files.
+*/
+public interface ClassFileReader {
+/**
+* Get the ClassFile object for a specified class.
+* @param className the name of the class to be returned.
+* @return the ClassFile for the given class
+* @throws Dependencies.ClassFileNotFoundException if the classfile cannot be
+*   found
+*/
+public ClassFile getClassFile(String className)
+throws ClassFileNotFoundException;
+}
+/**
+* Service provide interface to handle results.
+*/
+public interface Recorder {
+/**
+* Record a dependency that has been found.
+* @param d
+*/
+public void addDependency(Dependency d);
+}
+/**
+* Get the  default finder used to locate the dependencies for a class.
+* @return the default finder
+*/
+public static Finder getDefaultFinder() {
+return new APIDependencyFinder(AccessFlags.ACC_PRIVATE);
+}
+/**
+* Get a finder used to locate the API dependencies for a class.
+* These include the superclass, superinterfaces, and classes referenced in
+* the declarations of fields and methods.  The fields and methods that
+* are checked can be limited according to a specified access.
+* The access parameter must be one of {@link AccessFlags#ACC_PUBLIC ACC_PUBLIC},
+* {@link AccessFlags#ACC_PRIVATE ACC_PRIVATE},
+* {@link AccessFlags#ACC_PROTECTED ACC_PROTECTED}, or 0 for
+* package private access. Members with greater than or equal accessibility
+* to that specified will be searched for dependencies.
+* @param access the access of members to be checked
+* @return an API finder
+*/
+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)
+finder = getDefaultFinder();
+return finder;
+}
+/**
+* Set the finder used to locate the dependencies for a class.
+* @param f the finder
+*/
+public void setFinder(Finder f) {
+f.getClass(); // null check
+finder = f;
+}
+/**
+* Get the default filter used to determine included when searching
+* the transitive closure of all the dependencies.
+* Unless overridden, the default filter accepts all dependencies.
+* @return the default filter.
+*/
+public static Filter getDefaultFilter() {
+return DefaultFilter.instance();
+}
+/**
+* Get a filter which uses a regular expression on the target's class name
+* to determine if a dependency is of interest.
+* @param pattern the pattern used to match the target's class name
+* @return a filter for matching the target class name with a regular expression
+*/
+public static Filter getRegexFilter(Pattern pattern) {
+return new TargetRegexFilter(pattern);
+}
+/**
+* Get a filter which checks the package of a target's class name
+* to determine if a dependency is of interest. The filter checks if the
+* package of the target's class matches any of a set of given package
+* names. The match may optionally match subpackages of the given names as well.
+* @param packageNames the package names used to match the target's class name
+* @param matchSubpackages whether or not to match subpackages as well
+* @return a filter for checking the target package name against a list of package names
+*/
+public static Filter getPackageFilter(Set<String> packageNames, boolean matchSubpackages) {
+return new TargetPackageFilter(packageNames, matchSubpackages);
+}
+/**
+* Get the filter used to determine the dependencies included when searching
+* the transitive closure of all the dependencies.
+* Unless overridden, the default filter accepts all dependencies.
+* @return the filter
+*/
+public Filter getFilter() {
+if (filter == null)
+filter = getDefaultFilter();
+return filter;
+}
+/**
+* Set the filter used to determine the dependencies included when searching
+* the transitive closure of all the dependencies.
+* @param f the filter
+*/
+public void setFilter(Filter f) {
+f.getClass(); // null check
+filter = f;
+}
+/**
+* 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
+* filtered dependencies, by also searching in the classes named in those
+* dependencies.
+* @param classFinder a finder to locate class files
+* @param rootClassNames the names of the root classes from which to begin
+*      searching
+* @param transitiveClosure whether or not to also search those classes
+*      named in any filtered dependencies that are found.
+* @return the set of dependencies that were found
+* @throws ClassFileNotFoundException if a required class file cannot be found
+* @throws ClassFileError if an error occurs while processing a class file,
+*      such as an error in the internal class file structure.
+*/
+public Set<Dependency> findAllDependencies(
+ClassFileReader classFinder, Set<String> rootClassNames,
+boolean transitiveClosure)
+throws ClassFileNotFoundException {
+final Set<Dependency> results = new HashSet<Dependency>();
+Recorder r = new Recorder() {
+public void addDependency(Dependency d) {
+results.add(d);
+}
+};
+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
+* filtered dependencies, by also searching in the classes named in those
+* dependencies.
+* @param classFinder a finder to locate class files
+* @param rootClassNames the names of the root classes from which to begin
+*      searching
+* @param transitiveClosure whether or not to also search those classes
+*      named in any filtered dependencies that are found.
+* @param recorder a recorder for handling the results
+* @throws ClassFileNotFoundException if a required class file cannot be found
+* @throws ClassFileError if an error occurs while processing a class file,
+*      such as an error in the internal class file structure.
+*/
+public void findAllDependencies(
+ClassFileReader classFinder, Set<String> rootClassNames,
+boolean transitiveClosure, Recorder recorder)
+throws ClassFileNotFoundException {
+Set<String> doneClasses = new HashSet<String>();
+getFinder();  // ensure initialized
+getFilter();  // ensure initialized
+// Work queue of names of classfiles to be searched.
+// Entries will be unique, and for classes that do not yet have
+// dependencies in the results map.
+Deque<String> deque = new LinkedList<String>(rootClassNames);
+String className;
+while ((className = deque.poll()) != null) {
+assert (!doneClasses.contains(className));
+doneClasses.add(className);
+ClassFile cf = classFinder.getClassFile(className);
+// The following code just applies the filter to the dependencies
+// followed for the transitive closure.
+for (Dependency d: finder.findDependencies(cf)) {
+recorder.addDependency(d);
+if (transitiveClosure && filter.accepts(d)) {
+String cn = d.getTarget().getClassName();
+if (!doneClasses.contains(cn))
+deque.add(cn);
+}
+}
+}
+}
+private Filter filter;
+private Finder finder;
+/**
+* A location identifying a class.
+*/
+static class SimpleLocation implements Location {
+public SimpleLocation(String name) {
+this.name = name;
+this.className = name.replace('/', '.');
+}
+public String getName() {
+return name;
+}
+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 (name.equals(((SimpleLocation) other).name));
+}
+@Override
+public int hashCode() {
+return name.hashCode();
+}
+@Override
+public String toString() {
+return name;
+}
+private String name;
+private String className;
+}
+/**
+* A dependency of one class on another.
+*/
+static class SimpleDependency implements Dependency {
+public SimpleDependency(Location origin, Location target) {
+this.origin = origin;
+this.target = target;
+}
+public Location getOrigin() {
+return origin;
+}
+public Location getTarget() {
+return target;
+}
+@Override
+public boolean equals(Object other) {
+if (this == other)
+return true;
+if (!(other instanceof SimpleDependency))
+return false;
+SimpleDependency o = (SimpleDependency) other;
+return (origin.equals(o.origin) && target.equals(o.target));
+}
+@Override
+public int hashCode() {
+return origin.hashCode() * 31 + target.hashCode();
+}
+@Override
+public String toString() {
+return origin + ":" + target;
+}
+private Location origin;
+private Location target;
+}
+/**
+* This class accepts all dependencies.
+*/
+static class DefaultFilter implements Filter {
+private static DefaultFilter instance;
+static DefaultFilter instance() {
+if (instance == null)
+instance = new DefaultFilter();
+return instance;
+}
+public boolean accepts(Dependency dependency) {
+return true;
+}
+}
+/**
+* This class accepts those dependencies whose target's class name matches a
+* regular expression.
+*/
+static class TargetRegexFilter implements Filter {
+TargetRegexFilter(Pattern pattern) {
+this.pattern = pattern;
+}
+public boolean accepts(Dependency dependency) {
+return pattern.matcher(dependency.getTarget().getClassName()).matches();
+}
+private final Pattern pattern;
+}
+/**
+* This class accepts those dependencies whose class name is in a given
+* package.
+*/
+static class TargetPackageFilter implements Filter {
+TargetPackageFilter(Set<String> packageNames, boolean matchSubpackages) {
+for (String pn: packageNames) {
+if (pn.length() == 0) // implies null check as well
+throw new IllegalArgumentException();
+}
+this.packageNames = packageNames;
+this.matchSubpackages = matchSubpackages;
+}
+public boolean accepts(Dependency dependency) {
+String pn = dependency.getTarget().getPackageName();
+if (packageNames.contains(pn))
+return true;
+if (matchSubpackages) {
+for (String n: packageNames) {
+if (pn.startsWith(n + "."))
+return true;
+}
+}
+return false;
+}
+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;
+}
+}
+/**
+* This class identifies class names in the signatures of classes, fields,
+* and methods in a class.
+*/
+static class APIDependencyFinder extends BasicDependencyFinder {
+APIDependencyFinder(int access) {
+switch (access) {
+case AccessFlags.ACC_PUBLIC:
+case AccessFlags.ACC_PROTECTED:
+case AccessFlags.ACC_PRIVATE:
+case 0:
+showAccess = access;
+break;
+default:
+throw new IllegalArgumentException("invalid access 0x"
++ Integer.toHexString(access));
+}
+}
+public Iterable<? extends Dependency> findDependencies(ClassFile classfile) {
+try {
+Visitor v = new Visitor(classfile);
+v.addClass(classfile.super_class);
+v.addClasses(classfile.interfaces);
+// inner classes?
+for (Field f : classfile.fields) {
+if (checkAccess(f.access_flags))
+v.scan(f.descriptor, f.attributes);
+}
+for (Method m : classfile.methods) {
+if (checkAccess(m.access_flags)) {
+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);
+}
+}
+return v.deps;
+} catch (ConstantPoolException e) {
+throw new ClassFileError(e);
+}
+}
+boolean checkAccess(AccessFlags flags) {
+// code copied from javap.Options.checkAccess
+boolean isPublic = flags.is(AccessFlags.ACC_PUBLIC);
+boolean isProtected = flags.is(AccessFlags.ACC_PROTECTED);
+boolean isPrivate = flags.is(AccessFlags.ACC_PRIVATE);
+boolean isPackage = !(isPublic || isProtected || isPrivate);
+if ((showAccess == AccessFlags.ACC_PUBLIC) && (isProtected || isPrivate || isPackage))
+return false;
+else if ((showAccess == AccessFlags.ACC_PROTECTED) && (isPrivate || isPackage))
+return false;
+else if ((showAccess == 0) && (isPrivate))
+return false;
+else
+return true;
+}
+private int showAccess;
+}
+static abstract class BasicDependencyFinder implements Finder {
+private Map<String,Location> locations = new HashMap<String,Location>();
+Location getLocation(String className) {
+Location l = locations.get(className);
+if (l == null)
+locations.put(className, l = new SimpleLocation(className));
+return l;
+}
+class Visitor implements ConstantPool.Visitor<Void,Void>, Type.Visitor<Void, Void> {
+private ConstantPool constant_pool;
+private Location origin;
+Set<Dependency> deps;
+Visitor(ClassFile classFile) {
+try {
+constant_pool = classFile.constant_pool;
+origin = getLocation(classFile.getName());
+deps = new HashSet<Dependency>();
+} catch (ConstantPoolException e) {
+throw new ClassFileError(e);
+}
+}
+void scan(Descriptor d, Attributes attrs) {
+try {
+scan(new Signature(d.index).getType(constant_pool));
+scan(attrs);
+} catch (ConstantPoolException e) {
+throw new ClassFileError(e);
+}
+}
+void scan(CPInfo cpInfo) {
+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();
+if (name != null)
+addDependency(name);
+}
+}
+void addClasses(int[] indices) throws ConstantPoolException {
+for (int i: indices)
+addClass(i);
+}
+private void addDependency(String name) {
+deps.add(new SimpleDependency(origin, getLocation(name)));
+}
+// ConstantPool.Visitor methods
+public Void visitClass(CONSTANT_Class_info info, Void p) {
+try {
+if (info.getName().startsWith("["))
+new Signature(info.name_index).getType(constant_pool).accept(this, null);
+else
+addDependency(info.getBaseName());
+return null;
+} catch (ConstantPoolException e) {
+throw new ClassFileError(e);
+}
+}
+public Void visitDouble(CONSTANT_Double_info info, Void p) {
+return null;
+}
+public Void visitFieldref(CONSTANT_Fieldref_info info, Void p) {
+return visitRef(info, p);
+}
+public Void visitFloat(CONSTANT_Float_info info, Void p) {
+return null;
+}
+public Void visitInteger(CONSTANT_Integer_info info, Void p) {
+return null;
+}
+public Void visitInterfaceMethodref(CONSTANT_InterfaceMethodref_info info, Void p) {
+return visitRef(info, p);
+}
+public Void visitInvokeDynamic(CONSTANT_InvokeDynamic_info info, Void p) {
+return null;
+}
+public Void visitLong(CONSTANT_Long_info info, Void p) {
+return null;
+}
+public Void visitMethodHandle(CONSTANT_MethodHandle_info info, Void p) {
+return null;
+}
+public Void visitMethodType(CONSTANT_MethodType_info info, Void p) {
+return null;
+}
+public Void visitMethodref(CONSTANT_Methodref_info info, Void p) {
+return visitRef(info, p);
+}
+public Void visitNameAndType(CONSTANT_NameAndType_info info, Void p) {
+try {
+new Signature(info.type_index).getType(constant_pool).accept(this, null);
+return null;
+} catch (ConstantPoolException e) {
+throw new ClassFileError(e);
+}
+}
+public Void visitString(CONSTANT_String_info info, Void p) {
+return null;
+}
+public Void visitUtf8(CONSTANT_Utf8_info info, Void p) {
+return null;
+}
+private Void visitRef(CPRefInfo info, Void p) {
+try {
+visitClass(info.getClassInfo(), p);
+return null;
+} catch (ConstantPoolException e) {
+throw new ClassFileError(e);
+}
+}
+// Type.Visitor methods
+private void findDependencies(Type t) {
+if (t != null)
+t.accept(this, null);
+}
+private void findDependencies(List<? extends Type> ts) {
+if (ts != null) {
+for (Type t: ts)
+t.accept(this, null);
+}
+}
+public Void visitSimpleType(SimpleType type, Void p) {
+return null;
+}
+public Void visitArrayType(ArrayType type, Void p) {
+findDependencies(type.elemType);
+return null;
+}
+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);
+findDependencies(type.superinterfaceTypes);
+return null;
+}
+public Void visitClassType(ClassType type, Void p) {
+findDependencies(type.outerType);
+addDependency(type.getBinaryName());
+findDependencies(type.typeArgs);
+return null;
+}
+public Void visitTypeParamType(TypeParamType type, Void p) {
+findDependencies(type.classBound);
+findDependencies(type.interfaceBounds);
+return null;
+}
+public Void visitWildcardType(WildcardType type, Void p) {
+findDependencies(type.boundType);
+return null;
+}
+}
+}
+}

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