FreeChainXenon/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Makefile.in: Rebuilt.

Browse source 
* Makefile.in: Rebuilt.
	* Makefile.am (java/lang/reflect/Method.h): ObjectInputStream now
	a friend.
	* java/lang/natClass.cc (getSignature): Only look at elements of
	non-null parameters.
	(getPrivateMethod): Removed old FIXME comment.
	* java/io/natObjectInputStream.cc (allocateObject): Removed old
	FIXME comment.
	(callConstructor): Simply use `NULL' for value of parameters.
	(ObjectClass): Removed.
	(ClassClass): Likewise.
	* java/io/ObjectInputStream.java (readObject): Fixed typo.

From-SVN: r47800
This commit is contained in:
Tom Tromey 2001-12-09 00:17:07 +00:00 • committed by Tom Tromey
parent 3297bb4667
commit 91c6dda6c7
6 changed files with 69 additions and 36 deletions
Download patch file Download diff file Expand all files Collapse all files

12
libjava/java/io/ObjectInputStream.java
View file

@ -1,5 +1,5 @@
/* ObjectInputStream.java -- Class used to read serialized objects
Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
This file is part of GNU Classpath.
@ -225,13 +225,13 @@ public class ObjectInputStream extends InputStream
{
dumpElementln ("ARRAY");
ObjectStreamClass osc = (ObjectStreamClass)readObject ();
Class componenetType = osc.forClass ().getComponentType ();
Class componentType = osc.forClass ().getComponentType ();
dumpElement ("ARRAY LENGTH=");
int length = this.realInputStream.readInt ();
dumpElementln (length + "; COMPONENT TYPE=" + componenetType);
Object array = Array.newInstance (componenetType, length);
dumpElementln (length + "; COMPONENT TYPE=" + componentType);
Object array = Array.newInstance (componentType, length);
int handle = assignNewHandle (array);
readArrayElements (array, componenetType);
readArrayElements (array, componentType);
for (int i=0, len=Array.getLength(array); i < len; i++)
dumpElementln (" ELEMENT[" + i + "]=" + Array.get(array, i).toString());
ret_val = processResolution (array, handle);
@ -1295,7 +1295,7 @@ public class ObjectInputStream extends InputStream
// returns a new instance of REAL_CLASS that has been constructed
// only to th level of CONSTRUCTOR_CLASS (a super class of REAL_CLASS)
// only to the level of CONSTRUCTOR_CLASS (a super class of REAL_CLASS)
private Object newObject (Class real_class, Class constructor_class)
{
try

24
libjava/java/io/natObjectInputStream.cc
View file

@ -1,6 +1,6 @@
// natObjectInputStream.cc - Native part of ObjectInputStream class.
/* Copyright (C) 1998, 1999, 2000 Free Software Foundation
/* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation
This ObjectInputStream is part of libgcj.
@ -38,7 +38,6 @@ java::io::ObjectInputStream::allocateObject (jclass klass)
obj = NULL;
else
{
// FIXME: will this work for String?
obj = JvAllocObject (klass);
}
}
@ -51,19 +50,24 @@ java::io::ObjectInputStream::allocateObject (jclass klass)
}
#define ObjectClass java::lang::Object::class$
#define ClassClass java::lang::Class::class$
void
java::io::ObjectInputStream::callConstructor (jclass klass, jobject obj)
{
jstring init_name = JvNewStringLatin1 ("<init>");
// This is a bit inefficient, and a bit of a hack, since we don't
// actually use the Method and since what is returned isn't
// technically a Method. We can't use Method.invoke as it looks up
// the declared method.
JArray<jclass> *arg_types
= (JArray<jclass> *) JvNewObjectArray (0, &ClassClass, NULL);
JArray<jobject> *args
= (JArray<jobject> *) JvNewObjectArray (0, &ObjectClass, NULL);
java::lang::reflect::Method *m = klass->getPrivateMethod (init_name, arg_types);
m->invoke (obj, args);
= (JArray<jclass> *) JvNewObjectArray (0, &java::lang::Class::class$,
NULL);
java::lang::reflect::Method *m = klass->getPrivateMethod (init_name,
arg_types);
// We lie about this being a constructor. If we put `true' here
// then _Jv_CallAnyMethodA would try to allocate the object for us.
jmethodID meth = (jmethodID) ((char *) (klass->methods)
+ m->offset);
_Jv_CallAnyMethodA (obj, JvPrimClass (void), meth, false, arg_types, NULL);
}
java::lang::reflect::Field *

3
libjava/java/lang/natClass.cc
View file

@ -286,10 +286,10 @@ java::lang::Class::getSignature (JArray<jclass> *param_types,
{
java::lang::StringBuffer *buf = new java::lang::StringBuffer ();
buf->append((jchar) '(');
jclass *v = elements (param_types);
// A NULL param_types means "no parameters".
if (param_types != NULL)
{
jclass *v = elements (param_types);
for (int i = 0; i < param_types->length; ++i)
v[i]->getSignature(buf);
}
@ -1399,7 +1399,6 @@ java::lang::Class::getPrivateMethod (jstring name, JArray<jclass> *param_types)
int i = klass->isPrimitive () ? 0 : klass->method_count;
while (--i >= 0)
{
// FIXME: access checks.
if (_Jv_equalUtf8Consts (klass->methods[i].name, utf_name)
&& _Jv_equaln (klass->methods[i].signature, partial_sig, p_len))
{