natPlainDatagramSocketImpl.cc (BooleanClass): Removed.

* java/net/natPlainDatagramSocketImpl.cc (BooleanClass): Removed.
	(IntegerClass): Likewise.
	* java/lang/natClass.cc (CloneableClass): Removed.
	(ObjectClass, ErrorClass, ClassClass, MethodClass, FieldClass,
	ConstructorClass): Likewise.
	* java/lang/natClassLoader.cc (CloneableClass): Removed.
	(ObjectClass, ClassClass, VMClassLoaderClass, ClassLoaderClass,
	SerializableClass): Likewise.
	* java/lang/reflect/natMethod.cc (BooleanClass): Removed.
	(VoidClass, ByteClass, ShortClass, CharacterClass, IntegerClass,
	LongClass, FloatClass, DoubleClass): Likewise.

From-SVN: r54977

libjava/ChangeLog

@@ -1,5 +1,17 @@
 2002-06-24  Tom Tromey  <tromey@redhat.com>
 
+	* java/net/natPlainDatagramSocketImpl.cc (BooleanClass): Removed.
+	(IntegerClass): Likewise.
+	* java/lang/natClass.cc (CloneableClass): Removed.
+	(ObjectClass, ErrorClass, ClassClass, MethodClass, FieldClass,
+	ConstructorClass): Likewise.
+	* java/lang/natClassLoader.cc (CloneableClass): Removed.
+	(ObjectClass, ClassClass, VMClassLoaderClass, ClassLoaderClass,
+	SerializableClass): Likewise.
+	* java/lang/reflect/natMethod.cc (BooleanClass): Removed.
+	(VoidClass, ByteClass, ShortClass, CharacterClass, IntegerClass,
+	LongClass, FloatClass, DoubleClass): Likewise.
+
 	* verify.cc (branch_prepass): Updated for change to exception
 	handler type.
 	(verify_instructions_0): Likewise.

libjava/java/lang/natClass.cc

@@ -1,6 +1,6 @@
 // natClass.cc - Implementation of java.lang.Class native methods.
 
-/* Copyright (C) 1998, 1999, 2000, 2001  Free Software Foundation
+/* Copyright (C) 1998, 1999, 2000, 2001, 2002  Free Software Foundation
 
    This file is part of libgcj.
 
@@ -53,17 +53,6 @@ details.  */
 
 
 
-// FIXME: remove these.
-#define CloneableClass java::lang::Cloneable::class$
-#define ObjectClass java::lang::Object::class$
-#define ErrorClass java::lang::Error::class$
-#define ClassClass java::lang::Class::class$
-#define MethodClass java::lang::reflect::Method::class$
-#define FieldClass java::lang::reflect::Field::class$
-#define ConstructorClass java::lang::reflect::Constructor::class$
-
-
-
 using namespace gcj;
 
 jclass
@@ -174,7 +163,9 @@ java::lang::Class::_getConstructors (jboolean declared)
     }
   JArray<java::lang::reflect::Constructor *> *result
     = (JArray<java::lang::reflect::Constructor *> *)
-    JvNewObjectArray (numConstructors, &ConstructorClass, NULL);
+    JvNewObjectArray (numConstructors,
+		      &java::lang::reflect::Constructor::class$,
+		      NULL);
   java::lang::reflect::Constructor** cptr = elements (result);
   for (i = 0;  i < max;  i++)
     {
@@ -273,7 +264,7 @@ java::lang::Class::getDeclaredFields (void)
     s->checkMemberAccess (this, java::lang::reflect::Member::DECLARED);
   JArray<java::lang::reflect::Field *> *result
     = (JArray<java::lang::reflect::Field *> *)
-    JvNewObjectArray (field_count, &FieldClass, NULL);
+    JvNewObjectArray (field_count, &java::lang::reflect::Field::class$, NULL);
   java::lang::reflect::Field** fptr = elements (result);
   for (int i = 0;  i < field_count;  i++)
     {
@@ -366,7 +357,7 @@ java::lang::Class::getDeclaredMethods (void)
     }
   JArray<java::lang::reflect::Method *> *result
     = (JArray<java::lang::reflect::Method *> *)
-    JvNewObjectArray (numMethods, &MethodClass, NULL);
+    JvNewObjectArray (numMethods, &java::lang::reflect::Method::class$, NULL);
   java::lang::reflect::Method** mptr = elements (result);
   for (i = 0;  i < max;  i++)
     {
@@ -402,7 +393,8 @@ java::lang::Class::getClasses (void)
   // Until we have inner classes, it always makes sense to return an
   // empty array.
   JArray<jclass> *result
-    = (JArray<jclass> *) JvNewObjectArray (0, &ClassClass, NULL);
+    = (JArray<jclass> *) JvNewObjectArray (0, &java::lang::Class::class$,
+					   NULL);
   return result;
 }
 
@@ -413,7 +405,8 @@ java::lang::Class::getDeclaredClasses (void)
   // Until we have inner classes, it always makes sense to return an
   // empty array.
   JArray<jclass> *result
-    = (JArray<jclass> *) JvNewObjectArray (0, &ClassClass, NULL);
+    = (JArray<jclass> *) JvNewObjectArray (0, &java::lang::Class::class$,
+					   NULL);
   return result;
 }
 
@@ -474,7 +467,7 @@ java::lang::Class::getFields (void)
 
   JArray<java::lang::reflect::Field *> *result
     = ((JArray<java::lang::reflect::Field *> *)
-       JvNewObjectArray (count, &FieldClass, NULL));
+       JvNewObjectArray (count, &java::lang::reflect::Field::class$, NULL));
 
   _getFields (result, 0);
 
@@ -614,7 +607,9 @@ java::lang::Class::getMethods (void)
   jint count = _getMethods (NULL, 0);
 
   JArray<Method *> *result
-    = ((JArray<Method *> *) JvNewObjectArray (count, &MethodClass, NULL));
+    = ((JArray<Method *> *) JvNewObjectArray (count,
+					      &Method::class$,
+					      NULL));
 
   // When filling the array for real, we get the actual count.  Then
   // we resize the array.
@@ -623,7 +618,8 @@ java::lang::Class::getMethods (void)
   if (real_count != count)
     {
       JArray<Method *> *r2
-	= ((JArray<Method *> *) JvNewObjectArray (real_count, &MethodClass,
+	= ((JArray<Method *> *) JvNewObjectArray (real_count,
+						  &Method::class$,
 						  NULL));
       
       Method **destp = elements (r2);
@@ -663,7 +659,7 @@ java::lang::Class::newInstance (void)
   // seem to be any way to do these.
   // FIXME: we special-case one check here just to pass a Plum Hall
   // test.  Once access checking is implemented, remove this.
-  if (this == &ClassClass)
+  if (this == &java::lang::Class::class$)
     throw new java::lang::IllegalAccessException;
 
   if (isPrimitive ()
@@ -780,7 +776,7 @@ java::lang::Class::initializeClass (void)
     }
   catch (java::lang::Throwable *except)
     {
-      if (! ErrorClass.isInstance(except))
+      if (! java::lang::Error::class$.isInstance(except))
 	{
 	  try
 	    {
@@ -872,14 +868,14 @@ static void
 _Jv_AddMethodToCache (jclass klass,
                        _Jv_Method *method)
 {
-  _Jv_MonitorEnter (&ClassClass); 
+  _Jv_MonitorEnter (&java::lang::Class::class$); 
 
   int index = method->name->hash & MCACHE_SIZE;
 
   method_cache[index].method = method;
   method_cache[index].klass = klass;
 
-  _Jv_MonitorExit (&ClassClass);
+  _Jv_MonitorExit (&java::lang::Class::class$);
 }
 
 void *
@@ -967,7 +963,7 @@ _Jv_IsAssignableFrom (jclass target, jclass source)
   if (__builtin_expect (target->isPrimitive(), false))
     return false;
     
-  if (target == &ObjectClass)
+  if (target == &java::lang::Object::class$)
     {
       if (source->isPrimitive())
         return false;
@@ -1067,7 +1063,7 @@ _Jv_PrepareConstantTimeTables (jclass klass)
    
   jclass klass0 = klass;
   jboolean has_interfaces = 0;
-  while (klass0 != &ObjectClass)
+  while (klass0 != &java::lang::Object::class$)
     {
       has_interfaces += klass0->interface_count;
       klass0 = klass0->superclass;

libjava/java/lang/natClassLoader.cc

@@ -41,14 +41,6 @@ details.  */
 #include <java/io/Serializable.h>
 #include <java/lang/Cloneable.h>
 
-// FIXME: remove these.
-#define CloneableClass java::lang::Cloneable::class$
-#define ObjectClass java::lang::Object::class$
-#define ClassClass java::lang::Class::class$
-#define VMClassLoaderClass gnu::gcj::runtime::VMClassLoader::class$
-#define ClassLoaderClass java::lang::ClassLoader::class$
-#define SerializableClass java::io::Serializable::class$
-
 /////////// java.lang.ClassLoader native methods ////////////
 
 java::lang::Class *
@@ -60,7 +52,8 @@ java::lang::ClassLoader::defineClass0 (jstring name,
 {
 #ifdef INTERPRETER
   jclass klass;
-  klass = (jclass) JvAllocObject (&ClassClass, sizeof (_Jv_InterpClass));
+  klass = (jclass) JvAllocObject (&java::lang::Class::class$,
+				  sizeof (_Jv_InterpClass));
   _Jv_InitNewClassFields (klass);
 
   // synchronize on the class, so that it is not
@@ -295,7 +288,7 @@ _Jv_PrepareCompiledClass (jclass klass)
 	  int mod = f->getModifiers ();
 	  // If we have a static String field with a non-null initial
 	  // value, we know it points to a Utf8Const.
-	  if (f->getClass () == &StringClass
+	  if (f->getClass () == &java::lang::String::class$
 	      && java::lang::reflect::Modifier::isStatic (mod))
 	    {
 	      jstring *strp = (jstring *) f->u.addr;
@@ -353,7 +346,7 @@ static jclass loaded_classes[HASH_LEN];
 jclass
 _Jv_FindClassInCache (_Jv_Utf8Const *name, java::lang::ClassLoader *loader)
 {
-  _Jv_MonitorEnter (&ClassClass);
+  _Jv_MonitorEnter (&java::lang::Class::class$);
   jint hash = HASH_UTF (name);
 
   // first, if LOADER is a defining loader, then it is also initiating
@@ -381,7 +374,7 @@ _Jv_FindClassInCache (_Jv_Utf8Const *name, java::lang::ClassLoader *loader)
 	}
     }
 
-  _Jv_MonitorExit (&ClassClass);
+  _Jv_MonitorExit (&java::lang::Class::class$);
 
   return klass;
 }
@@ -389,7 +382,7 @@ _Jv_FindClassInCache (_Jv_Utf8Const *name, java::lang::ClassLoader *loader)
 void
 _Jv_UnregisterClass (jclass the_class)
 {
-  _Jv_MonitorEnter (&ClassClass);
+  _Jv_MonitorEnter (&java::lang::Class::class$);
   jint hash = HASH_UTF(the_class->name);
 
   jclass *klass = &(loaded_classes[hash]);
@@ -414,7 +407,7 @@ _Jv_UnregisterClass (jclass the_class)
 	break;
     }
 
-  _Jv_MonitorExit (&ClassClass);
+  _Jv_MonitorExit (&java::lang::Class::class$);
 }
 
 void
@@ -424,12 +417,12 @@ _Jv_RegisterInitiatingLoader (jclass klass, java::lang::ClassLoader *loader)
   _Jv_LoaderInfo *info = (_Jv_LoaderInfo *) _Jv_Malloc (sizeof(_Jv_LoaderInfo));
   jint hash = HASH_UTF(klass->name);
 
-  _Jv_MonitorEnter (&ClassClass);
+  _Jv_MonitorEnter (&java::lang::Class::class$);
   info->loader = loader;
   info->klass  = klass;
   info->next   = initiated_classes[hash];
   initiated_classes[hash] = info;
-  _Jv_MonitorExit (&ClassClass);
+  _Jv_MonitorExit (&java::lang::Class::class$);
 }
 
 // This function is called many times during startup, before main() is
@@ -582,7 +575,7 @@ jclass
 _Jv_NewClass (_Jv_Utf8Const *name, jclass superclass,
 	      java::lang::ClassLoader *loader)
 {
-  jclass ret = (jclass) JvAllocObject (&ClassClass);
+  jclass ret = (jclass) JvAllocObject (&java::lang::Class::class$);
   _Jv_InitNewClassFields (ret);
   ret->name = name;
   ret->superclass = superclass;
@@ -646,13 +639,14 @@ _Jv_NewArrayClass (jclass element, java::lang::ClassLoader *loader,
   }
 
   // Create new array class.
-  jclass array_class = _Jv_NewClass (array_name, &ObjectClass,
+  jclass array_class = _Jv_NewClass (array_name, &java::lang::Object::class$,
   				     element->loader);
 
   // Note that `vtable_method_count' doesn't include the initial
   // gc_descr slot.
-  JvAssert (ObjectClass.vtable_method_count == NUM_OBJECT_METHODS);
-  int dm_count = ObjectClass.vtable_method_count;
+  JvAssert (java::lang::Object::class$.vtable_method_count
+	    == NUM_OBJECT_METHODS);
+  int dm_count = java::lang::Object::class$.vtable_method_count;
 
   // Create a new vtable by copying Object's vtable.
   _Jv_VTable *vtable;
@@ -661,18 +655,23 @@ _Jv_NewArrayClass (jclass element, java::lang::ClassLoader *loader,
   else
     vtable = _Jv_VTable::new_vtable (dm_count);
   vtable->clas = array_class;
-  vtable->gc_descr = ObjectClass.vtable->gc_descr;
+  vtable->gc_descr = java::lang::Object::class$.vtable->gc_descr;
   for (int i = 0; i < dm_count; ++i)
-    vtable->set_method (i, ObjectClass.vtable->get_method (i));
+    vtable->set_method (i, java::lang::Object::class$.vtable->get_method (i));
 
   array_class->vtable = vtable;
-  array_class->vtable_method_count = ObjectClass.vtable_method_count;
+  array_class->vtable_method_count
+    = java::lang::Object::class$.vtable_method_count;
 
   // Stash the pointer to the element type.
   array_class->methods = (_Jv_Method *) element;
 
   // Register our interfaces.
-  static jclass interfaces[] = { &CloneableClass, &SerializableClass };
+  static jclass interfaces[] =
+    {
+      &java::lang::Cloneable::class$,
+      &java::io::Serializable::class$
+    };
   array_class->interfaces = interfaces;
   array_class->interface_count = sizeof interfaces / sizeof interfaces[0];
 

libjava/java/lang/reflect/natMethod.cc

@@ -42,17 +42,6 @@ details.  */
 #include <java/lang/UnsupportedOperationException.h>
 #endif
 
-// FIXME: remove these.
-#define BooleanClass java::lang::Boolean::class$
-#define VoidClass java::lang::Void::class$
-#define ByteClass java::lang::Byte::class$
-#define ShortClass java::lang::Short::class$
-#define CharacterClass java::lang::Character::class$
-#define IntegerClass java::lang::Integer::class$
-#define LongClass java::lang::Long::class$
-#define FloatClass java::lang::Float::class$
-#define DoubleClass java::lang::Double::class$
-
 struct cpair
 {
   jclass prim;
@@ -64,16 +53,16 @@ struct cpair
 static cpair primitives[] =
 {
 #define BOOLEAN 0
-  { JvPrimClass (boolean), &BooleanClass },
-  { JvPrimClass (byte), &ByteClass },
+  { JvPrimClass (boolean), &java::lang::Boolean::class$ },
+  { JvPrimClass (byte), &java::lang::Byte::class$ },
 #define SHORT 2
-  { JvPrimClass (short), &ShortClass },
+  { JvPrimClass (short), &java::lang::Short::class$ },
 #define CHAR 3
-  { JvPrimClass (char), &CharacterClass },
-  { JvPrimClass (int), &IntegerClass },
-  { JvPrimClass (long), &LongClass },
-  { JvPrimClass (float), &FloatClass },
-  { JvPrimClass (double), &DoubleClass },
+  { JvPrimClass (char), &java::lang::Character::class$ },
+  { JvPrimClass (int), &java::lang::Integer::class$ },
+  { JvPrimClass (long), &java::lang::Long::class$ },
+  { JvPrimClass (float), &java::lang::Float::class$ },
+  { JvPrimClass (double), &java::lang::Double::class$ },
   { NULL, NULL }
 };
 

libjava/java/net/natPlainDatagramSocketImpl.cc

@@ -69,10 +69,6 @@ _Jv_bind (int fd, struct sockaddr *addr, int addrlen)
 #include <java/lang/Boolean.h>
 #include <java/lang/Integer.h>
 
-// FIXME: remove these
-#define BooleanClass java::lang::Boolean::class$
-#define IntegerClass java::lang::Integer::class$
-
 #ifdef DISABLE_JAVA_NET
 
 void
@@ -504,13 +500,13 @@ java::net::PlainDatagramSocketImpl::setOption (jint optID,
   if (fnum < 0)
     throw new java::net::SocketException (JvNewStringUTF ("Socket closed"));
 
-  if (_Jv_IsInstanceOf (value, &BooleanClass))
+  if (_Jv_IsInstanceOf (value, &java::lang::Boolean::class$))
     {
       java::lang::Boolean *boolobj = 
         static_cast<java::lang::Boolean *> (value);
       val = boolobj->booleanValue() ? 1 : 0;
     }
-  else if (_Jv_IsInstanceOf (value, &IntegerClass))
+  else if (_Jv_IsInstanceOf (value, &java::lang::Integer::class$))
     {
       java::lang::Integer *intobj = 
         static_cast<java::lang::Integer *> (value);