Makefile.in: Rebuilt.

	* 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

2 files changed, 20 insertions, 16 deletions

diff --git a/libjava/java/io/ObjectInputStream.java b/libjava/java/io/ObjectInputStream.java
index e607975..7a67f3f 100644
--- a/libjava/java/io/ObjectInputStream.java
+++ b/libjava/java/io/ObjectInputStream.java
@@ -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
diff --git a/libjava/java/io/natObjectInputStream.cc b/libjava/java/io/natObjectInputStream.cc
index 856f6e2..8240144 100644
--- a/libjava/java/io/natObjectInputStream.cc
+++ b/libjava/java/io/natObjectInputStream.cc
@@ -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 *