[kaffe] CVS kaffe (guilhem): Class loading updates. lockCount overflow fix.

Kaffe CVS cvs-commits at kaffe.org
Sun Dec 18 02:48:06 PST 2005


PatchSet 7008 
Date: 2005/12/18 10:39:48
Author: guilhem
Branch: HEAD
Tag: (none) 
Log:
Class loading updates. lockCount overflow fix.

        * kaffe/kaffevm/classPool.c
        (classMappingSearch): If we are asking again the same class while
        we are loading it then it means we have a circularity problem.

        * kaffe/kaffevm/locks.c:
        (slowLockMutex): Added an assertion checking.

        * kaffe/kaffevm/locks.h:
        (iLock.lockCount): Use uint32 instead of uint8.

        * libraries/clib/native/ClassLoader.c
        (findLoadedClasses): New native function.

        * libraries/javalib/vmspecific/java/lang/ClassLoader.java:
        Removed.

        * libraries/javalib/vmspecific/java/lang/VMClassLoader.java:
        Reimported from GNU Classpath and merged with the older version.

        * libraries/javalib/Makefile.am, libraries/javalib/Makefile.in:
        Regenerated.

Members: 
	ChangeLog:1.4528->1.4529 
	kaffe/kaffevm/classPool.c:1.37->1.38 
	kaffe/kaffevm/locks.c:1.66->1.67 
	kaffe/kaffevm/locks.h:1.30->1.31 
	libraries/clib/native/ClassLoader.c:1.49->1.50 
	libraries/javalib/Makefile.am:1.411->1.412 
	libraries/javalib/Makefile.in:1.508->1.509 
	libraries/javalib/vmspecific/java/lang/ClassLoader.java:1.1->1.2(DEAD) 
	libraries/javalib/vmspecific/java/lang/VMClassLoader.java:1.1->1.2 

Index: kaffe/ChangeLog
diff -u kaffe/ChangeLog:1.4528 kaffe/ChangeLog:1.4529
--- kaffe/ChangeLog:1.4528	Fri Dec 16 20:35:43 2005
+++ kaffe/ChangeLog	Sun Dec 18 10:39:48 2005
@@ -1,3 +1,27 @@
+2005-12-17  Guilhem Lavaux  <guilhem at kaffe.org>
+
+	* kaffe/kaffevm/classPool.c
+	(classMappingSearch): If we are asking again the same class while
+	we are loading it then it means we have a circularity problem.
+
+	* kaffe/kaffevm/locks.c:
+	(slowLockMutex): Added an assertion checking.
+
+	* kaffe/kaffevm/locks.h:
+	(iLock.lockCount): Use uint32 instead of uint8.
+
+	* libraries/clib/native/ClassLoader.c
+	(findLoadedClasses): New native function.
+
+	* libraries/javalib/vmspecific/java/lang/ClassLoader.java:
+	Removed.
+
+	* libraries/javalib/vmspecific/java/lang/VMClassLoader.java: 
+	Reimported from GNU Classpath and merged with the older version.
+
+	* libraries/javalib/Makefile.am, libraries/javalib/Makefile.in:
+	Regenerated.
+	
 2005-12-16  Guilhem Lavaux  <guilhem at kaffe.org>
 
 	* kaffe/kaffevm/jni/jni-helpers.c
Index: kaffe/kaffe/kaffevm/classPool.c
diff -u kaffe/kaffe/kaffevm/classPool.c:1.37 kaffe/kaffe/kaffevm/classPool.c:1.38
--- kaffe/kaffe/kaffevm/classPool.c:1.37	Tue Jul 19 16:27:35 2005
+++ kaffe/kaffe/kaffevm/classPool.c	Sun Dec 18 10:39:55 2005
@@ -345,7 +345,14 @@
 		case NMS_SEARCHING:
 			if( ce->data.thread == jt )
 			{
+				/* Circularity. */
 				done = 1;
+				retval = 0;
+				postExceptionMessage(
+					einfo,
+					JAVA_LANG(ClassNotFoundException),
+					"%s",
+					ce->name->data);
 				break;
 			}
 			waitStaticCond(&ce->slock, (jlong)0);
Index: kaffe/kaffe/kaffevm/locks.c
diff -u kaffe/kaffe/kaffevm/locks.c:1.66 kaffe/kaffe/kaffevm/locks.c:1.67
--- kaffe/kaffe/kaffevm/locks.c:1.66	Mon Dec  5 20:54:04 2005
+++ kaffe/kaffe/kaffevm/locks.c	Sun Dec 18 10:39:55 2005
@@ -233,6 +233,7 @@
    
    /* If I hold the heavy lock then just keep on going */
    if (cur == lk->holder) {
+     assert(lk->lockCount < 0xffffffff);
      lk->lockCount++;
      putHeavyLock(lk);
      KTHREAD(enable_stop)();
Index: kaffe/kaffe/kaffevm/locks.h
diff -u kaffe/kaffe/kaffevm/locks.h:1.30 kaffe/kaffe/kaffevm/locks.h:1.31
--- kaffe/kaffe/kaffevm/locks.h:1.30	Sun Apr 24 15:10:46 2005
+++ kaffe/kaffe/kaffevm/locks.h	Sun Dec 18 10:39:55 2005
@@ -51,7 +51,7 @@
   jthread_t	mux;
   jthread_t	cv;
   Ksem          sem;
-  uint8         lockCount;
+  uint32        lockCount;
   void*	hlockHolder;
 } iLock;
 
Index: kaffe/libraries/clib/native/ClassLoader.c
diff -u kaffe/libraries/clib/native/ClassLoader.c:1.49 kaffe/libraries/clib/native/ClassLoader.c:1.50
--- kaffe/libraries/clib/native/ClassLoader.c:1.49	Wed Oct 19 20:10:39 2005
+++ kaffe/libraries/clib/native/ClassLoader.c	Sun Dec 18 10:39:55 2005
@@ -161,6 +161,32 @@
 	}
 }
 
+struct Hjava_lang_Class*
+java_lang_VMClassLoader_findLoadedClass(Hjava_lang_ClassLoader* loader, Hjava_lang_String* name)
+{
+  Utf8Const *utfClassName;
+  classEntry *centry;
+  errorInfo einfo;
+  Hjava_lang_Class *clazz;
+
+  utfClassName = checkPtr(stringJava2Utf8ConstReplace(name, '.', '/'));
+  
+  /*
+   * See if an entry for that name and class loader already exists
+   * create one if not.
+   */
+  centry = lookupClassEntryInternal(utfClassName, loader);
+  if (centry == NULL)
+    return NULL;
+
+  utf8ConstRelease(utfClassName);
+  
+  if (centry->state >= NMS_LOADED)
+    return centry->data.cl;
+  else
+    return NULL;
+}
+
 
 struct Hjava_lang_Class*
 java_lang_VMClassLoader_loadClass(Hjava_lang_String* jStr, jboolean resolve)
Index: kaffe/libraries/javalib/Makefile.am
diff -u kaffe/libraries/javalib/Makefile.am:1.411 kaffe/libraries/javalib/Makefile.am:1.412
--- kaffe/libraries/javalib/Makefile.am:1.411	Wed Dec 14 05:08:56 2005
+++ kaffe/libraries/javalib/Makefile.am	Sun Dec 18 10:39:51 2005
@@ -668,7 +668,6 @@
 	vmspecific/java/io/VMObjectInputStream.java \
 	vmspecific/java/io/VMObjectStreamClass.java \
 	vmspecific/java/lang/Class.java \
-	vmspecific/java/lang/ClassLoader.java \
 	vmspecific/java/lang/Runtime.java \
 	vmspecific/java/lang/String.java \
 	vmspecific/java/lang/VMClass.java \
Index: kaffe/libraries/javalib/Makefile.in
diff -u kaffe/libraries/javalib/Makefile.in:1.508 kaffe/libraries/javalib/Makefile.in:1.509
--- kaffe/libraries/javalib/Makefile.in:1.508	Wed Dec 14 05:08:57 2005
+++ kaffe/libraries/javalib/Makefile.in	Sun Dec 18 10:39:54 2005
@@ -979,7 +979,6 @@
 	vmspecific/java/io/VMObjectInputStream.java \
 	vmspecific/java/io/VMObjectStreamClass.java \
 	vmspecific/java/lang/Class.java \
-	vmspecific/java/lang/ClassLoader.java \
 	vmspecific/java/lang/Runtime.java \
 	vmspecific/java/lang/String.java \
 	vmspecific/java/lang/VMClass.java \
===================================================================
Checking out kaffe/libraries/javalib/vmspecific/java/lang/ClassLoader.java
RCS:  /home/cvs/kaffe/kaffe/libraries/javalib/vmspecific/java/lang/Attic/ClassLoader.java,v
VERS: 1.1
***************
--- kaffe/libraries/javalib/vmspecific/java/lang/ClassLoader.java	Sun Dec 18 10:48:06 2005
+++ /dev/null	Sun Aug  4 19:57:58 2002
@@ -1,1115 +0,0 @@
-/* ClassLoader.java -- responsible for loading classes into the VM
-   Copyright (C) 1998, 1999, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
-
-This file is part of GNU Classpath.
-
-GNU Classpath is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
-any later version.
-
-GNU Classpath is distributed in the hope that it will be useful, but
-WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with GNU Classpath; see the file COPYING.  If not, write to the
-Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301 USA.
-
-Linking this library statically or dynamically with other modules is
-making a combined work based on this library.  Thus, the terms and
-conditions of the GNU General Public License cover the whole
-combination.
-
-As a special exception, the copyright holders of this library give you
-permission to link this library with independent modules to produce an
-executable, regardless of the license terms of these independent
-modules, and to copy and distribute the resulting executable under
-terms of your choice, provided that you also meet, for each linked
-independent module, the terms and conditions of the license of that
-module.  An independent module is a module which is not derived from
-or based on this library.  If you modify this library, you may extend
-this exception to your version of the library, but you are not
-obligated to do so.  If you do not wish to do so, delete this
-exception statement from your version. */
-
-
-package java.lang;
-
-import gnu.classpath.SystemProperties;
-import gnu.classpath.VMStackWalker;
-import gnu.java.util.DoubleEnumeration;
-import gnu.java.util.EmptyEnumeration;
-
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-import java.lang.reflect.Constructor;
-import java.net.URL;
-import java.net.URLClassLoader;
-import java.security.CodeSource;
-import java.security.PermissionCollection;
-import java.security.Policy;
-import java.security.ProtectionDomain;
-import java.util.ArrayList;
-import java.util.Enumeration;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.StringTokenizer;
-
-/**
- * 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!
- *
- * <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
- * anonymous inner class of ClassLoader and 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 (ebb9 at email.byu.edu)
- * @see Class
- * @since 1.0
- * @status still missing 1.4 functionality
- */
-public abstract class ClassLoader
-{
-  /**
-   * All classes loaded by this classloader. If the VM's chooses to implement
-   * this cache natively this field will be null.
-   * It is not private in order to allow VMClassLoader access to this field.
-   */
-  final HashMap loadedClasses =
-                    VMClassLoader.USE_VM_CACHE ? null : new HashMap();
-
-  /**
-   * All packages defined by this classloader. It is not private in order to
-   * allow native code (and trusted subclasses) access to this field.
-   */
-  final HashMap definedPackages = new HashMap();
-
-  /**
-   * The classloader that is consulted before this classloader.
-   * If null then the parent is the bootstrap classloader.
-   */
-  private final ClassLoader parent;
-
-  /**
-   * This is true if this classloader was successfully initialized.
-   * This flag is needed to avoid a class loader attack: even if the
-   * security manager rejects an attempt to create a class loader, the
-   * malicious class could have a finalize method which proceeds to
-   * define classes.
-   */
-  private final boolean initialized;
-
-  static class StaticData
-  {
-    /**
-     * The System Class Loader (a.k.a. Application Class Loader). The one
-     * returned by ClassLoader.getSystemClassLoader.
-     */
-    static final ClassLoader systemClassLoader =
-                              VMClassLoader.getSystemClassLoader();
-    static
-    {
-      // Find out if we have to install a default security manager. Note that
-      // this is done here because we potentially need the system class loader
-      // to load the security manager and note also that we don't need the
-      // security manager until the system class loader is created.
-      // If the runtime chooses to use a class loader that doesn't have the
-      // system class loader as its parent, it is responsible for setting
-      // up a security manager before doing so.
-      String secman = SystemProperties.getProperty("java.security.manager");
-      if (secman != null && SecurityManager.current == null)
-        {
-          if (secman.equals("") || secman.equals("default"))
-	    {
-	      SecurityManager.current = new SecurityManager();
-	    }
-	  else
-	    {
-	      try
-	        {
-	  	  Class cl = Class.forName(secman, false, StaticData.systemClassLoader);
-		  SecurityManager.current = (SecurityManager)cl.newInstance();
-	        }
-	      catch (Exception x)
-	        {
-		  throw (InternalError)
-		      new InternalError("Unable to create SecurityManager")
-		  	  .initCause(x);
-	        }
-	    }
-        }
-    }
-
-    /**
-     * The default protection domain, used when defining a class with a null
-     * parameter for the domain.
-     */
-    static final ProtectionDomain defaultProtectionDomain;
-    static
-    {
-        CodeSource cs = new CodeSource(null, null);
-        PermissionCollection perm = Policy.getPolicy().getPermissions(cs);
-        defaultProtectionDomain = new ProtectionDomain(cs, perm);
-    }
-    /**
-     * 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 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 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 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 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;
-
-  /**
-   * VM private data.
-   */
-  transient Object vmdata;
-
-  /**
-   * Create a new ClassLoader with as parent the system classloader. There
-   * may be a security check for <code>checkCreateClassLoader</code>.
-   *
-   * @throws SecurityException if the security check fails
-   */
-  protected ClassLoader() throws SecurityException
-  {
-    this(StaticData.systemClassLoader);
-  }
-
-  /**
-   * Create a new ClassLoader with the specified parent. The parent will
-   * be consulted when a class or resource is requested through
-   * <code>loadClass()</code> or <code>getResource()</code>. Only when the
-   * parent classloader cannot provide the requested class or resource the
-   * <code>findClass()</code> or <code>findResource()</code> method
-   * of this classloader will be called. There may be a security check for
-   * <code>checkCreateClassLoader</code>.
-   *
-   * @param parent the classloader's parent, or null for the bootstrap
-   *        classloader
-   * @throws SecurityException if the security check fails
-   * @since 1.2
-   */
-  protected ClassLoader(ClassLoader parent)
-  {
-    // May we create a new classloader?
-    SecurityManager sm = SecurityManager.current;
-    if (sm != null)
-      sm.checkCreateClassLoader();
-    this.parent = parent;
-    this.initialized = true;
-  }
-
-  /**
-   * Load a class using this ClassLoader or its parent, without resolving
-   * it. Calls <code>loadClass(name, false)</code>.
-   *
-   * <p>Subclasses should not override this method but should override
-   * <code>findClass()</code> which is called by this method.</p>
-   *
-   * @param name the name of the class relative to this ClassLoader
-   * @return the loaded class
-   * @throws ClassNotFoundException if the class cannot be found
-   */
-  public Class loadClass(String name) throws ClassNotFoundException
-  {
-    return loadClass(name, false);
-  }
-
-  /**
-   * Load a class using this ClassLoader or its parent, possibly resolving
-   * it as well using <code>resolveClass()</code>. It first tries to find
-   * out if the class has already been loaded through this classloader by
-   * calling <code>findLoadedClass()</code>. Then it calls
-   * <code>loadClass()</code> on the parent classloader (or when there is
-   * no parent it uses the VM bootclassloader). If the class is still
-   * not loaded it tries to create a new class by calling
-   * <code>findClass()</code>. Finally when <code>resolve</code> is
-   * <code>true</code> it also calls <code>resolveClass()</code> on the
-   * newly loaded class.
-   *
-   * <p>Subclasses should not override this method but should override
-   * <code>findClass()</code> which is called by this method.</p>
-   *
-   * @param name the fully qualified name of the class to load
-   * @param resolve whether or not to resolve the class
-   * @return the loaded class
-   * @throws ClassNotFoundException if the class cannot be found
-   */
-  protected synchronized Class loadClass(String name, boolean resolve)
-    throws ClassNotFoundException
-  {
-    // Have we already loaded this class?
-    Class c = findLoadedClass(name);
-    if (c == null)
-      {
-	// Can the class be loaded by a parent?
-	try
-	  {
-	    if (parent == null)
-	      {
-		c = VMClassLoader.loadClass(name, resolve);
-		if (c != null)
-		  return c;
-	      }
-	    else
-	      {
-		return parent.loadClass(name, resolve);
-	      }
-	  }
-	catch (ClassNotFoundException e)
-	  {
-	  }
-	// Still not found, we have to do it ourself.
-	c = findClass(name);
-      }
-    if (resolve)
-      resolveClass(c);
-    return c;
-  }
-
-  /**
-   * 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(packageName) == 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
-  {
-    throw new ClassNotFoundException(name);
-  }
-
-  /**
-   * Helper to define a class using a string of bytes. This version is not
-   * secure.
-   *
-   * @param data the data representing the classfile, in classfile format
-   * @param offset the offset into the data where the classfile starts
-   * @param len the length of the classfile data in the array
-   * @return the class that was defined
-   * @throws ClassFormatError if data is not in proper classfile format
-   * @throws IndexOutOfBoundsException if offset or len is negative, or
-   *         offset + len exceeds data
-   * @deprecated use {@link #defineClass(String, byte[], int, int)} instead
-   */
-  protected final Class defineClass(byte[] data, int offset, int len)
-    throws ClassFormatError
-  {
-    return defineClass(null, data, offset, len);
-  }
-
-  /**
-   * Helper to define a class using a string of bytes without a
-   * ProtectionDomain. Subclasses should call this method from their
-   * <code>findClass()</code> implementation. The name should use '.'
-   * separators, and discard the trailing ".class".  The default protection
-   * domain has the permissions of
-   * <code>Policy.getPolicy().getPermissions(new CodeSource(null, null))</code>.
-   *
-   * @param name the name to give the class, or null if unknown
-   * @param data the data representing the classfile, in classfile format
-   * @param offset the offset into the data where the classfile starts
-   * @param len the length of the classfile data in the array
-   * @return the class that was defined
-   * @throws ClassFormatError if data is not in proper classfile format
-   * @throws IndexOutOfBoundsException if offset or len is negative, or
-   *         offset + len exceeds data
-   * @throws SecurityException if name starts with "java."
-   * @since 1.1
-   */
-  protected final Class defineClass(String name, byte[] data, int offset,
-                                    int len) throws ClassFormatError
-  {
-    return defineClass(name, data, offset, len, null);
-  }
-
-  /**
-   * Helper to define a class using a string of bytes. Subclasses should call
-   * this method from their <code>findClass()</code> implementation. If the
-   * domain is null, the default of
-   * <code>Policy.getPolicy().getPermissions(new CodeSource(null, null))</code>
-   * is used. Once a class has been defined in a package, all further classes
-   * in that package must have the same set of certificates or a
-   * SecurityException is thrown.
-   *
-   * @param name the name to give the class.  null if unknown
-   * @param data the data representing the classfile, in classfile format
-   * @param offset the offset into the data where the classfile starts
-   * @param len the length of the classfile data in the array
-   * @param domain the ProtectionDomain to give to the class, null for the
-   *        default protection domain
-   * @return the class that was defined
-   * @throws ClassFormatError if data is not in proper classfile format
-   * @throws IndexOutOfBoundsException if offset or len is negative, or
-   *         offset + len exceeds data
-   * @throws SecurityException if name starts with "java.", or if certificates
-   *         do not match up
-   * @since 1.2
-   */
-  protected final synchronized Class defineClass(String name, byte[] data,
-						 int offset, int len,
-						 ProtectionDomain domain)
-    throws ClassFormatError
-  {
-    if (domain == null)
-      domain = StaticData.defaultProtectionDomain;
-    if (! initialized)
-      throw new SecurityException("attempt to define class from uninitialized class loader");
-    
-    Class retval = VMClassLoader.defineClass(this, name, data,
-					     offset, len, domain);
-    if (! VMClassLoader.USE_VM_CACHE)
-      loadedClasses.put(retval.getName(), retval);
-    return retval;
-  }
-
-  /**
-   * Links the class, if that has not already been done. Linking basically
-   * resolves all references to other classes made by this class.
-   *
-   * @param c the class to resolve
-   * @throws NullPointerException if c is null
-   * @throws LinkageError if linking fails
-   */
-  protected final void resolveClass(Class c)
-  {
-    VMClassLoader.resolveClass(c);
-  }
-
-  /**
-   * Helper to find a Class using the system classloader, possibly loading it.
-   * A subclass usually does not need to call this, if it correctly
-   * overrides <code>findClass(String)</code>.
-   *
-   * @param name the name of the class to find
-   * @return the found class
-   * @throws ClassNotFoundException if the class cannot be found
-   */
-  protected final Class findSystemClass(String name)
-    throws ClassNotFoundException
-  {
-    return Class.forName(name, false, StaticData.systemClassLoader);
-  }
-
-  /**
-   * Returns the parent of this classloader. If the parent of this
-   * classloader is the bootstrap classloader then this method returns
-   * <code>null</code>. A security check may be performed on
-   * <code>RuntimePermission("getClassLoader")</code>.
-   *
-   * @return the parent <code>ClassLoader</code>
-   * @throws SecurityException if the security check fails
-   * @since 1.2
-   */
-  public final ClassLoader getParent()
-  {
-    // Check if we may return the parent classloader.
-    SecurityManager sm = SecurityManager.current;
-    if (sm != null)
-      {
-	ClassLoader cl = VMStackWalker.getCallingClassLoader();
-	if (cl != null && ! cl.isAncestorOf(this))
-          sm.checkPermission(new RuntimePermission("getClassLoader"));
-      }
-    return parent;
-  }
-
-  /**
-   * 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)
-  {
-    c.setSigners(signers);
-  }
-
-  /**
-   * Helper to find an already-loaded class in this ClassLoader.
-   *
-   * @param name the name of the class to find
-   * @return the found Class, or null if it is not found
-   * @since 1.1
-   */
-  protected final synchronized Class findLoadedClass(String name)
-  {
-    return VMClassLoader.findLoadedClass(this, name);
-  }
-
-  /**
-   * Get the URL to a resource using this classloader or one of its parents.
-   * First tries to get the resource by calling <code>getResource()</code>
-   * on the parent classloader. If the parent classloader returns null then
-   * it tries finding the resource by calling <code>findResource()</code> on
-   * this classloader. The resource name should be separated by '/' for path
-   * elements.
-   *
-   * <p>Subclasses should not override this method but should override
-   * <code>findResource()</code> which is called by this method.
-   *
-   * @param name the name of the resource relative to this classloader
-   * @return the URL to the resource or null when not found
-   */
-  public URL getResource(String name)
-  {
-    URL result;
-
-    if (parent == null)
-      result = VMClassLoader.getResource(name);
-    else
-      result = parent.getResource(name);
-
-    if (result == null)
-      result = findResource(name);
-    return result;
-  }
-
-  /**
-   * 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()</code> 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.</p>
-   *
-   * @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
-  {
-    Enumeration parentResources;
-    if (parent == null)
-      parentResources = VMClassLoader.getResources(name);
-    else
-      parentResources = parent.getResources(name);
-    return new DoubleEnumeration(parentResources, findResources(name));
-  }
-
-  /**
-   * 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 EmptyEnumeration.getInstance();
-  }
-
-  /**
-   * Called whenever a resource is needed that could not be provided by
-   * one of the parents of this classloader. It is called by
-   * <code>getResource()</code> after <code>parent.getResource()</code>
-   * couldn't provide the requested resource.
-   *
-   * <p>The default implementation always returns null. Subclasses should
-   * override this method when they can provide a way to return a URL
-   * to a named resource.
-   *
-   * @param name the name of the resource to be found
-   * @return a URL to the named resource or null when not found
-   * @since 1.2
-   */
-  protected URL findResource(String name)
-  {
-    return null;
-  }
-
-  /**
-   * Get the URL to a resource using the system classloader.
-   *
-   * @param name the name of the resource relative to the system classloader
-   * @return the URL to the resource
-   * @since 1.1
-   */
-  public static final URL getSystemResource(String name)
-  {
-    return StaticData.systemClassLoader.getResource(name);
-  }
-
-  /**
-   * Get an Enumeration of URLs to resources with a given name using the
-   * the system classloader. The enumeration firsts lists the resources with
-   * the given name that can be found by the bootstrap classloader followed
-   * by the resources with the given name that can be found on the classpath.
-   *
-   * @param name the name of the resource relative to the system classloader
-   * @return an Enumeration of URLs to the resources
-   * @throws IOException if I/O errors occur in the process
-   * @since 1.2
-   */
-  public static Enumeration getSystemResources(String name) throws IOException
-  {
-    return StaticData.systemClassLoader.getResources(name);
-  }
-
-  /**
-   * Get a resource as stream using this classloader or one of its parents.
-   * First calls <code>getResource()</code> and if that returns a URL to
-   * the resource then it calls and returns the InputStream given by
-   * <code>URL.openStream()</code>.
-   *
-   * <p>Subclasses should not override this method but should override
-   * <code>findResource()</code> which is called by this method.
-   *
-   * @param name the name of the resource relative to this classloader
-   * @return an InputStream to the resource, or null
-   * @since 1.1
-   */
-  public InputStream getResourceAsStream(String name)
-  {
-    try
-      {
-        URL url = getResource(name);
-        if (url == null)
-          return null;
-        return url.openStream();
-      }
-    catch (IOException e)
-      {
-        return null;
-      }
-  }
-
-  /**
-   * 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 final InputStream getSystemResourceAsStream(String name)
-  {
-    try
-      {
-        URL url = getSystemResource(name);
-        if (url == null)
-          return null;
-        return url.openStream();
-      }
-    catch (IOException e)
-      {
-        return null;
-      }
-  }
-
-  /**
-   * Returns the system classloader. The system classloader (also called
-   * the application classloader) is the classloader that is used to
-   * load the application classes on the classpath (given by the system
-   * property <code>java.class.path</code>. This is set as the context
-   * class loader for a thread. The system property
-   * <code>java.system.class.loader</code>, if defined, is taken to be the
-   * name of the class to use as the system class loader, which must have
-   * a public constructor which takes a ClassLoader as a parent. The parent
-   * class loader passed in the constructor is the default system class
-   * loader.
-   *
-   * <p>Note that this is different from the bootstrap classloader that
-   * actually loads all the real "system" classes.
-   *
-   * <p>A security check will be performed for
-   * <code>RuntimePermission("getClassLoader")</code> if the calling class
-   * is not a parent of the system class loader.
-   *
-   * @return the system class loader
-   * @throws SecurityException if the security check fails
-   * @throws IllegalStateException if this is called recursively
-   * @throws Error if <code>java.system.class.loader</code> fails to load
-   * @since 1.2
-   */
-  public static ClassLoader getSystemClassLoader()
-  {
-    // Check if we may return the system classloader
-    SecurityManager sm = SecurityManager.current;
-    if (sm != null)
-      {
-	ClassLoader cl = VMStackWalker.getCallingClassLoader();
-	if (cl != null && cl != StaticData.systemClassLoader)
-	  sm.checkPermission(new RuntimePermission("getClassLoader"));
-      }
-
-    return StaticData.systemClassLoader;
-  }
-
-  /**
-   * Defines a new package and creates a Package object. The package should
-   * be defined before any class in the package is defined with
-   * <code>defineClass()</code>. The package should not yet be defined
-   * before in this classloader or in one of its parents (which means that
-   * <code>getPackage()</code> should return <code>null</code>). All
-   * parameters except the <code>name</code> of the package may be
-   * <code>null</code>.
-   *
-   * <p>Subclasses should call this method from their <code>findClass()</code>
-   * implementation before calling <code>defineClass()</code> on a Class
-   * in a not yet defined Package (which can be checked by calling
-   * <code>getPackage()</code>).
-   *
-   * @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
-   * @throws IllegalArgumentException if the package name is null or 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");

*** Patch too long, truncated ***



More information about the kaffe mailing list