[multiple changes]

2005-02-21  Bryce McKinlay  <mckinlay@redhat.com>

	Merge serialization from GNU Classpath.
	* gcj/method.h: Add missing #includes.
	* java/io/ObjectInputStream.java (readClassDescriptor): Check for
	primitive class IDs on the stream here...
	(resolveClass): ...not here.
	* java/io/ObjectStreamField.java: Use VMObjectStream class calls to set
	fields.
	* java/io/VMObjectStreamClass.java (setDoubleNative, setFloatNative,
	setLongNative, setIntNative, setShortNative, setCharNative,
	setByteNative, setBooleanNative, setObjectNative): New native methods.
	* java/io/natVMObjectStreamClass.java (setDoubleNative, setFloatNative,
	setLongNative, setIntNative, setShortNative, setCharNative,
	setByteNative, setBooleanNative, setObjectNative): Implement them.
	* java/io/natObjectInputStream.cc (allocateObject): Add new parameters
	from Classpath's version. Use _Jv_FromReflectedConstructor(). Call
	the constructor here.
	(callConstructor): Removed.
	(getCallersClassLoader): Removed.
	* java/lang/reflect/Field.java (setByte, setShort, setInt, setLong,
	setFloat, setDouble, setChar, setBoolean): Add 'checkFinal' parameter
	to control whether setting final field values is permitted. Call
	getAddr() with checkFinal parameter instead of setAddr().
	* java/lang/reflect/natField.cc (getType): Lookup and resolve field
	only if not done already.
	(getAddr): Add checkFinal parameter. Do the final field check only if
	checkFinal is set.
	(setAddr): Removed.

2005-02-21  Mark Wielaard  <mark@klomp.org>

	# Fixes bug #11957
	* java/io/ObjectInputStream.java (resolveClass): Don't check "void"
	twice.

2005-02-21  Mark Wielaard  <mark@klomp.org>

	Fixes bug #11618.
	* java/io/ObjectInputStream.java (readClassDescriptor): Handle classes
	without a super class and us ObjectStreamClass.lookupForClassObject().
	(resolveClass): Check for primitive types.
	(lookupClass): Return null when argument is null.

2005-02-21  Jeroen Frijters  <jeroen@frijters.net>

	* java/io/ObjectInputStream.java
	(readObject): Fix to consume TC_ENDBLOCKDATA after readExternal.

2005-02-21  Jeroen Frijters  <jeroen@frijters.net>

	* java/io/ObjectOutputStream.java
	(writeObject, callWriteMethod): Replaced reflection with accessing
	cached info in ObjectStreamClass.
	(getMethod): Removed.
	* java/io/ObjectStreamClass.java
	(findMethod): Added check to make sure the method found has the
	right modifiers.
	(cacheMethods): Added writeReplace and writeObject methods.
	(setFlags): Look at new writeObjectMethod field instead of doing
	reflection again.
	(writeReplaceMethod): New field.
	(writeObjectMethod): New field.

2005-02-21  Guilhem Lavaux  <guilhem@kaffe.org>
	Jeroen Frijters  <jeroen@frijters.net>

	* java/io/ObjectInputStream.java
	(newObject): Changed prototype. Get a constructor reflect object
	directly.
	(callConstructor): Removed.
	(allocateObject): Changed prototype.
	(readClassDescriptor): Build the constructor reflection directly.
	(readObject): Invoke newObject using the new prototype.

	* java/io/ObjectStreamClass.java
	(firstNonSerializableParent): Removed.
	(firstNonSerializableParentConstructor): Added.

From-SVN: r95378

libjava/java/io/ObjectInputStream.java

@@ -43,6 +43,7 @@ import gnu.classpath.Configuration;
 import gnu.java.io.ObjectIdentityWrapper;
 
 import java.lang.reflect.Array;
+import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
@@ -122,15 +123,6 @@ public class ObjectInputStream extends InputStream
    */
   public final Object readObject() throws ClassNotFoundException, IOException
   {
-	if (callersClassLoader == null)
-	  {
-		callersClassLoader = getCallersClassLoader ();
-		if (Configuration.DEBUG && dump)
-		  {
-			dumpElementln ("CallersClassLoader = " + callersClassLoader);
-		  }
-	  }
-	
     if (this.useSubclassMethod)
       return readObjectOverride();
 
@@ -272,7 +264,7 @@ public class ObjectInputStream extends InputStream
 	      readArrayElements(array, componentType);
 	      if(dump)
 	        for (int i = 0, len = Array.getLength(array); i < len; i++)
-			  dumpElementln("  ELEMENT[" + i + "]=" + Array.get(array, i));
+		  dumpElementln("  ELEMENT[" + i + "]=" + Array.get(array, i));
 	      ret_val = processResolution(null, array, handle);
 	      break;
 	    }
@@ -302,13 +294,18 @@ public class ObjectInputStream extends InputStream
 		  obj.readExternal(this);
 		  
 		  if (read_from_blocks)
-		    setBlockDataMode(oldmode);
+                    {
+		      setBlockDataMode(oldmode);
+                      if (!oldmode)
+			if (this.realInputStream.readByte() != TC_ENDBLOCKDATA)
+			    throw new IOException("No end of block data seen for class with readExternal (ObjectInputStream) method.");
+                    }
 		  
 		  ret_val = processResolution(osc, obj, handle);
 		  break;
 		} // end if (osc.realClassIsExternalizable)
 
-	      Object obj = newObject(clazz, osc.firstNonSerializableParent);
+	      Object obj = newObject(clazz, osc.firstNonSerializableParentConstructor);
 	      
 	      int handle = assignNewHandle(obj);
 	      Object prevObject = this.currentObject;
@@ -399,8 +396,6 @@ public class ObjectInputStream extends InputStream
 	setBlockDataMode(old_mode);
 	
 	this.isDeserializing = was_deserializing;
-
-	depth -= 2;
 	
 	depth -= 2;
 	
@@ -506,7 +501,8 @@ public class ObjectInputStream extends InputStream
 						  flags, fields);
     assignNewHandle(osc);
 
-    ClassLoader currentLoader = currentLoader();
+    if (callersClassLoader == null)
+      callersClassLoader = currentLoader();
 	      
     for (int i = 0; i < field_count; i++)
       {
@@ -527,12 +523,40 @@ public class ObjectInputStream extends InputStream
 	  class_name = String.valueOf(type_code);
 		  
 	fields[i] =
-	  new ObjectStreamField(field_name, class_name, currentLoader);
+	  new ObjectStreamField(field_name, class_name, callersClassLoader);
       }
 	      
     /* Now that fields have been read we may resolve the class
      * (and read annotation if needed). */
-    Class clazz = resolveClass(osc);
+    Class clazz;
+    try
+      {
+	clazz = resolveClass(osc);
+      }
+    catch (ClassNotFoundException cnfe)
+      {
+	// Maybe it was an primitive class?
+	if (name.equals("void"))
+	  clazz = Void.TYPE;
+	else if (name.equals("boolean"))
+	  clazz = Boolean.TYPE;
+	else if (name.equals("byte"))
+	  clazz = Byte.TYPE;
+	else if (name.equals("short"))
+	  clazz = Short.TYPE;
+	else if (name.equals("char"))
+	  clazz = Character.TYPE;
+	else if (name.equals("int"))
+	  clazz = Integer.TYPE;
+	else if (name.equals("long"))
+	  clazz = Long.TYPE;
+	else if (name.equals("float"))
+	  clazz = Float.TYPE;
+	else if (name.equals("double"))
+	  clazz = Double.TYPE;
+	else
+	  throw cnfe;
+      }
 
     boolean oldmode = setBlockDataMode(true);
     osc.setClass(clazz, lookupClass(clazz.getSuperclass()));
@@ -542,16 +566,45 @@ public class ObjectInputStream extends InputStream
     // find the first non-serializable, non-abstract
     // class in clazz's inheritance hierarchy
     Class first_nonserial = clazz.getSuperclass();
-    while (Serializable.class.isAssignableFrom(first_nonserial)
-	|| Modifier.isAbstract(first_nonserial.getModifiers()))
+    // Maybe it is a primitive class, those don't have a super class,
+    // or Object itself.  Otherwise we can keep getting the superclass
+    // till we hit the Object class, or some other non-serializable class.
+
+    if (first_nonserial == null)
+      first_nonserial = clazz;
+    else
+      while (Serializable.class.isAssignableFrom(first_nonserial)
+	     || Modifier.isAbstract(first_nonserial.getModifiers()))
 	first_nonserial = first_nonserial.getSuperclass();
 
-    osc.firstNonSerializableParent = first_nonserial;
+    final Class local_constructor_class = first_nonserial;
+
+    osc.firstNonSerializableParentConstructor =
+        (Constructor)AccessController.doPrivileged(new PrivilegedAction()
+          {
+            public Object run()
+            {
+              try
+                {
+                  Constructor c = local_constructor_class.
+                                    getDeclaredConstructor(new Class[0]);
+                  if (Modifier.isPrivate(c.getModifiers()))
+                    return null;
+                  return c;
+                }
+              catch (NoSuchMethodException e)
+                {
+                  // error will be reported later, in newObject()
+                  return null;
+                }
+            }
+          });
+
     osc.realClassIsSerializable = Serializable.class.isAssignableFrom(clazz);
     osc.realClassIsExternalizable = Externalizable.class.isAssignableFrom(clazz);
 
     ObjectStreamField[] stream_fields = osc.fields;
-    ObjectStreamField[] real_fields = ObjectStreamClass.lookup(clazz).fields;
+    ObjectStreamField[] real_fields = ObjectStreamClass.lookupForClassObject(clazz).fields;
     ObjectStreamField[] fieldmapping = new ObjectStreamField[2 * Math.max(stream_fields.length, real_fields.length)];
 
     int stream_idx = 0;
@@ -717,6 +770,15 @@ public class ObjectInputStream extends InputStream
   protected Class resolveClass(ObjectStreamClass osc)
     throws ClassNotFoundException, IOException
   {
+    if (callersClassLoader == null)
+      {
+	callersClassLoader = currentLoader ();
+	if (Configuration.DEBUG && dump)
+	  {
+	    dumpElementln ("CallersClassLoader = " + callersClassLoader);
+	  }
+      }
+
     return Class.forName(osc.getName(), true, callersClassLoader);
   }
 
@@ -750,8 +812,10 @@ public class ObjectInputStream extends InputStream
    */
   private ObjectStreamClass lookupClass(Class clazz)
   {
-    ObjectStreamClass oclazz;
+    if (clazz == null)
+      return null;
 
+    ObjectStreamClass oclazz;
     oclazz = (ObjectStreamClass)classLookupTable.get(clazz);
     if (oclazz == null)
       return ObjectStreamClass.lookup(clazz);
@@ -1767,14 +1831,14 @@ public class ObjectInputStream extends InputStream
 
   // returns a new instance of REAL_CLASS that has been constructed
   // only to the level of CONSTRUCTOR_CLASS (a super class of REAL_CLASS)
-  private Object newObject (Class real_class, Class constructor_class)
-    throws ClassNotFoundException
+  private Object newObject (Class real_class, Constructor constructor)
+    throws ClassNotFoundException, IOException
   {
+    if (constructor == null)
+        throw new InvalidClassException("Missing accessible no-arg base class constructor for " + real_class.getName()); 
     try
       {
-	Object obj = allocateObject (real_class);
-	callConstructor (constructor_class, obj);
-	return obj;
+	return allocateObject(real_class, constructor.getDeclaringClass(), constructor);
       }
     catch (InstantiationException e)
       {
@@ -1810,8 +1874,6 @@ public class ObjectInputStream extends InputStream
    * @return The current class loader in the calling stack.
    */
   private static native ClassLoader currentClassLoader (SecurityManager sm);
-  
-  private native ClassLoader getCallersClassLoader();
 
   private void callReadMethod (Method readObject, Class klass, Object obj)
     throws ClassNotFoundException, IOException
@@ -1844,11 +1906,9 @@ public class ObjectInputStream extends InputStream
     prereadFields = null;
   }
     
-  private native Object allocateObject (Class clazz)
+  private native Object allocateObject(Class clazz, Class constr_clazz, Constructor constructor)
     throws InstantiationException;
 
-  private native void callConstructor (Class clazz, Object obj);
-
   private static final int BUFFER_SIZE = 1024;
 
   private DataInputStream realInputStream;
@@ -1870,9 +1930,8 @@ public class ObjectInputStream extends InputStream
   private Hashtable classLookupTable;
   private GetField prereadFields;
 
-  private static boolean dump = false && Configuration.DEBUG;
-
   private ClassLoader callersClassLoader;
+  private static boolean dump;
 
   // The nesting depth for debugging output
   private int depth = 0;

libjava/java/io/ObjectOutputStream.java

@@ -250,6 +250,11 @@ public class ObjectOutputStream extends OutputStream
 		break;
 	      }
 
+	    Class clazz = obj.getClass();
+	    ObjectStreamClass osc = ObjectStreamClass.lookupForClassObject(clazz);
+	    if (osc == null)
+	      throw new NotSerializableException(clazz.getName());
+	    
 	    if ((replacementEnabled || obj instanceof Serializable)
 		&& ! replaceDone)
 	      {
@@ -257,19 +262,11 @@ public class ObjectOutputStream extends OutputStream
 		
 		if (obj instanceof Serializable)
 		  {
-		    Method m = null;
 		    try
 		      {
-			Class classArgs[] = {};
-			m = getMethod(obj.getClass(), "writeReplace",
-				      classArgs);
-			// m can't be null by definition since an
-			// exception would have been thrown so a check
-			// for null is not needed.
-			obj = m.invoke(obj, new Object[] {});
-		      }
-		    catch (NoSuchMethodException ignore)
-		      {
+                        Method m = osc.writeReplaceMethod;
+                        if (m != null)
+                            obj = m.invoke(obj, new Object[0]);
 		      }
 		    catch (IllegalAccessException ignore)
 		      {
@@ -294,11 +291,6 @@ public class ObjectOutputStream extends OutputStream
 		break;
 	      }
 
-	    Class clazz = obj.getClass();
-	    ObjectStreamClass osc = ObjectStreamClass.lookupForClassObject(clazz);
-	    if (osc == null)
-	      throw new NotSerializableException(clazz.getName());
-	    
 	    if (clazz.isArray ())
 	      {
 		realOutput.writeByte(TC_ARRAY);
@@ -347,8 +339,8 @@ public class ObjectOutputStream extends OutputStream
 		    fieldsAlreadyWritten = false;
 		    if (currentObjectStreamClass.hasWriteMethod())
 		      {
-				if (dump)
-				  dumpElementln ("WRITE METHOD CALLED FOR: " + obj);
+			if (dump)
+			  dumpElementln ("WRITE METHOD CALLED FOR: " + obj);
 			setBlockDataMode(true);
 			callWriteMethod(obj, currentObjectStreamClass);
 			setBlockDataMode(false);
@@ -358,10 +350,10 @@ public class ObjectOutputStream extends OutputStream
 		      }
 		    else
 		      {
-				if (dump)
-				  dumpElementln ("WRITE FIELDS CALLED FOR: " + obj);
-				writeFields(obj, currentObjectStreamClass);
-			  }
+			if (dump)
+			  dumpElementln ("WRITE FIELDS CALLED FOR: " + obj);
+			writeFields(obj, currentObjectStreamClass);
+		      }
 		  }
 
 		this.currentObject = prevObject;
@@ -1261,18 +1253,11 @@ public class ObjectOutputStream extends OutputStream
   private void callWriteMethod(Object obj, ObjectStreamClass osc)
     throws IOException
   {
-    Class klass = osc.forClass();
     currentPutField = null;
     try
       {
-	Class classArgs[] = {ObjectOutputStream.class};
-	Method m = getMethod(klass, "writeObject", classArgs);
-	Object args[] = {this};
-	m.invoke(obj, args);	
-      }
-    catch (NoSuchMethodException nsme)
-      {
-	// Nothing.
+        Object args[] = {this};
+        osc.writeObjectMethod.invoke(obj, args);
       }
     catch (InvocationTargetException x)
       {
@@ -1285,7 +1270,8 @@ public class ObjectOutputStream extends OutputStream
 
 	IOException ioe
 	  = new IOException("Exception thrown from writeObject() on " +
-			    klass + ": " + exception.getClass().getName());
+			    osc.forClass().getName() + ": " +
+                            exception.getClass().getName());
 	ioe.initCause(exception);
 	throw ioe;
       }
@@ -1293,7 +1279,8 @@ public class ObjectOutputStream extends OutputStream
       {
 	IOException ioe
 	  = new IOException("Failure invoking writeObject() on " +
-			    klass + ": " + x.getClass().getName());
+			    osc.forClass().getName() + ": " +
+			    x.getClass().getName());
 	ioe.initCause(x);
 	throw ioe;
       }
@@ -1535,15 +1522,6 @@ public class ObjectOutputStream extends OutputStream
       }
   }
 
-  private Method getMethod (Class klass, String name, Class[] args)
-    throws java.lang.NoSuchMethodException
-  {
-    final Method m = klass.getDeclaredMethod(name, args);
-    setAccessible.setMember(m);
-    AccessController.doPrivileged(setAccessible);
-    return m;
-  }
-
   private void dumpElementln (String msg)
   {
     for (int i = 0; i < depth; i++)

libjava/java/io/ObjectStreamField.java

@@ -367,109 +367,46 @@ public class ObjectStreamField implements Comparable
 
   final void setBooleanField(Object obj, boolean val)
   {
-    try
-      {
-	field.setBoolean(obj, val);
-      }
-    catch(IllegalAccessException x)
-      {
-	throw new InternalError(x.getMessage());
-      }
+    VMObjectStreamClass.setBooleanNative(field, obj, val);  
   }
 
   final void setByteField(Object obj, byte val)
   {
-    try
-      {
-	field.setByte(obj, val);
-      }
-    catch(IllegalAccessException x)
-      {
-	throw new InternalError(x.getMessage());
-      }
+    VMObjectStreamClass.setByteNative(field, obj, val);
   }
   
   final void setCharField(Object obj, char val)
   {
-    try
-      {
-	field.setChar(obj, val);
-      }
-    catch(IllegalAccessException x)
-      {
-	throw new InternalError(x.getMessage());
-      }
+    VMObjectStreamClass.setCharNative(field, obj, val);
   }
   
   final void setShortField(Object obj, short val)
   {
-    try
-      {
-	field.setShort(obj, val);
-      }
-    catch(IllegalAccessException x)
-      {
-	throw new InternalError(x.getMessage());
-      }
+    VMObjectStreamClass.setShortNative(field, obj, val);
   }
 
   final void setIntField(Object obj, int val)
   {
-    try
-      {
-	field.setInt(obj, val);
-      }
-    catch(IllegalAccessException x)
-      {
-	throw new InternalError(x.getMessage());
-      }
+    VMObjectStreamClass.setIntNative(field, obj, val);
   }
   
   final void setLongField(Object obj, long val)
   {
-    try
-      {
-	field.setLong(obj, val);
-      }
-    catch(IllegalAccessException x)
-      {
-	throw new InternalError(x.getMessage());
-      }
+    VMObjectStreamClass.setLongNative(field, obj, val);
   }
   
   final void setFloatField(Object obj, float val)
   {
-    try
-      {
-	field.setFloat(obj, val);
-      }
-    catch(IllegalAccessException x)
-      {
-	throw new InternalError(x.getMessage());
-      }
+    VMObjectStreamClass.setFloatNative(field, obj, val);
   }
   
   final void setDoubleField(Object obj, double val)
   {
-    try
-      {
-	field.setDouble(obj, val);
-      }
-    catch(IllegalAccessException x)
-      {
-	throw new InternalError(x.getMessage());
-      }
+    VMObjectStreamClass.setDoubleNative(field, obj, val);
   }
   
   final void setObjectField(Object obj, Object val)
   { 
-    try
-      {
-	field.set(obj, val);
-      }
-    catch(IllegalAccessException x)
-      {
-	throw new InternalError(x.getMessage());
-      }
+    VMObjectStreamClass.setObjectNative(field, obj, val);
   }
 }

libjava/java/io/VMObjectStreamClass.java

@@ -38,7 +38,7 @@ exception statement from your version. */
 
 package java.io;
 
-import java.lang.reflect.Method;
+import java.lang.reflect.Field;
 
 final class VMObjectStreamClass
 {
@@ -47,4 +47,94 @@ final class VMObjectStreamClass
     * (a.k.a. <clinit>).
     */
   static native boolean hasClassInitializer (Class clazz);
+
+  /**
+   * Sets the value of the specified "double" field, allowing final values 
+   * to be assigned.
+   *
+   * @param field Field to set the value.
+   * @param obj Instance which will have its field set.
+   * @param val Value to put in the field.
+   */
+  static native void setDoubleNative(Field field, Object obj, double val);
+
+  /**
+   * Sets the value of the specified "float" field, allowing final values 
+   * to be assigned.
+   *
+   * @param field Field to set the value.
+   * @param obj Instance which will have its field set.
+   * @param val Value to put in the field.
+   */
+  static native void setFloatNative(Field field, Object obj, float val);
+
+  /**
+   * Sets the value of the specified "long" field, allowing final values 
+   * to be assigned.
+   *
+   * @param field Field to set the value.
+   * @param obj Instance which will have its field set.
+   * @param val Value to put in the field.
+   */
+  static native void setLongNative(Field field, Object obj, long val);
+  
+  /**
+   * Sets the value of the specified "int" field, allowing final values 
+   * to be assigned.
+   *
+   * @param field Field to set the value.
+   * @param obj Instance which will have its field set.
+   * @param val Value to put in the field.
+   */
+  static native void setIntNative(Field field, Object obj, int val);
+  
+  /**
+   * Sets the value of the specified "short" field, allowing final values 
+   * to be assigned.
+   *
+   * @param field Field to set the value.
+   * @param obj Instance which will have its field set.
+   * @param val Value to put in the field.
+   */
+  static native void setShortNative(Field field, Object obj, short val);
+
+  /**
+   * Sets the value of the specified "char" field, allowing final values 
+   * to be assigned.
+   *
+   * @param field Field to set the value.
+   * @param obj Instance which will have its field set.
+   * @param val Value to put in the field.
+   */
+  static native void setCharNative(Field field, Object obj, char val);
+
+  /**
+   * Sets the value of the specified "byte" field, allowing final values 
+   * to be assigned.
+   *
+   * @param field Field to set the value.
+   * @param obj Instance which will have its field set.
+   * @param val Value to put in the field.
+   */
+  static native void setByteNative(Field field, Object obj, byte val);
+
+  /**
+   * Sets the value of the specified "boolean" field, allowing final values 
+   * to be assigned.
+   *
+   * @param field Field to set the value.
+   * @param obj Instance which will have its field set.
+   * @param val Value to put in the field.
+   */
+  static native void setBooleanNative(Field field, Object obj, boolean val);
+
+  /**
+   * Sets the value of the specified object field, allowing final values 
+   * to be assigned.
+   *
+   * @param field Field to set the value.
+   * @param obj Instance which will have its field set.
+   * @param val Value to put in the field.
+   */
+  static native void setObjectNative(Field field, Object obj, Object val);
 }

libjava/java/io/natObjectInputStream.cc

@@ -12,6 +12,7 @@ details.  */
 
 #include <gcj/cni.h>
 #include <jvm.h>
+#include <gcj/method.h>
 
 #include <java/io/ObjectInputStream$GetField.h>
 #include <java/io/ObjectInputStream.h>
@@ -21,6 +22,8 @@ details.  */
 #include <java/lang/reflect/Method.h>
 #include <java/lang/ArrayIndexOutOfBoundsException.h>
 #include <java/lang/SecurityManager.h>
+#include <java/lang/reflect/Constructor.h>
+#include <java/lang/reflect/Method.h>
 
 #ifdef DEBUG
 #include <java/lang/System.h>
@@ -28,7 +31,8 @@ details.  */
 #endif
 
 jobject
-java::io::ObjectInputStream::allocateObject (jclass klass)
+java::io::ObjectInputStream::allocateObject (jclass klass, jclass,
+  ::java::lang::reflect::Constructor *ctr)
 {
   jobject obj = NULL;
   using namespace java::lang::reflect;
@@ -41,21 +45,15 @@ java::io::ObjectInputStream::allocateObject (jclass klass)
       else
 	{
 	  obj = _Jv_AllocObject (klass);
-	}
+	}	
     }
   catch (jthrowable t)
     {
       return NULL;
     }
 
-  return obj;
-}
+  jmethodID meth = _Jv_FromReflectedConstructor (ctr);
 
-
-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
@@ -63,36 +61,12 @@ java::io::ObjectInputStream::callConstructor (jclass klass, jobject obj)
   JArray<jclass> *arg_types
     = (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::ClassLoader* 
-java::io::ObjectInputStream::getCallersClassLoader ()
-{
-  java::lang::ClassLoader *loader = NULL;
-  gnu::gcj::runtime::StackTrace *t 
-    = new gnu::gcj::runtime::StackTrace(4);
-  java::lang::Class *klass = NULL;
-  try
-    {
-      for (int i = 2; !klass; i++)
-	{
-	  klass = t->classAt (i);
-	}
-      loader = klass->getClassLoaderInternal();
-    }
-  catch (::java::lang::ArrayIndexOutOfBoundsException *e)
-    {
-      // FIXME: RuntimeError
-    }
-
-  return loader;
+  return obj;
 }
 
 java::lang::ClassLoader*

libjava/java/io/natVMObjectStreamClass.cc

@@ -13,11 +13,75 @@ details.  */
 
 #include <java/io/VMObjectStreamClass.h>
 #include <java/lang/Class.h>
+#include <java/lang/reflect/Field.h>
+
+using namespace java::lang::reflect;
 
 jboolean
 java::io::VMObjectStreamClass::hasClassInitializer (jclass klass)
 {
+  if (klass->isPrimitive())
+    return false;
   _Jv_Method *meth = _Jv_GetMethodLocal(klass, gcj::clinit_name,
 					       gcj::void_signature);
   return (meth != NULL);
 }
+
+void
+java::io::VMObjectStreamClass::setDoubleNative (Field *f, jobject obj, 
+						jdouble val)
+{
+  f->setDouble (NULL, obj, val, false);
+}
+
+void 
+java::io::VMObjectStreamClass::setFloatNative (Field *f, jobject obj, 
+					       jfloat val)
+{
+  f->setFloat (NULL, obj, val, false);
+}
+
+void
+java::io::VMObjectStreamClass::setLongNative (Field *f, jobject obj, jlong val)
+{
+  f->setLong (NULL, obj, val, false);
+}
+
+void
+java::io::VMObjectStreamClass::setIntNative (Field *f, jobject obj, jint val)
+{
+  f->setInt (NULL, obj, val, false);
+}
+
+void
+java::io::VMObjectStreamClass::setShortNative (Field *f, jobject obj, 
+					       jshort val)
+{
+  f->setShort (NULL, obj, val, false);
+}
+
+void
+java::io::VMObjectStreamClass::setCharNative (Field *f, jobject obj, jchar val)
+{
+  f->setChar (NULL, obj, val, false);
+}
+
+void
+java::io::VMObjectStreamClass::setByteNative (Field *f, jobject obj, jbyte val)
+{
+  f->setByte (NULL, obj, val, false);
+}
+
+void
+java::io::VMObjectStreamClass::setBooleanNative (Field *f, jobject obj,
+						 jboolean val)
+{
+  f->setBoolean (NULL, obj, val, false);
+}
+
+void
+java::io::VMObjectStreamClass::setObjectNative (Field *f, jobject obj, 
+						jobject val)
+{
+  f->set (NULL, obj, val, f->getType(), false);
+}