resolve.cc (_Jv_PrepareClass): Use ClassLoader::resolveClass0.

1999-08-14  Per Bothner  <per@bothner.com>

	* resolve.cc (_Jv_PrepareClass): Use ClassLoader::resolveClass0.
	* java/lang/natClass.cc (initializeClass): Likewise.
	* java/lang/ClassLoader.java (resolveClass0): New static method.
	(resolveClass): Call resolveClass0.
	(findSystemClass): No longer static.

From-SVN: r28711

diff --git a/libjava/ChangeLog b/libjava/ChangeLog
index bcaa5c41bb056c52ebf2e5e703d99bafb55adf31..2422a71c91cac980f7792d4d3c9bd10de3d25a81 100644 (file)
--- a/libjava/ChangeLog
+++ b/libjava/ChangeLog
@@ -1,3 +1,11 @@
+1999-08-14  Per Bothner  <per@bothner.com>
+
+       * resolve.cc (_Jv_PrepareClass): Use ClassLoader::resolveClass0.
+       * java/lang/natClass.cc (initializeClass): Likewise.
+       * java/lang/ClassLoader.java (resolveClass0): New static method.
+       (resolveClass): Call resolveClass0.
+       (findSystemClass): No longer static.
+
 1999-08-12  Alexandre Oliva  <oliva@dcc.unicamp.br>
 
        * include/javaprims.h (TRUE, FALSE): Redefine as themselves.

diff --git a/libjava/configure.in b/libjava/configure.in
index caff68164b0d4bfdfa2f349495dea26fbeb05628..355e8f7b890b636b7eed37f06f6b5a5c91300c61 100644 (file)
--- a/libjava/configure.in
+++ b/libjava/configure.in
@@ -50,7 +50,7 @@ AC_ARG_ENABLE(interpreter,
      AC_DEFINE(INTERPRETER)
   fi)
 
-dnl This becomes -lffi if the interpreter is enables
+dnl This becomes -lffi if the interpreter is enabled.
 INTERPSPEC=
 AC_SUBST(INTERPSPEC)
 

diff --git a/libjava/java/lang/ClassLoader.java b/libjava/java/lang/ClassLoader.java
index f0b533f6041d531a5b9bb058a8f2f0c4aa4fd070..3135740a88ea2680f99999ec44480f2aabc47aea 100644 (file)
--- a/libjava/java/lang/ClassLoader.java
+++ b/libjava/java/lang/ClassLoader.java
@@ -23,10 +23,6 @@ import java.util.Stack;
  * @author  Kresten Krab Thorup
  */
 
-/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
- * Status: Just a stub; not useful at all.
- */
-
 public abstract class ClassLoader {
 
   static private ClassLoader system;
@@ -225,16 +221,17 @@ public abstract class ClassLoader {
    * 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.
-   * <P>
-   * FIXME: The JDK documentation declares this method
-   * <code>final</code>, we declare it <code>static</code> -- any
-   * objections?  This allows us to call it directly from native code
-   * with less hassle. 
    *
    * @param     clazz the class to link.
    * @exception java.lang.LinkageError
    */
-  protected static void resolveClass(Class clazz)
+  protected final void resolveClass(Class clazz)
+    throws java.lang.LinkageError
+  {
+    resolveClass0(clazz);
+  }
+
+  static void resolveClass0(Class clazz)
     throws java.lang.LinkageError
   {
     synchronized (clazz)
@@ -273,7 +270,7 @@ public abstract class ClassLoader {
    * @exception java.lang.LinkageError 
    * @exception java.lang.ClassNotFoundException 
    */
-  protected native static Class findSystemClass(String name) 
+  protected native Class findSystemClass(String name) 
     throws java.lang.ClassNotFoundException, java.lang.LinkageError;
 
   /*

diff --git a/libjava/java/lang/natClass.cc b/libjava/java/lang/natClass.cc
index 367f14abb0f6d2f20aeddb59a6ba0d94fdf6701f..01058dc0e6b1bf54630d4dd7b3a5621608e69321 100644 (file)
--- a/libjava/java/lang/natClass.cc
+++ b/libjava/java/lang/natClass.cc
@@ -398,7 +398,7 @@ java::lang::Class::initializeClass (void)
 #ifdef INTERPRETER
       if (_Jv_IsInterpretedClass (this))
        {
-         java::lang::ClassLoader::resolveClass (this);
+         java::lang::ClassLoader::resolveClass0 (this);
 
          // Step 1.
          _Jv_MonitorEnter (this);

diff --git a/libjava/resolve.cc b/libjava/resolve.cc
index 9a48b6092b0fecbfe300a7c48a1e3ee77ed158db..d5ab739833a94b987a475b7669101792385b31b6 100644 (file)
--- a/libjava/resolve.cc
+++ b/libjava/resolve.cc
@@ -486,7 +486,7 @@ _Jv_PrepareClass(jclass klass)
   // the super class, so we use the Java method resolveClass, which will
   // unlock it properly, should an exception happen.
 
-  java::lang::ClassLoader::resolveClass (klass->superclass);
+  java::lang::ClassLoader::resolveClass0 (klass->superclass);
 
   _Jv_InterpClass *clz = (_Jv_InterpClass*)klass;