Context Navigation

-              r1390
+              r1391
 // ClassLoader.java - Define policies for loading Java classes.
 /* Copyright (C) 1998, 1999, 2000, 2001  Free Software Foundation
+/* Copyright (C) 1998, 1999, 2000, 2001  Free Software Foundation
    This file is part of libgcj.
 …
 import java.io.IOException;
 import java.net.URL;
-import java.net.URLConnection;
 import java.security.AllPermission;
 import java.security.CodeSource;
 …
 import java.security.Policy;
 import java.security.ProtectionDomain;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Stack;
+import java.util.*;
 /**
+ * The class <code>ClassLoader</code> is intended to be subclassed by
+ * applications in order to describe new ways of loading classes,
+ * such as over the network.
+ * The ClassLoader is a way of customizing the way Java gets its classes
+ * and loads them into memory.  The verifier and other standard Java things
+ * still run, but the ClassLoader is allowed great flexibility in determining
+ * where to get the classfiles and when to load and resolve them. For that
+ * matter, a custom ClassLoader can perform on-the-fly code generation or
+ * modification!
+ *
+ * @author  Kresten Krab Thorup
+ * <p>Every classloader has a parent classloader that is consulted before
+ * the 'child' classloader when classes or resources should be loaded.
+ * This is done to make sure that classes can be loaded from an hierarchy of
+ * multiple classloaders and classloaders do not accidentially redefine
+ * already loaded classes by classloaders higher in the hierarchy.
+ *
+ * <p>The grandparent of all classloaders is the bootstrap classloader, which
+ * loads all the standard system classes as implemented by GNU Classpath. The
+ * other special classloader is the system classloader (also called
+ * application classloader) that loads all classes from the CLASSPATH
+ * (<code>java.class.path</code> system property). The system classloader
+ * is responsible for finding the application classes from the classpath,
+ * and delegates all requests for the standard library classes to its parent
+ * the bootstrap classloader. Most programs will load all their classes
+ * through the system classloaders.
+ *
+ * <p>The bootstrap classloader in GNU Classpath is implemented as a couple of
+ * static (native) methods on the package private class
+ * <code>java.lang.VMClassLoader</code>, the system classloader is an
+ * instance of <code>gnu.java.lang.SystemClassLoader</code>
+ * (which is a subclass of <code>java.net.URLClassLoader</code>).
+ *
+ * <p>Users of a <code>ClassLoader</code> will normally just use the methods
+ * <ul>
+ *  <li> <code>loadClass()</code> to load a class.</li>
+ *  <li> <code>getResource()</code> or <code>getResourceAsStream()</code>
+ *       to access a resource.</li>
+ *  <li> <code>getResources()</code> to get an Enumeration of URLs to all
+ *       the resources provided by the classloader and its parents with the
+ *       same name.</li>
+ * </ul>
+ *
+ * <p>Subclasses should implement the methods
+ * <ul>
+ *  <li> <code>findClass()</code> which is called by <code>loadClass()</code>
+ *       when the parent classloader cannot provide a named class.</li>
+ *  <li> <code>findResource()</code> which is called by
+ *       <code>getResource()</code> when the parent classloader cannot provide
+ *       a named resource.</li>
+ *  <li> <code>findResources()</code> which is called by
+ *       <code>getResource()</code> to combine all the resources with the
+ *       same name from the classloader and its parents.</li>
+ *  <li> <code>findLibrary()</code> which is called by
+ *       <code>Runtime.loadLibrary()</code> when a class defined by the
+ *       classloader wants to load a native library.</li>
+ * </ul>
+ *
+ * @author John Keiser
+ * @author Mark Wielaard
+ * @author Eric Blake
+ * @author Kresten Krab Thorup
+ * @see Class
+ * @since 1.0
+ * @status still missing 1.4 functionality
  */
 public abstract class ClassLoader
+{
+  private ClassLoader parent;
+  /**
+   * All classes loaded by this classloader. VM's may choose to implement
+   * this cache natively; but it is here available for use if necessary. It
+   * is not private in order to allow native code (and trusted subclasses)
+   * access to this field.
+   */
+  final Map loadedClasses = new HashMap();
+  /**
+   * The desired assertion status of classes loaded by this loader, if not
+   * overridden by package or class instructions.
+   */
+  // Package visible for use by Class.
+  boolean defaultAssertionStatus = VMClassLoader.defaultAssertionStatus();
+  /**
+   * The command-line state of the package assertion status overrides. This
+   * map is never modified, so it does not need to be synchronized.
+   */
+  // Package visible for use by Class.
+  static final Map systemPackageAssertionStatus
+    = VMClassLoader.packageAssertionStatus();
+  /**
+   * The map of package assertion status overrides, or null if no package
+   * overrides have been specified yet. The values of the map should be
+   * Boolean.TRUE or Boolean.FALSE, and the unnamed package is represented
+   * by the null key. This map must be synchronized on this instance.
+   */
+  // Package visible for use by Class.
+  Map packageAssertionStatus;
+  /**
+   * The command-line state of the class assertion status overrides. This
+   * map is never modified, so it does not need to be synchronized.
+   */
+  // Package visible for use by Class.
+  static final Map systemClassAssertionStatus
+    = VMClassLoader.classAssertionStatus();
+  /**
+   * The map of class assertion status overrides, or null if no class
+   * overrides have been specified yet. The values of the map should be
+   * Boolean.TRUE or Boolean.FALSE. This map must be synchronized on this
+   * instance.
+   */
+  // Package visible for use by Class.
+  Map classAssertionStatus;
+  /**
+   * The classloader that is consulted before this classloader.
+   * If null then the parent is the bootstrap classloader.
+   */
+  private final ClassLoader parent;
+  /**
+   * All packages defined by this classloader. It is not private in order to
+   * allow native code (and trusted subclasses) access to this field.
+   */
   private HashMap definedPackages = new HashMap();
   public final ClassLoader getParent ()
+  {
+    /* FIXME: security */
+    // Check if we may return the parent classloader
+    SecurityManager sm = System.getSecurityManager();
+    if (sm != null)
+      {
+        /* FIXME: security, getClassContext() not implemented.
+        Class c = VMSecurityManager.getClassContext()[1];
+        ClassLoader cl = c.getClassLoader();
+        if (cl != null && cl != this)
+          sm.checkPermission(new RuntimePermission("getClassLoader"));
+        */
+      }
     return parent;
+  }
   public static ClassLoader getSystemClassLoader ()
+  {
 …
     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 */;
+        }
+        try
+          {
+            ClassLoader cl = parent;
+            if (parent == null)
+              cl = gnu.gcj.runtime.VMClassLoader.instance;
+            if (cl != this)
+              c = cl.loadClass (name, link);
+          }
+        catch (ClassNotFoundException ex)
+          {
+            /* ignore, we'll try findClass */;
+          }
+      }
 …
+  }
+  /** 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
+   */
+  /**
+   * Called for every class name that is needed but has not yet been
+   * defined by this classloader or one of its parents. It is called by
+   * <code>loadClass()</code> after both <code>findLoadedClass()</code> and
+   * <code>parent.loadClass()</code> couldn't provide the requested class.
+   *
+   * <p>The default implementation throws a
+   * <code>ClassNotFoundException</code>. Subclasses should override this
+   * method. An implementation of this method in a subclass should get the
+   * class bytes of the class (if it can find them), if the package of the
+   * requested class doesn't exist it should define the package and finally
+   * it should call define the actual class. It does not have to resolve the
+   * class. It should look something like the following:<br>
+   *
+   * <pre>
+   * // Get the bytes that describe the requested class
+   * byte[] classBytes = classLoaderSpecificWayToFindClassBytes(name);
+   * // Get the package name
+   * int lastDot = name.lastIndexOf('.');
+   * if (lastDot != -1)
+   *   {
+   *     String packageName = name.substring(0, lastDot);
+   *     // Look if the package already exists
+   *     if (getPackage(pkg) == null)
+   *       {
+   *         // define the package
+   *         definePackage(packageName, ...);
+   *       }
+   *   }
+   * // Define and return the class
+   *  return defineClass(name, classBytes, 0, classBytes.length);
+   * </pre>
+   *
+   * <p><code>loadClass()</code> makes sure that the <code>Class</code>
+   * returned by <code>findClass()</code> will later be returned by
+   * <code>findLoadedClass()</code> when the same class name is requested.
+   *
+   * @param name class name to find (including the package name)
+   * @return the requested Class
+   * @throws ClassNotFoundException when the class can not be found
+   * @since 1.2
+   */
   protected Class findClass (String name)
     throws ClassNotFoundException
 …
+  }
   protected final Class defineClass(String name, byte[] data, int off, int len)
     throws ClassFormatError
 …
     // as per 5.3.5.1
     if (name != null  &&  findLoadedClass (name) != null)
+    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 ());
+    }
+    try
+      {
+        Class retval = defineClass0 (name, data, off, len, protectionDomain);
+        loadedClasses.put(retval.getName(), retval);
+        return retval;
+      }
+    catch (LinkageError x)
+      {
+        throw x;                // rethrow
+      }
+    catch (VirtualMachineError x)
+      {
+        throw x;                // rethrow
+      }
+    catch (Throwable x)
+      {
+        // This should never happen, or we are beyond spec.
+        InternalError r = new InternalError ("Unexpected exception "
+                                             + "while defining class "
+                                             + name);
+        r.initCause(x);
+        throw r;
+      }
+  }
 …
     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);
+        }
+        try
+          {
+            linkClass0 (clazz);
+          }
+        catch (Throwable x)
+          {
+            markClassErrorState0 (clazz);
+            LinkageError e;
+            if (x instanceof LinkageError)
+              e = (LinkageError)x;
+            else if (x instanceof ClassNotFoundException)
+              {
+                e = new NoClassDefFoundError("while resolving class: "
+                                             + clazz.getName());
+                e.initCause (x);
+              }
+            else
+              {
+                e = new LinkageError ("unexpected exception during linking: "
+                                      + clazz.getName());
+                e.initCause (x);
+              }
+            throw e;
+          }
+      }
+  }
 …
    * parents.
+   *
    * @since 1.2
    */
 …
    * Returns all Package objects defined by this classloader and its parents.
+   *
    * @since 1.2
    */
 …
+  }
   /**
    * Returns a class found in a system-specific way, typically
 …
+  }
+  /*
+   * Does currently nothing. FIXME.
+   */
+  protected final void setSigners(Class claz, Object[] signers) {
+    /* claz.setSigners (signers); */
+  /**
+   * Helper to set the signers of a class. This should be called after
+   * defining the class.
+   *
+   * @param c the Class to set signers of
+   * @param signers the signers to set
+   * @since 1.1
+   */
+  protected final void setSigners(Class c, Object[] signers)
+  {
+    /*
+     * Does currently nothing. FIXME.
+     */
+  }
 …
    * If a class named <code>name</code> was previously loaded using
    * this <code>ClassLoader</code>, then it is returned.  Otherwise
+   * it returns <code>null</code>.  (Unlike the JDK this is native,
+   * since we implement the class table internally.)
+   * it returns <code>null</code>.
    * @param     name  class to find.
    * @return    the class loaded, or null.
    */
+  protected final native Class findLoadedClass(String name);
+  protected final synchronized Class findLoadedClass(String name)
+  {
+    return (Class) loadedClasses.get(name);
+  }
+  /**
+   * Get a resource using the system classloader.
+   *
+   * @param name the name of the resource relative to the system classloader
+   * @return an input stream for the resource, or null
+   * @since 1.1
+   */
   public static InputStream getSystemResourceAsStream(String name) {
     return getSystemClassLoader().getResourceAsStream (name);
+  }
   public static URL getSystemResource(String name) {
     return getSystemClassLoader().getResource (name);
+  }
 …
   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;
+    }
+    try
+      {
+        URL res = getResource (name);
+        if (res == null)
+          return null;
+        return res.openStream ();
+      }
+    catch (java.io.IOException x)
+      {
+        return null;
+      }
+  }
 …
+  }
   protected URL findResource (String name)
+  {
 …
+  }
+  public final Enumeration getResources (String name) throws IOException
+  /**
+   * Returns an Enumeration of all resources with a given name that can
+   * be found by this classloader and its parents. Certain classloaders
+   * (such as the URLClassLoader when given multiple jar files) can have
+   * multiple resources with the same name that come from multiple locations.
+   * It can also occur that a parent classloader offers a resource with a
+   * certain name and the child classloader also offers a resource with that
+   * same name. <code>getResource() only offers the first resource (of the
+   * parent) with a given name. This method lists all resources with the
+   * same name. The name should use '/' as path separators.
+   *
+   * <p>The Enumeration is created by first calling <code>getResources()</code>
+   * on the parent classloader and then calling <code>findResources()</code>
+   * on this classloader.
+   *
+   * @param name the resource name
+   * @return an enumaration of all resources found
+   * @throws IOException if I/O errors occur in the process
+   * @since 1.2
+   */
+  public final Enumeration getResources(String name) throws IOException
+  {
     // The rules say search the parent class if non-null,
 …
+  }
+  protected Enumeration findResources (String name) throws IOException
+  {
+    // Default to returning null.  Derived classes implement this.
+    return null;
+  /**
+   * Called whenever all locations of a named resource are needed.
+   * It is called by <code>getResources()</code> after it has called
+   * <code>parent.getResources()</code>. The results are combined by
+   * the <code>getResources()</code> method.
+   *
+   * <p>The default implementation always returns an empty Enumeration.
+   * Subclasses should override it when they can provide an Enumeration of
+   * URLs (possibly just one element) to the named resource.
+   * The first URL of the Enumeration should be the same as the one
+   * returned by <code>findResource</code>.
+   *
+   * @param name the name of the resource to be found
+   * @return a possibly empty Enumeration of URLs to the named resource
+   * @throws IOException if I/O errors occur in the process
+   * @since 1.2
+   */
+  protected Enumeration findResources(String name) throws IOException
+  {
+    return Collections.enumeration(Collections.EMPTY_LIST);
+  }
+  /**
+   * Set the default assertion status for classes loaded by this classloader,
+   * used unless overridden by a package or class request.
+   *
+   * @param enabled true to set the default to enabled
+   * @see #setClassAssertionStatus(String, boolean)
+   * @see #setPackageAssertionStatus(String, boolean)
+   * @see #clearAssertionStatus()
+   * @since 1.4
+   */
+  public void setDefaultAssertionStatus(boolean enabled)
+  {
+    defaultAssertionStatus = enabled;
+  }
+  /**
+   * Set the default assertion status for packages, used unless overridden
+   * by a class request. This default also covers subpackages, unless they
+   * are also specified. The unnamed package should use null for the name.
+   *
+   * @param name the package (and subpackages) to affect
+   * @param enabled true to set the default to enabled
+   * @see #setDefaultAssertionStatus(String, boolean)
+   * @see #setClassAssertionStatus(String, boolean)
+   * @see #clearAssertionStatus()
+   * @since 1.4
+   */
+  public synchronized void setPackageAssertionStatus(String name,
+                                                     boolean enabled)
+  {
+    if (packageAssertionStatus == null)
+      packageAssertionStatus
+        = new HashMap(systemPackageAssertionStatus);
+    packageAssertionStatus.put(name, Boolean.valueOf(enabled));
+  }
+  /**
+   * Set the default assertion status for a class. This only affects the
+   * status of top-level classes, any other string is harmless.
+   *
+   * @param name the class to affect
+   * @param enabled true to set the default to enabled
+   * @throws NullPointerException if name is null
+   * @see #setDefaultAssertionStatus(String, boolean)
+   * @see #setPackageAssertionStatus(String, boolean)
+   * @see #clearAssertionStatus()
+   * @since 1.4
+   */
+  public synchronized void setClassAssertionStatus(String name,
+                                                   boolean enabled)
+  {
+    if (classAssertionStatus == null)
+      classAssertionStatus = new HashMap(systemClassAssertionStatus);
+    // The toString() hack catches null, as required.
+    classAssertionStatus.put(name.toString(), Boolean.valueOf(enabled));
+  }
+  /**
+   * Resets the default assertion status of this classloader, its packages
+   * and classes, all to false. This allows overriding defaults inherited
+   * from the command line.
+   *
+   * @see #setDefaultAssertionStatus(boolean)
+   * @see #setClassAssertionStatus(String, boolean)
+   * @see #setPackageAssertionStatus(String, boolean)
+   * @since 1.4
+   */
+  public synchronized void clearAssertionStatus()
+  {
+    defaultAssertionStatus = false;
+    packageAssertionStatus = new HashMap();
+    classAssertionStatus = new HashMap();
+  }
+}

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset 1391 for branches/GNU/src/gcc/libjava/java/lang/ClassLoader.java

Legend:

branches/GNU/src/gcc

branches/GNU/src/gcc/libjava/java/lang/ClassLoader.java

Download in other formats: