ClassLoader is intended to be subclassed by
- * applications in order to describe new ways of loading classes,
- * such as over the network.
- *
- * @author Kresten Krab Thorup
- */
-
-public abstract class ClassLoader
-{
- private ClassLoader parent;
- private HashMap definedPackages = new HashMap();
-
- public final ClassLoader getParent ()
- {
- /* FIXME: security */
- return parent;
- }
-
- public static ClassLoader getSystemClassLoader ()
- {
- return gnu.gcj.runtime.VMClassLoader.instance;
- }
-
- /**
- * Creates a ClassLoader with no parent.
- * @exception java.lang.SecurityException if not allowed
- */
- protected ClassLoader()
- {
- this (null);
- }
-
- /**
- * Creates a ClassLoader with the given parent.
- * The parent may be null.
- * The only thing this
- * constructor does, is to call
- * checkCreateClassLoader on the current
- * security manager.
- * @exception java.lang.SecurityException if not allowed
- * @since 1.2
- */
- protected ClassLoader(ClassLoader parent)
- {
- SecurityManager security = System.getSecurityManager ();
- if (security != null)
- security.checkCreateClassLoader ();
- this.parent = parent;
- }
-
- /**
- * Loads and link the class by the given name.
- * @param name the name of the class.
- * @return the class loaded.
- * @see ClassLoader#loadClass(String,boolean)
- * @exception java.lang.ClassNotFoundException
- */
- public Class loadClass(String name)
- throws java.lang.ClassNotFoundException
- {
- return loadClass (name, false);
- }
-
- /**
- * Loads the class by the given name. The default implementation
- * will search for the class in the following order (similar to jdk 1.2)
- * findLoadedClass.
- * parent.loadClass;
- * otherwise findSystemClass.
- * findClass.
- * link is true, resolveClass is then
- * called. Normally, this need not be overridden; override
- * findClass instead.
- * @param name the name of the class.
- * @param link if the class should be linked.
- * @return the class loaded.
- * @exception java.lang.ClassNotFoundException
- * @deprecated
- */
- protected Class loadClass(String name, boolean link)
- throws java.lang.ClassNotFoundException
- {
- Class c = findLoadedClass (name);
-
- if (c == null)
- {
- try {
- if (parent != null)
- return parent.loadClass (name, link);
- else
- c = gnu.gcj.runtime.VMClassLoader.instance.findClass (name);
- } catch (ClassNotFoundException ex) {
- /* ignore, we'll try findClass */;
- }
- }
-
- if (c == null)
- c = findClass (name);
-
- if (c == null)
- throw new ClassNotFoundException (name);
-
- if (link)
- resolveClass (c);
-
- return c;
- }
-
- /** Find a class. This should be overridden by subclasses; the
- * default implementation throws ClassNotFoundException.
- *
- * @param name Name of the class to find.
- * @return The class found.
- * @exception java.lang.ClassNotFoundException
- * @since 1.2
- */
- protected Class findClass (String name)
- throws ClassNotFoundException
- {
- throw new ClassNotFoundException (name);
- }
-
- // Protection Domain definitions
- // FIXME: should there be a special protection domain used for native code?
-
- // The permission required to check what a classes protection domain is.
- static final Permission protectionDomainPermission
- = new RuntimePermission("getProtectionDomain");
- // The protection domain returned if we cannot determine it.
- static ProtectionDomain unknownProtectionDomain;
- // Protection domain to use when a class is defined without one specified.
- static ProtectionDomain defaultProtectionDomain;
-
- static
- {
- Permissions permissions = new Permissions();
- permissions.add(new AllPermission());
- unknownProtectionDomain = new ProtectionDomain(null, permissions);
-
- CodeSource cs = new CodeSource(null, null);
- defaultProtectionDomain =
- new ProtectionDomain(cs, Policy.getPolicy().getPermissions(cs));
- }
-
- /**
- * Defines a class, given the class-data. According to the JVM, this
- * method should not be used; instead use the variant of this method
- * in which the name of the class being defined is specified
- * explicitly.
- *
- * If the name of the class, as specified (implicitly) in the class
- * data, denotes a class which has already been loaded by this class
- * loader, an instance of
- * java.lang.ClassNotFoundException will be thrown.
- *
- * @param data bytes in class file format.
- * @param off offset to start interpreting data.
- * @param len length of data in class file.
- * @return the class defined.
- * @exception java.lang.ClassNotFoundException
- * @exception java.lang.LinkageError
- * @see ClassLoader#defineClass(String,byte[],int,int) */
- protected final Class defineClass(byte[] data, int off, int len)
- throws ClassFormatError
- {
- return defineClass (null, data, off, len, defaultProtectionDomain);
- }
-
- protected final Class defineClass(String name, byte[] data, int off, int len)
- throws ClassFormatError
- {
- return defineClass (name, data, off, len, defaultProtectionDomain);
- }
-
- /**
- * Defines a class, given the class-data. This is preferable
- * over defineClass(byte[],off,len) since it is more
- * secure. If the expected name does not match that of the class
- * file, ClassNotFoundException is thrown. If
- * name denotes the name of an already loaded class, a
- * LinkageError is thrown.
- *
- * - * FIXME: How do we assure that the class-file data is not being - * modified, simultaneously with the class loader running!? If this - * was done in some very clever way, it might break security. - * Right now I am thinking that defineclass should make sure never to - * read an element of this array more than once, and that that would - * assure the ``immutable'' appearance. It is still to be determined - * if this is in fact how defineClass operates. - * - * @param name the expected name. - * @param data bytes in class file format. - * @param off offset to start interpreting data. - * @param len length of data in class file. - * @param protectionDomain security protection domain for the class. - * @return the class defined. - * @exception java.lang.ClassNotFoundException - * @exception java.lang.LinkageError - */ - protected final synchronized Class defineClass(String name, - byte[] data, - int off, - int len, - ProtectionDomain protectionDomain) - throws ClassFormatError - { - if (data==null || data.length < off+len || off<0 || len<0) - throw new ClassFormatError ("arguments to defineClass " - + "are meaningless"); - - // as per 5.3.5.1 - if (name != null && findLoadedClass (name) != null) - throw new java.lang.LinkageError ("class " - + name - + " already loaded"); - - if (protectionDomain == null) - protectionDomain = defaultProtectionDomain; - - try { - // Since we're calling into native code here, - // we better make sure that any generated - // exception is to spec! - - return defineClass0 (name, data, off, len, protectionDomain); - - } catch (LinkageError x) { - throw x; // rethrow - - } catch (java.lang.VirtualMachineError x) { - throw x; // rethrow - - } catch (java.lang.Throwable x) { - // This should never happen, or we are beyond spec. - - throw new InternalError ("Unexpected exception " - + "while defining class " - + name + ": " - + x.toString ()); - } - } - - /** This is the entry point of defineClass into the native code */ - private native Class defineClass0 (String name, - byte[] data, - int off, - int len, - ProtectionDomain protectionDomain) - throws ClassFormatError; - - /** - * Link the given class. This will bring the class to a state where - * the class initializer can be run. Linking involves the following - * steps: - *
gcj-compiled classes, only the first step is
- * performed. The compiler will have done the rest already.
- * - * This is called by the system automatically, - * as part of class initialization; there is no reason to ever call - * this method directly. - *
- * For historical reasons, this method has a name which is easily
- * misunderstood. Java classes are never ``resolved''. Classes are
- * linked; whereas method and field references are resolved.
- *
- * @param clazz the class to link.
- * @exception java.lang.LinkageError
- */
- protected final void resolveClass(Class clazz)
- {
- resolveClass0(clazz);
- }
-
- static void resolveClass0(Class clazz)
- {
- synchronized (clazz)
- {
- try {
- linkClass0 (clazz);
- } catch (Throwable x) {
- markClassErrorState0 (clazz);
-
- if (x instanceof Error)
- throw (Error)x;
- else
- throw new java.lang.InternalError
- ("unexpected exception during linking: " + x);
- }
- }
- }
-
- /** Internal method. Calls _Jv_PrepareClass and
- * _Jv_PrepareCompiledClass. This is only called from resolveClass. */
- private static native void linkClass0(Class clazz);
-
- /** Internal method. Marks the given clazz to be in an erroneous
- * state, and calls notifyAll() on the class object. This should only
- * be called when the caller has the lock on the class object. */
- private static native void markClassErrorState0(Class clazz);
-
- /**
- * Defines a new package and creates a Package object.
- * The package should be defined before any class in the package is
- * defined with defineClass(). The package should not yet
- * be defined before in this classloader or in one of its parents (which
- * means that getPackage() should return null).
- * All parameters except the name of the package may be
- * null.
- *
- * Subclasses should call this method from their findClass()
- * implementation before calling defineClass() on a Class
- * in a not yet defined Package (which can be checked by calling
- * getPackage()).
- *
- * @param name The name of the Package
- * @param specTitle The name of the specification
- * @param specVendor The name of the specification designer
- * @param specVersion The version of this specification
- * @param implTitle The name of the implementation
- * @param implVendor The vendor that wrote this implementation
- * @param implVersion The version of this implementation
- * @param sealed If sealed the origin of the package classes
- * @return the Package object for the specified package
- *
- * @exception IllegalArgumentException if the package name is null or if
- * it was already defined by this classloader or one of its parents.
- *
- * @see Package
- * @since 1.2
- */
- protected Package definePackage(String name,
- String specTitle, String specVendor,
- String specVersion, String implTitle,
- String implVendor, String implVersion,
- URL sealed)
- {
- if (getPackage(name) != null)
- throw new IllegalArgumentException("Package " + name
- + " already defined");
- Package p = new Package(name,
- specTitle, specVendor, specVersion,
- implTitle, implVendor, implVersion,
- sealed);
- synchronized (definedPackages)
- {
- definedPackages.put(name, p);
- }
- return p;
- }
-
- /**
- * Returns the Package object for the requested package name. It returns
- * null when the package is not defined by this classloader or one of its
- * parents.
- *
- * @since 1.2
- */
- protected Package getPackage(String name)
- {
- Package p;
- if (parent == null)
- // XXX - Should we use the bootstrap classloader?
- p = null;
- else
- p = parent.getPackage(name);
-
- if (p == null)
- {
- synchronized (definedPackages)
- {
- p = (Package) definedPackages.get(name);
- }
- }
-
- return p;
- }
-
- /**
- * Returns all Package objects defined by this classloader and its parents.
- *
- * @since 1.2
- */
- protected Package[] getPackages()
- {
- Package[] allPackages;
-
- // Get all our packages.
- Package[] packages;
- synchronized(definedPackages)
- {
- packages = new Package[definedPackages.size()];
- definedPackages.values().toArray(packages);
- }
-
- // If we have a parent get all packages defined by our parents.
- if (parent != null)
- {
- Package[] parentPackages = parent.getPackages();
- allPackages = new Package[parentPackages.length + packages.length];
- System.arraycopy(parentPackages, 0, allPackages, 0,
- parentPackages.length);
- System.arraycopy(packages, 0, allPackages, parentPackages.length,
- packages.length);
- }
- else
- // XXX - Should we use the bootstrap classloader?
- allPackages = packages;
-
- return allPackages;
- }
-
- /**
- * Returns a class found in a system-specific way, typically
- * via the java.class.path system property. Loads the
- * class if necessary.
- *
- * @param name the class to resolve.
- * @return the class loaded.
- * @exception java.lang.LinkageError
- * @exception java.lang.ClassNotFoundException
- */
- protected final Class findSystemClass(String name)
- throws java.lang.ClassNotFoundException
- {
- return gnu.gcj.runtime.VMClassLoader.instance.loadClass (name);
- }
-
- /*
- * Does currently nothing. FIXME.
- */
- protected final void setSigners(Class claz, Object[] signers) {
- /* claz.setSigners (signers); */
- }
-
- /**
- * If a class named name was previously loaded using
- * this ClassLoader, then it is returned. Otherwise
- * it returns null. (Unlike the JDK this is native,
- * since we implement the class table internally.)
- * @param name class to find.
- * @return the class loaded, or null.
- */
- protected final native Class findLoadedClass(String name);
-
- public static InputStream getSystemResourceAsStream(String name) {
- return getSystemClassLoader().getResourceAsStream (name);
- }
-
- public static URL getSystemResource(String name) {
- return getSystemClassLoader().getResource (name);
- }
-
- /**
- * Return an InputStream representing the resource name.
- * This is essentially like
- * getResource(name).openStream(), except
- * it masks out any IOException and returns null on failure.
- * @param name resource to load
- * @return an InputStream, or null
- * @see java.lang.ClassLoader#getResource(String)
- * @see java.io.InputStream
- */
- public InputStream getResourceAsStream(String name)
- {
- try {
- URL res = getResource (name);
- if (res == null) return null;
- return res.openStream ();
- } catch (java.io.IOException x) {
- return null;
- }
- }
-
- /**
- * Return an java.io.URL representing the resouce name.
- * The default implementation just returns null.
- * @param name resource to load
- * @return a URL, or null if there is no such resource.
- * @see java.lang.ClassLoader#getResourceAsBytes(String)
- * @see java.lang.ClassLoader#getResourceAsStream(String)
- * @see java.io.URL
- */
- public URL getResource (String name)
- {
- // The rules say search the parent class if non-null,
- // otherwise search the built-in class loader (assumed to be
- // the system ClassLoader). If not found, call
- // findResource().
- URL result = null;
-
- ClassLoader delegate = parent;
-
- if (delegate == null)
- delegate = getSystemClassLoader ();
-
- // Protect ourselves from looping.
- if (this != delegate)
- result = delegate.getResource (name);
-
- if (result != null)
- return result;
- else
- return findResource (name);
- }
-
- protected URL findResource (String name)
- {
- // Default to returning null. Derived classes implement this.
- return null;
- }
-
- public final Enumeration getResources (String name) throws IOException
- {
- // The rules say search the parent class if non-null,
- // otherwise search the built-in class loader (assumed to be
- // the system ClassLoader). If not found, call
- // findResource().
- Enumeration result = null;
-
- ClassLoader delegate = parent;
-
- if (delegate == null)
- delegate = getSystemClassLoader ();
-
- // Protect ourselves from looping.
- if (this != delegate)
- result = delegate.getResources (name);
-
- if (result != null)
- return result;
- else
- return findResources (name);
- }
-
- protected Enumeration findResources (String name) throws IOException
- {
- // Default to returning null. Derived classes implement this.
- return null;
- }
-}