* java/lang/Class.h (_Jv_SetVTableEntries): Updated declaration.

	* resolve.cc: Don't include AbstractMethodError.h.
	(_Jv_abstractMethodError): Removed.
	* defineclass.cc (handleMethodsBegin): Initialize method index to
	-1.
	* java/lang/natClass.cc (_Jv_LayoutVTableMethods): Don't set
	method index for "new" final method.
	(_Jv_SetVTableEntries): Compare index against -1 instead of using
	isVirtualMethod.  Added `flags' argument.
	(_Jv_MakeVTable): Throw exception for abstract method in concrete
	class.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@59847 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/libjava/ChangeLog b/libjava/ChangeLog
index 8dfbcf4..4f4a7e1 100644 (file)
--- a/libjava/ChangeLog
+++ b/libjava/ChangeLog
@@ -1,3 +1,17 @@
+2002-12-05  Tom Tromey  <tromey@redhat.com>
+
+       * java/lang/Class.h (_Jv_SetVTableEntries): Updated declaration.
+       * resolve.cc: Don't include AbstractMethodError.h.
+       (_Jv_abstractMethodError): Removed.
+       * defineclass.cc (handleMethodsBegin): Initialize method index to
+       -1.
+       * java/lang/natClass.cc (_Jv_LayoutVTableMethods): Don't set
+       method index for "new" final method.
+       (_Jv_SetVTableEntries): Compare index against -1 instead of using
+       isVirtualMethod.  Added `flags' argument.
+       (_Jv_MakeVTable): Throw exception for abstract method in concrete
+       class.
+
 2002-12-04  Tom Tromey  <tromey@redhat.com>
 
        * java/net/SocketPermission.java (hashCode): Rewrote.

diff --git a/libjava/defineclass.cc b/libjava/defineclass.cc
index 6a250da..dc35002 100644 (file)
--- a/libjava/defineclass.cc
+++ b/libjava/defineclass.cc
@@ -1184,15 +1184,17 @@ void _Jv_ClassReader::handleFieldsEnd ()
 void
 _Jv_ClassReader::handleMethodsBegin (int count)
 {
-  def->methods = (_Jv_Method*)
-    _Jv_AllocBytes (sizeof (_Jv_Method)*count);
+  def->methods = (_Jv_Method *) _Jv_AllocBytes (sizeof (_Jv_Method) * count);
 
   def->interpreted_methods
     = (_Jv_MethodBase **) _Jv_AllocBytes (sizeof (_Jv_MethodBase *)
                                          * count);
 
   for (int i = 0; i < count; i++)
-    def->interpreted_methods[i] = 0;
+    {
+      def->interpreted_methods[i] = 0;
+      def->methods[i].index = (_Jv_ushort) -1;
+    }
 
   def->method_count = count;
 }
@@ -1376,12 +1378,14 @@ throw_internal_error (char *msg)
   throw new java::lang::InternalError (JvNewStringLatin1 (msg));
 }
 
-static void throw_incompatible_class_change_error (jstring msg)
+static void
+throw_incompatible_class_change_error (jstring msg)
 {
   throw new java::lang::IncompatibleClassChangeError (msg);
 }
 
-static void throw_class_circularity_error (jstring msg)
+static void
+throw_class_circularity_error (jstring msg)
 {
   throw new java::lang::ClassCircularityError (msg);
 }

diff --git a/libjava/java/lang/Class.h b/libjava/java/lang/Class.h
index 6fb918a..4ccf388 100644 (file)
--- a/libjava/java/lang/Class.h
+++ b/libjava/java/lang/Class.h
@@ -325,7 +325,7 @@ private:
   friend jshort _Jv_FindIIndex (jclass *, jshort *, jshort);
   friend void _Jv_LinkOffsetTable (jclass);
   friend void _Jv_LayoutVTableMethods (jclass klass);
-  friend void _Jv_SetVTableEntries (jclass, _Jv_VTable *);
+  friend void _Jv_SetVTableEntries (jclass, _Jv_VTable *, jboolean *);
   friend void _Jv_MakeVTable (jclass);
 
   // Return array class corresponding to element type KLASS, creating it if

diff --git a/libjava/java/lang/natClass.cc b/libjava/java/lang/natClass.cc
index 68fbd54..bafac78 100644 (file)
--- a/libjava/java/lang/natClass.cc
+++ b/libjava/java/lang/natClass.cc
@@ -97,7 +97,7 @@ java::lang::Class::forName (jstring className)
   java::lang::Class *klass = NULL;
   try
     {
-      for (int i=1; !klass; i++)
+      for (int i = 1; !klass; i++)
        {
          klass = t->classAt (i);
        }
@@ -1556,7 +1556,7 @@ _Jv_LinkOffsetTable(jclass klass)
 }
 
 // Returns true if METH should get an entry in a VTable.
-static bool
+static jboolean
 isVirtualMethod (_Jv_Method *meth)
 {
   using namespace java::lang::reflect;
@@ -1574,7 +1574,7 @@ _Jv_LayoutVTableMethods (jclass klass)
   if (klass->vtable != NULL || klass->isInterface() 
       || klass->vtable_method_count != -1)
     return;
-    
+
   jclass superclass = klass->superclass;
 
   if (superclass != NULL && superclass->vtable_method_count == -1)
@@ -1582,48 +1582,59 @@ _Jv_LayoutVTableMethods (jclass klass)
       JvSynchronize sync (superclass);
       _Jv_LayoutVTableMethods (superclass);
     }
-    
+
   int index = (superclass == NULL ? 0 : superclass->vtable_method_count);
 
   for (int i = 0; i < klass->method_count; ++i)
     {
       _Jv_Method *meth = &klass->methods[i];
       _Jv_Method *super_meth = NULL;
-    
-      if (!isVirtualMethod(meth))
-        continue;
-             
+
+      if (! isVirtualMethod (meth))
+       continue;
+
       if (superclass != NULL)
         super_meth = _Jv_LookupDeclaredMethod (superclass, meth->name, 
                                               meth->signature);
-      
+
       if (super_meth)
         meth->index = super_meth->index;
-      else
+      else if (! (meth->accflags & java::lang::reflect::Modifier::FINAL))
         meth->index = index++;
     }
-  
+
   klass->vtable_method_count = index;
 }
 
-// Set entries in VTABLE for virtual methods declared in KLASS. If KLASS has
-// an immediate abstract parent, recursivly do its methods first.
+// Set entries in VTABLE for virtual methods declared in KLASS. If
+// KLASS has an immediate abstract parent, recursively do its methods
+// first.  FLAGS is used to determine which slots we've actually set.
 void
-_Jv_SetVTableEntries (jclass klass, _Jv_VTable *vtable)
+_Jv_SetVTableEntries (jclass klass, _Jv_VTable *vtable, jboolean *flags)
 {
   using namespace java::lang::reflect;
 
   jclass superclass = klass->getSuperclass();
 
   if (superclass != NULL && (superclass->getModifiers() & Modifier::ABSTRACT))
-    _Jv_SetVTableEntries (superclass, vtable);
-    
+    _Jv_SetVTableEntries (superclass, vtable, flags);
+
   for (int i = klass->method_count - 1; i >= 0; i--)
     {
       _Jv_Method *meth = &klass->methods[i];
-      if (!isVirtualMethod(meth))
+      if (meth->index == (_Jv_ushort) -1)
        continue;
-      vtable->set_method(meth->index, meth->ncode);
+      if ((meth->accflags & Modifier::ABSTRACT))
+       {
+         // FIXME: we should set abstract slots to a function that
+         // throws AbstractMethodError.  How can we do that on IA-64?
+         flags[meth->index] = false;
+       }
+      else
+       {
+         vtable->set_method(meth->index, meth->ncode);
+         flags[meth->index] = true;
+       }
     }
 }
 
@@ -1639,7 +1650,7 @@ _Jv_MakeVTable (jclass klass)
   if (klass->vtable != NULL || klass->isInterface() 
       || (klass->accflags & Modifier::ABSTRACT))
     return;
-  
+
   //  out before we can create a vtable. 
   if (klass->vtable_method_count == -1)
     _Jv_LayoutVTableMethods (klass);
@@ -1647,7 +1658,11 @@ _Jv_MakeVTable (jclass klass)
   // Allocate the new vtable.
   _Jv_VTable *vtable = _Jv_VTable::new_vtable (klass->vtable_method_count);
   klass->vtable = vtable;
-  
+
+  jboolean flags[klass->vtable_method_count];
+  for (int i = 0; i < klass->vtable_method_count; ++i)
+    flags[i] = false;
+
   // Copy the vtable of the closest non-abstract superclass.
   jclass superclass = klass->superclass;
   if (superclass != NULL)
@@ -1662,7 +1677,10 @@ _Jv_MakeVTable (jclass klass)
        }
 
       for (int i = 0; i < superclass->vtable_method_count; ++i)
-       vtable->set_method (i, superclass->vtable->get_method (i));
+       {
+         vtable->set_method (i, superclass->vtable->get_method (i));
+         flags[i] = true;
+       }
     }
 
   // Set the class pointer and GC descriptor.
@@ -1671,5 +1689,14 @@ _Jv_MakeVTable (jclass klass)
 
   // For each virtual declared in klass and any immediate abstract 
   // superclasses, set new vtable entry or override an old one.
-  _Jv_SetVTableEntries (klass, vtable);
+  _Jv_SetVTableEntries (klass, vtable, flags);
+
+  // It is an error to have an abstract method in a concrete class.
+  if (! (klass->accflags & Modifier::ABSTRACT))
+    {
+      for (int i = 0; i < klass->vtable_method_count; ++i)
+       if (! flags[i])
+         // FIXME: messsage.
+         throw new java::lang::AbstractMethodError ();
+    }
 }

diff --git a/libjava/resolve.cc b/libjava/resolve.cc
index e9fe4ad..e195c33 100644 (file)
--- a/libjava/resolve.cc
+++ b/libjava/resolve.cc
@@ -363,13 +363,6 @@ _Jv_SearchMethodInClass (jclass cls, jclass klass,
   return 0;
 }
 
-/* this is installed in place of abstract methods */
-static void
-_Jv_abstractMethodError ()
-{
-  throw new java::lang::AbstractMethodError;
-}
-
 void 
 _Jv_PrepareClass(jclass klass)
 {