import sun.tools.java.ClassDeclaration; //导入依赖的package包/类
protected boolean initParents(ContextStack stack) {

        stack.setNewContextCode(ContextStack.EXTENDS);
        BatchEnvironment env = stack.getEnv();

        // Init parent...

        boolean result = true;

        try {
            ClassDeclaration parentDecl = getClassDefinition().getSuperClass(env);
            if (parentDecl != null) {
                ClassDefinition parentDef = parentDecl.getClassDefinition(env);
                parent = (ClassType) makeType(parentDef.getType(),parentDef,stack);
                if (parent == null) {
                    result = false;
                }
            }
        } catch (ClassNotFound e) {
            classNotFound(stack,e);
            throw new CompilerError("ClassType constructor");
        }

        return result;
    }
 

import sun.tools.java.ClassDeclaration; //导入依赖的package包/类
protected boolean inheritsFrom(ClassDefinition def, ClassDefinition otherDef) {
    if (def == otherDef)
        return true;

    ClassDefinition superDef;
    if (def.getSuperClass() != null) {
        superDef = def.getSuperClass().getClassDefinition();
        if (inheritsFrom(superDef, otherDef))
            return true;
    }

    ClassDeclaration[] interfaces = def.getInterfaces();
    for (int i=0; i<interfaces.length; i++) {
        superDef = interfaces[i].getClassDefinition();
        if (inheritsFrom(superDef, otherDef))
            return true;
    }
    return false;
}
 

import sun.tools.java.ClassDeclaration; //导入依赖的package包/类
/**
 * Sort array of class declarations alphabetically by their mangled
 * fully-qualified class name.  This is used to feed a method's exceptions
 * in a canonical order into the digest stream for the interface hash
 * computation.
 */
private void sortClassDeclarations(ClassDeclaration[] decl) {
    for (int i = 1; i < decl.length; i++) {
        ClassDeclaration curr = decl[i];
        String name = Names.mangleClass(curr.getName()).toString();
        int j;
        for (j = i; j > 0; j--) {
            if (name.compareTo(
                               Names.mangleClass(decl[j - 1].getName()).toString()) >= 0)
                {
                    break;
                }
            decl[j] = decl[j - 1];
        }
        decl[j] = curr;
    }
}
 

import sun.tools.java.ClassDeclaration; //导入依赖的package包/类
/**
 * Add to the supplied list all exceptions in the "from" array
 * that are subclasses of an exception in the "with" array.
 */
private void collectCompatibleExceptions(ClassDeclaration[] from,
                                         ClassDeclaration[] with,
                                         Vector<ClassDeclaration> list)
    throws ClassNotFound
{
    for (int i = 0; i < from.length; i++) {
        ClassDefinition exceptionDef = from[i].getClassDefinition(env);
        if (!list.contains(from[i])) {
            for (int j = 0; j < with.length; j++) {
                if (exceptionDef.subClassOf(env, with[j])) {
                    list.addElement(from[i]);
                    break;
                }
            }
        }
    }
}
 

import sun.tools.java.ClassDeclaration; //导入依赖的package包/类
/**
 * Sort array of class declarations alphabetically by their mangled
 * fully-qualfied class name.  This is used to feed a method's exceptions
 * in a canonical order into the digest stream for the interface hash
 * computation.
 */
private void sortClassDeclarations(ClassDeclaration[] decl) {
    for (int i = 1; i < decl.length; i++) {
        ClassDeclaration curr = decl[i];
        String name = Names.mangleClass(curr.getName()).toString();
        int j;
        for (j = i; j > 0; j--) {
            if (name.compareTo(
                               Names.mangleClass(decl[j - 1].getName()).toString()) >= 0)
                {
                    break;
                }
            decl[j] = decl[j - 1];
        }
        decl[j] = curr;
    }
}