mirror/gcc
2
0
Fork 0
mirror of git://gcc.gnu.org/git/gcc.git synced 2025-03-09 23:17:20 +08:00
Code Issues Packages Projects Releases Wiki Activity

natPlainDatagramSocketImpl.cc (BooleanClass): Removed.

Browse Source 
* 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
This commit is contained in:
Tom Tromey 2002-06-25 05:29:22 +00:00 committed by Tom Tromey
parent b41e09a79f
commit d74bba04e8
5 changed files with 67 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
libjava/ChangeLog
View File

@ -1,5 +1,17 @@
2002-06-24 Tom Tromey <tromey@redhat.com> 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 * verify.cc (branch_prepass): Updated for change to exception
handler type. handler type.
(verify_instructions_0): Likewise. (verify_instructions_0): Likewise.

48
libjava/java/lang/natClass.cc
View File

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

47
libjava/java/lang/natClassLoader.cc
View File

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

27
libjava/java/lang/reflect/natMethod.cc
View File

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

8
libjava/java/net/natPlainDatagramSocketImpl.cc
View File

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