sun.tools.java.ClassNotFound Java Examples

private static boolean couldBeRemote (boolean quiet, ContextStack stack,
                                      ClassDefinition classDef) {

    boolean result = false;
    BatchEnvironment env = stack.getEnv();

    try {
        if (!classDef.isInterface()) {
            failedConstraint(16,quiet,stack,classDef.getName());
        } else {
            result = env.defRemote.implementedBy(env,classDef.getClassDeclaration());
            if (!result) failedConstraint(1,quiet,stack,classDef.getName());
        }
    } catch (ClassNotFound e) {
        classNotFound(stack,e);
    }

    return result;
}
 

private static boolean couldBeImplementation(boolean quiet, ContextStack stack,
                                             ClassDefinition classDef) {
    boolean result = false;
    BatchEnvironment env = stack.getEnv();

    try {
        if (!classDef.isClass()) {
            failedConstraint(17,quiet,stack,classDef.getName());
        } else {
            result = env.defRemote.implementedBy(env, classDef.getClassDeclaration());
            if (!result) failedConstraint(8,quiet,stack,classDef.getName());
        }
    } catch (ClassNotFound e) {
        classNotFound(stack,e);
    }

    return result;
}
 

private static boolean couldBeRemote (boolean quiet, ContextStack stack,
                                      ClassDefinition classDef) {

    boolean result = false;
    BatchEnvironment env = stack.getEnv();

    try {
        if (!classDef.isInterface()) {
            failedConstraint(16,quiet,stack,classDef.getName());
        } else {
            result = env.defRemote.implementedBy(env,classDef.getClassDeclaration());
            if (!result) failedConstraint(1,quiet,stack,classDef.getName());
        }
    } catch (ClassNotFound e) {
        classNotFound(stack,e);
    }

    return result;
}
 

/**
 * 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;
                }
            }
        }
    }
}
 

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;
    }
 

/**
 * 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;
                }
            }
        }
    }
}
 

private static boolean isSpecial(sun.tools.java.Type type,
                                 ClassDefinition theClass,
                                 ContextStack stack) {
    if (type.isType(TC_CLASS)) {
        Identifier id = type.getClassName();

        if (id.equals(idRemote)) return true;
        if (id == idJavaIoSerializable) return true;
        if (id == idJavaIoExternalizable) return true;
        if (id == idCorbaObject) return true;
        if (id == idIDLEntity) return true;
        BatchEnvironment env = stack.getEnv();
        try {
            if (env.defCorbaObject.implementedBy(env,theClass.getClassDeclaration())) return true;
        } catch (ClassNotFound e) {
            classNotFound(stack,e);
        }
    }
    return false;
}
 

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;
    }
 

/**
 * Add to the supplied list all exceptions in the "from" array
 * that are subclasses of an exception in the "with" array.
 */
private void collectCompatibleExceptions(
        ValueType[] from, ValueType[] with, Vector list)
        throws ClassNotFound {

    for (int i = 0; i < from.length; i++) {
        ClassDefinition exceptionDef = from[i].getClassDefinition();
        if (!list.contains(from[i])) {
            for (int j = 0; j < with.length; j++) {
                if (exceptionDef.subClassOf(
                        enclosing.getEnv(),
                        with[j].getClassDeclaration())) {
                    list.addElement(from[i]);
                    break;
                }
            }
        }
    }
}
 

private static boolean couldBeImplementation(boolean quiet, ContextStack stack,
                                             ClassDefinition classDef) {
    boolean result = false;
    BatchEnvironment env = stack.getEnv();

    try {
        if (!classDef.isClass()) {
            failedConstraint(17,quiet,stack,classDef.getName());
        } else {
            result = env.defRemote.implementedBy(env, classDef.getClassDeclaration());
            if (!result) failedConstraint(8,quiet,stack,classDef.getName());
        }
    } catch (ClassNotFound e) {
        classNotFound(stack,e);
    }

    return result;
}
 

/**
 * 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;
                }
            }
        }
    }
}
 

/**
 * Return a new Method object that is a legal combination of
 * this method object and another one.
 *
 * This requires determining the exceptions declared by the
 * combined method, which must be only those exceptions
 * that may thrown by both of the old methods.
 */
public Method mergeWith(Method other) {
    if (!equals(other)) {
        env.error(0, "attempt to merge method failed:", getName(),
                  enclosing.getClassDefinition().getName());
    }

    Vector legalExceptions = new Vector();
    try {
        collectCompatibleExceptions(
              other.exceptions, exceptions, legalExceptions);
        collectCompatibleExceptions(
              exceptions, other.exceptions, legalExceptions);
    } catch (ClassNotFound e) {
        env.error(0, "class.not.found", e.name,
                  enclosing.getClassDefinition().getName());
        return null;
    }

    Method merged = (Method) clone();
    merged.exceptions = new ValueType[legalExceptions.size()];
    legalExceptions.copyInto(merged.exceptions);
    merged.implExceptions = merged.exceptions;

    return merged;
}
 

/**
 * Add to the supplied list all exceptions in the "from" array
 * that are subclasses of an exception in the "with" array.
 */
private void collectCompatibleExceptions(
        ValueType[] from, ValueType[] with, Vector list)
        throws ClassNotFound {

    for (int i = 0; i < from.length; i++) {
        ClassDefinition exceptionDef = from[i].getClassDefinition();
        if (!list.contains(from[i])) {
            for (int j = 0; j < with.length; j++) {
                if (exceptionDef.subClassOf(
                        enclosing.getEnv(),
                        with[j].getClassDeclaration())) {
                    list.addElement(from[i]);
                    break;
                }
            }
        }
    }
}
 

private static boolean couldBeAbstract(ContextStack stack, ClassDefinition classDef,
                                       boolean quiet) {

    // Return true if interface and not remote...

    boolean result = false;

    if (classDef.isInterface()) {
        BatchEnvironment env = stack.getEnv();

        try {
            result = ! env.defRemote.implementedBy(env, classDef.getClassDeclaration());
            if (!result) failedConstraint(15,quiet,stack,classDef.getName());
        } catch (ClassNotFound e) {
            classNotFound(stack,e);
        }
    } else {
        failedConstraint(14,quiet,stack,classDef.getName());
    }


    return result;
}
 

private static boolean couldBeAbstract(ContextStack stack, ClassDefinition classDef,
                                       boolean quiet) {

    // Return true if interface and not remote...

    boolean result = false;

    if (classDef.isInterface()) {
        BatchEnvironment env = stack.getEnv();

        try {
            result = ! env.defRemote.implementedBy(env, classDef.getClassDeclaration());
            if (!result) failedConstraint(15,quiet,stack,classDef.getName());
        } catch (ClassNotFound e) {
            classNotFound(stack,e);
        }
    } else {
        failedConstraint(14,quiet,stack,classDef.getName());
    }


    return result;
}
 

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;
    }
 

/**
 * 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;
                }
            }
        }
    }
}
 

/**
 * Add to the supplied list all exceptions in the "from" array
 * that are subclasses of an exception in the "with" array.
 */
private void collectCompatibleExceptions(
        ValueType[] from, ValueType[] with, Vector list)
        throws ClassNotFound {

    for (int i = 0; i < from.length; i++) {
        ClassDefinition exceptionDef = from[i].getClassDefinition();
        if (!list.contains(from[i])) {
            for (int j = 0; j < with.length; j++) {
                if (exceptionDef.subClassOf(
                        enclosing.getEnv(),
                        with[j].getClassDeclaration())) {
                    list.addElement(from[i]);
                    break;
                }
            }
        }
    }
}
 

private static boolean isSpecial(sun.tools.java.Type type,
                                 ClassDefinition theClass,
                                 ContextStack stack) {
    if (type.isType(TC_CLASS)) {
        Identifier id = type.getClassName();

        if (id.equals(idRemote)) return true;
        if (id == idJavaIoSerializable) return true;
        if (id == idJavaIoExternalizable) return true;
        if (id == idCorbaObject) return true;
        if (id == idIDLEntity) return true;
        BatchEnvironment env = stack.getEnv();
        try {
            if (env.defCorbaObject.implementedBy(env,theClass.getClassDeclaration())) return true;
        } catch (ClassNotFound e) {
            classNotFound(stack,e);
        }
    }
    return false;
}
 

/**
 * Report a ClassNotFoundException thru the compiler environment.
 */
protected static void classNotFound(boolean quiet,
                                    ContextStack stack,
                                    ClassNotFound e) {
    if (!quiet) stack.getEnv().error(0, "rmic.class.not.found", e.name);
    stack.traceCallStack();
}
 

/**
 * Generate the source files for the stub and/or skeleton classes
 * needed by RMI for the given remote implementation class.
 *
 * @param env       compiler environment
 * @param cdef      definition of remote implementation class
 *                  to generate stubs and/or skeletons for
 * @param destDir   directory for the root of the package hierarchy
 *                  for generated files
 */
public void generate(BatchEnvironment env, ClassDefinition cdef, File destDir) {
    RemoteClass remoteClass = RemoteClass.forClass(env, cdef);
    if (remoteClass == null)        // exit if an error occurred
        return;

    RMIGenerator gen;
    try {
        gen = new RMIGenerator(env, cdef, destDir, remoteClass, version);
    } catch (ClassNotFound e) {
        env.error(0, "rmic.class.not.found", e.name);
        return;
    }
    gen.generate();
}
 

/**
 * Initialize this instance.
 */
private boolean initialize (ContextStack stack) {

    if (stack.getEnv().getParseNonConforming()) {

        Vector directInterfaces = new Vector();
        Vector directMethods = new Vector();
        Vector directMembers = new Vector();

        try {

            // need to include parent interfaces in IDL generation...
            addNonRemoteInterfaces( directInterfaces,stack );

            // Get methods...

            if (addAllMethods(getClassDefinition(),directMethods,false,false,stack) != null) {

                // Get conforming constants...

                if (addConformingConstants(directMembers,false,stack)) {

                    // We're ok, so pass 'em up...

                    if (!initialize(directInterfaces,directMethods,directMembers,stack,false)) {
                        return false;
                    }
                }
            }
            return true;

        } catch (ClassNotFound e) {
            classNotFound(stack,e);
        }
        return false;
    } else {
        return initialize(null,null,null,stack,false);
    }
}
 

/**
 * Initialize this instance.
 */
private boolean initialize (ContextStack stack) {

    if (stack.getEnv().getParseNonConforming()) {

        Vector directInterfaces = new Vector();
        Vector directMethods = new Vector();
        Vector directMembers = new Vector();

        try {

            // need to include parent interfaces in IDL generation...
            addNonRemoteInterfaces( directInterfaces,stack );

            // Get methods...

            if (addAllMethods(getClassDefinition(),directMethods,false,false,stack) != null) {

                // Get conforming constants...

                if (addConformingConstants(directMembers,false,stack)) {

                    // We're ok, so pass 'em up...

                    if (!initialize(directInterfaces,directMethods,directMembers,stack,false)) {
                        return false;
                    }
                }
            }
            return true;

        } catch (ClassNotFound e) {
            classNotFound(stack,e);
        }
        return false;
    } else {
        return initialize(null,null,null,stack,false);
    }
}
 

public void compileAllClasses (BatchEnvironment env)
    throws ClassNotFound,
           IOException,
           InterruptedException {
    ByteArrayOutputStream buf = new ByteArrayOutputStream(4096);
    boolean done;

    do {
        done = true;
        for (Enumeration<?> e = env.getClasses() ; e.hasMoreElements() ; ) {
            ClassDeclaration c = (ClassDeclaration)e.nextElement();
            done = compileClass(c,buf,env);
        }
    } while (!done);
}
 

/**
 * Generate the source files for the stub and/or skeleton classes
 * needed by RMI for the given remote implementation class.
 *
 * @param env       compiler environment
 * @param cdef      definition of remote implementation class
 *                  to generate stubs and/or skeletons for
 * @param destDir   directory for the root of the package hierarchy
 *                  for generated files
 */
public void generate(BatchEnvironment env, ClassDefinition cdef, File destDir) {
    RemoteClass remoteClass = RemoteClass.forClass(env, cdef);
    if (remoteClass == null)        // exit if an error occurred
        return;

    RMIGenerator gen;
    try {
        gen = new RMIGenerator(env, cdef, destDir, remoteClass, version);
    } catch (ClassNotFound e) {
        env.error(0, "rmic.class.not.found", e.name);
        return;
    }
    gen.generate();
}
 

/**
 * Create a new stub/skeleton Generator object for the given
 * remote implementation class to generate code according to
 * the given stub protocol version.
 */
private RMIGenerator(BatchEnvironment env, ClassDefinition cdef,
                       File destDir, RemoteClass remoteClass, int version)
    throws ClassNotFound
{
    this.destDir     = destDir;
    this.cdef        = cdef;
    this.env         = env;
    this.remoteClass = remoteClass;
    this.version     = version;

    remoteMethods = remoteClass.getRemoteMethods();

    remoteClassName = remoteClass.getName();
    stubClassName = Names.stubFor(remoteClassName);
    skeletonClassName = Names.skeletonFor(remoteClassName);

    methodFieldNames = nameMethodFields(remoteMethods);

    stubFile = sourceFileForClass(remoteClassName,stubClassName, destDir , env);
    skeletonFile = sourceFileForClass(remoteClassName,skeletonClassName, destDir, env);

    /*
     * Initialize cached definitions for exception classes used
     * in the generation process.
     */
    defException =
        env.getClassDeclaration(idJavaLangException).
            getClassDefinition(env);
    defRemoteException =
        env.getClassDeclaration(idRemoteException).
            getClassDefinition(env);
    defRuntimeException =
        env.getClassDeclaration(idJavaLangRuntimeException).
            getClassDefinition(env);
}
 

/**
 * Return an array containing only those exceptions which need to be
 * handled explicitly by the stub.  Removes java.lang.RuntimeException,
 * java.lang.Error, and their subclasses, since these are all passed
 * back as CORBA system exceptions.  Also removes subclasses of
 * java.rmi.RemoteException but not java.rmi.RemoteException itself,
 * since this may need to be thrown by the stub.
 */
public ValueType[] getFilteredStubExceptions(ValueType[] list) {
    ValueType[] result = list;
    int newSize = list.length;

    try {

        for (int i = 0; i < list.length; i++) {
            ClassDeclaration decl = list[i].getClassDeclaration();
            if ((env.defRemoteException.superClassOf(env, decl) &&
                 !env.defRemoteException.getClassDeclaration().equals(decl)) ||
                env.defRuntimeException.superClassOf(env, decl) ||
                env.defError.superClassOf(env, decl)) {
                list[i] = null;
                newSize--;
            }
        }

    } catch (ClassNotFound e) {
        classNotFound(stack,e); // Report error but do not stop.
    }

    // Create new list if we removed anything...

    if (newSize < list.length) {
        ValueType[] temp = new ValueType[newSize];
        int offset = 0;
        for (int i = 0; i < list.length; i++) {
            if (list[i] != null) {
                temp[offset++] = list[i];
            }
        }
        list = temp;
    }

    return list;
}
 

/**
 * Initialize this instance.
 */

private static boolean couldBeValue(ContextStack stack, ClassDefinition classDef) {

    boolean result = false;
    ClassDeclaration classDecl = classDef.getClassDeclaration();
    BatchEnvironment env = stack.getEnv();

    try {
        // Make sure it's not remote...

        if (env.defRemote.implementedBy(env, classDecl)) {
            failedConstraint(10,false,stack,classDef.getName());
        } else {

            // Make sure it's Serializable...

            if (!env.defSerializable.implementedBy(env, classDecl)) {
                failedConstraint(11,false,stack,classDef.getName());
            } else {
                result = true;
            }
        }
    } catch (ClassNotFound e) {
        classNotFound(stack,e);
    }

    return result;
}
 

/**
 * Generate the source files for the stub and/or skeleton classes
 * needed by RMI for the given remote implementation class.
 *
 * @param env       compiler environment
 * @param cdef      definition of remote implementation class
 *                  to generate stubs and/or skeletons for
 * @param destDir   directory for the root of the package hierarchy
 *                  for generated files
 */
public void generate(BatchEnvironment env, ClassDefinition cdef, File destDir) {
    RemoteClass remoteClass = RemoteClass.forClass(env, cdef);
    if (remoteClass == null)        // exit if an error occurred
        return;

    RMIGenerator gen;
    try {
        gen = new RMIGenerator(env, cdef, destDir, remoteClass, version);
    } catch (ClassNotFound e) {
        env.error(0, "rmic.class.not.found", e.name);
        return;
    }
    gen.generate();
}
 

protected boolean isIDLEntityException(Type type, CompoundType.Method method,boolean quiet)
    throws ClassNotFound {
    if (type.isArray()) {
        type = type.getElementType();
    }
    if (type.isCompound()){
        if (((CompoundType)type).isIDLEntityException()) {
            failedConstraint(18,quiet,stack,method.getEnclosing(), method.toString());
            return true;
        }
    }
    return false;
}