import org.apache.bcel.classfile.DescendingVisitor; //导入依赖的package包/类
private CPESSC_Visitor(JavaClass _jc){
	jc = _jc;
	cp = _jc.getConstantPool();
	cplen = cp.getLength();

	CONST_Class = org.apache.bcel.classfile.ConstantClass.class;
	/*
          CONST_Fieldref = org.apache.bcel.classfile.ConstantFieldref.class;
	CONST_Methodref = org.apache.bcel.classfile.ConstantMethodref.class;
	CONST_InterfaceMethodref = org.apache.bcel.classfile.ConstantInterfaceMethodref.class;
          */
	CONST_String = org.apache.bcel.classfile.ConstantString.class;
	CONST_Integer = org.apache.bcel.classfile.ConstantInteger.class;
	CONST_Float = org.apache.bcel.classfile.ConstantFloat.class;
	CONST_Long = org.apache.bcel.classfile.ConstantLong.class;
	CONST_Double = org.apache.bcel.classfile.ConstantDouble.class;
	CONST_NameAndType = org.apache.bcel.classfile.ConstantNameAndType.class;
	CONST_Utf8 = org.apache.bcel.classfile.ConstantUtf8.class;

	carrier = new DescendingVisitor(_jc, this);
	carrier.visit();
}
 

import org.apache.bcel.classfile.DescendingVisitor; //导入依赖的package包/类
/**
 * Traverses a JavaClass parse tree and accepts all registered
 * visitors.
 * @param aJavaClass the root of the tree.
 */
public void walk(JavaClass aJavaClass)
{
    DescendingVisitor visitor =
        new DescendingVisitor(aJavaClass, mVisitor);
    aJavaClass.accept(visitor);
}
 

import org.apache.bcel.classfile.DescendingVisitor; //导入依赖的package包/类
private String[] getRefClasses(String className, byte[] bytecode) {
    String[] result = null;
    try {
        InputStream in = new ByteArrayInputStream(bytecode);
        ClassParser parser = new ClassParser(in, className);
        JavaClass javaClass = parser.parse();
        ClassVisitor visitor;
        if (searchClassForName) {
            visitor = new ClassVisitorSearchCFN(javaClass);
        }
        else {
            visitor = new ClassVisitor(javaClass);
        }
//        ConstantPoolGen pool = new ConstantPoolGen(javaClass.getConstantPool());

        DescendingVisitor dvis = new DescendingVisitor(javaClass, visitor);
        dvis.visit();
        in.close();

        result = visitor.getRefClasses();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return result;
}
 

import org.apache.bcel.classfile.DescendingVisitor; //导入依赖的package包/类
private void verifyClassAdheresToDesign(Design d, InputStream in, String name, File originalClassOrJarFile)
		throws ClassFormatException, IOException {
	try {
		verifiedAtLeastOne = true;
		ClassParser parser = new ClassParser(in, name);
		JavaClass javaClass = parser.parse();
		className = javaClass.getClassName();

		if (!d.needEvalCurrentClass(className))
			return;

		ConstantPool pool = javaClass.getConstantPool();
		processConstantPool(pool);
		VisitorImpl visitor = new VisitorImpl(pool, this, d, task.getLocation());
		DescendingVisitor desc = new DescendingVisitor(javaClass, visitor);
		desc.visit();
	} catch (BuildException e) {
		log(Design.getWrapperMsg(originalClassOrJarFile, e.getMessage()), Project.MSG_ERR);
		designErrors.addElement(e);
	}
}
 

import org.apache.bcel.classfile.DescendingVisitor; //导入依赖的package包/类
@Override
protected JavaClass doParse(String place, InputStream is, String model) throws ParseClassException {

	JavaClass jClass = null;
	try {

		ClassParser parser = new ClassParser(is, null);

		org.apache.bcel.classfile.JavaClass javaClass = parser.parse();

		jClass = new JavaClass("Unknown", true, javaClass.getAccessFlags());
		jClass.setPlace(place);

		JDependClassFileVisitor visitor = this.createVisitor(model);
		visitor.setJavaClass(jClass);
		visitor.setParser(this);

		DescendingVisitor dvisitor = new DescendingVisitor(javaClass, visitor);

		dvisitor.visit();

		visitor.calImportedPackages();

		this.debug("");

		this.getWriter().flush();

		return jClass;
	} catch (Exception e) {
		if (jClass != null) {
			throw new ParseClassException(jClass.getName(), e);
		} else {
			throw new ParseClassException(e);
		}
	}
}
 

import org.apache.bcel.classfile.DescendingVisitor; //导入依赖的package包/类
public XmlvmResource parse() {
    if (!init()) {
        return null;
    }
    new DescendingVisitor(clazz, visitor).visit();
    return new XmlvmResource(org.xmlvm.proc.XmlvmResource.Type.JVM,
            visitor.getXmlvmDocument());
}
 

import org.apache.bcel.classfile.DescendingVisitor; //导入依赖的package包/类
/** Constructs an InnerClassDetector working on the JavaClass _jc. */
public InnerClassDetector(JavaClass _jc){
	jc = _jc;
	cp = jc.getConstantPool();
	(new DescendingVisitor(jc, this)).visit();
}
 

import org.apache.bcel.classfile.DescendingVisitor; //导入依赖的package包/类
JarMetadata parseJar(final File jarFile) throws IOException, NoSuchAlgorithmException {
  List<ClassMetadata> list = new ArrayList<ClassMetadata>();

  final JarFile jfile = new JarFile(jarFile);
  Enumeration<JarEntry> entries = jfile.entries();

  while (entries.hasMoreElements()) {
    final JarEntry entry = entries.nextElement();
    if (entry.isDirectory())
      continue;

    if (entry.getName().endsWith(".class")) {

      JavaClass jclass = new ClassParser(jfile.getInputStream(entry), entry.getName()).parse();
      DependencyEmitter visitor = new DependencyEmitter(jclass);
      DescendingVisitor classWalker = new DescendingVisitor(jclass, visitor);
      classWalker.visit();

      HashCode hash = ByteStreams.hash(new InputSupplier<InputStream>() {
        public InputStream getInput() throws IOException {
          return jfile.getInputStream(entry);
        }
      }, Hashing.sha1());

      visitor.deps.remove(jclass.getClassName());

      ClassMetadata classInfo = new ClassMetadata(hash.toString(), jclass.getClassName(), visitor.deps);
      list.add(classInfo);
    }

  }

  HashCode jarHash = ByteStreams.hash(new InputSupplier<InputStream>() {
    public InputStream getInput() throws IOException {
      return new FileInputStream(jarFile);
    }
  }, Hashing.sha1());

  return new JarMetadata(jarFile.getName(), jarHash.toString(), list);

}
 

import org.apache.bcel.classfile.DescendingVisitor; //导入依赖的package包/类
/**
 * Ensures that the ConstantCP-subclassed entries of the constant
 * pool are valid. According to "Yellin: Low Level Security in Java",
 * this method does not verify the existence of referenced entities
 * (such as classes) but only the formal correctness (such as well-formed
 * signatures).
  * The visitXXX() methods throw ClassConstraintException instances otherwise.
 * <B>Precondition: index-style cross referencing in the constant
 * pool must be valid. Simply invoke constant_pool_entries_satisfy_static_constraints()
 * before.</B>
 *
 * @throws ClassConstraintException otherwise.
 * @see #constant_pool_entries_satisfy_static_constraints()
 */
private void field_and_method_refs_are_valid(){
    try {
	JavaClass jc = Repository.lookupClass(myOwner.getClassName());
	DescendingVisitor v = new DescendingVisitor(jc, new FAMRAV_Visitor(jc));
	v.visit();

    } catch (ClassNotFoundException e) {
	// FIXME: this might not be the best way to handle missing classes.
	throw new AssertionViolatedException("Missing class: " + e.toString());
    }
}
 

import org.apache.bcel.classfile.DescendingVisitor; //导入依赖的package包/类
@Override
public Set<ClassName> resolve(ClassFile classFile) throws IOException {
	eventBus.post(new ClassDependencyResolutionStartEvent("resolving: " + classFile.physicalFile().getAbsolutePath(), this.getClass()));
	
	final JavaClass javaClass = new ClassParser(classFile.toString()).parse();
	
	final DependencyVisitor dependencyVisitor = new DependencyVisitor(javaClass);
	final DescendingVisitor classWalker = new DescendingVisitor(javaClass, dependencyVisitor);
	
	classWalker.visit();
	
	eventBus.post(new ClassDependencyResolutionEndEvent("resolved: " + dependencyVisitor.getFoundDependencies(), this.getClass()));
	
	return dependencyVisitor.getFoundDependencies();
}