ObjectInputStream.java: Reindent.

       * java/io/ObjectInputStream.java: Reindent.
       * java/io/ObjectOutputStream.java: Likewise.

From-SVN: r63614

1 files changed, 291 insertions, 290 deletions

diff --git a/libjava/java/io/ObjectOutputStream.java b/libjava/java/io/ObjectOutputStream.java
index d522996..69f789a 100644
--- a/libjava/java/io/ObjectOutputStream.java
+++ b/libjava/java/io/ObjectOutputStream.java
@@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2, or (at your option)
 any later version.
- 
+
 GNU Classpath is distributed in the hope that it will be useful, but
 WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
@@ -77,22 +77,22 @@ import gnu.classpath.Configuration;
    in a graph lost.
 
    Example usage:
-     <pre>
-     Hashtable map = new Hashtable ();
-     map.put ("one", new Integer (1));
-     map.put ("two", new Integer (2));
+   <pre>
+   Hashtable map = new Hashtable ();
+   map.put ("one", new Integer (1));
+   map.put ("two", new Integer (2));
 
-     ObjectOutputStream oos =
-       new ObjectOutputStream (new FileOutputStream ("numbers"));
-     oos.writeObject (map);
-     oos.close ();
+   ObjectOutputStream oos =
+   new ObjectOutputStream (new FileOutputStream ("numbers"));
+   oos.writeObject (map);
+   oos.close ();
 
-     ObjectInputStream ois =
-       new ObjectInputStream (new FileInputStream ("numbers"));
-     Hashtable newmap = (Hashtable)ois.readObject ();
+   ObjectInputStream ois =
+   new ObjectInputStream (new FileInputStream ("numbers"));
+   Hashtable newmap = (Hashtable)ois.readObject ();
 
-     System.out.println (newmap);
-     </pre>
+   System.out.println (newmap);
+   </pre>
 
    The default serialization can be overriden in two ways.
 
@@ -188,7 +188,7 @@ public class ObjectOutputStream extends OutputStream
 		realOutput.writeByte (TC_NULL);
 		break;
 	      }
-	    
+
 	    Integer handle = findHandle (obj);
 	    if (handle != null)
 	      {
@@ -196,16 +196,16 @@ public class ObjectOutputStream extends OutputStream
 		realOutput.writeInt (handle.intValue ());
 		break;
 	      }
-	    
+
 	    if (obj instanceof Class)
 	      {
 		Class cl = (Class)obj;
-		ObjectStreamClass osc = ObjectStreamClass.lookupForClassObject(cl);
+		ObjectStreamClass osc = ObjectStreamClass.lookupForClassObject (cl);
 		assignNewHandle (obj);
 		realOutput.writeByte (TC_CLASS);
 		if (!osc.isProxyClass)
 		  {
-		    writeObject(osc);
+		    writeObject (osc);
 		  }
 		else
 		  {
@@ -224,7 +224,7 @@ public class ObjectOutputStream extends OutputStream
 		  }
 		break;
 	      }
-	    
+
 	    if (obj instanceof ObjectStreamClass)
 	      {
 		ObjectStreamClass osc = (ObjectStreamClass)obj;
@@ -232,46 +232,46 @@ public class ObjectOutputStream extends OutputStream
 		realOutput.writeUTF (osc.getName ());
 		realOutput.writeLong (osc.getSerialVersionUID ());
 		assignNewHandle (obj);
-		
+
 		int flags = osc.getFlags ();
-		
+
 		if (protocolVersion == PROTOCOL_VERSION_2
 		    && osc.isExternalizable ())
 		  flags |= SC_BLOCK_DATA;
-		
+
 		realOutput.writeByte (flags);
-		
+
 		ObjectStreamField[] fields = osc.fields;
 		realOutput.writeShort (fields.length);
-		
+
 		ObjectStreamField field;
 		for (int i=0; i < fields.length; i++)
 		  {
 		    field = fields[i];
 		    realOutput.writeByte (field.getTypeCode ());
 		    realOutput.writeUTF (field.getName ());
-		    
+
 		    if (! field.isPrimitive ())
 		      writeObject (field.getTypeString ());
 		  }
-		
+
 		boolean oldmode = setBlockDataMode (true);
 		annotateClass (osc.forClass ());
 		setBlockDataMode (oldmode);
 		realOutput.writeByte (TC_ENDBLOCKDATA);
-		
+
 		if (osc.isSerializable ())
 		  writeObject (osc.getSuper ());
 		else
 		  writeObject (null);
 		break;
 	      }
-	    
+
 	    if ((replacementEnabled || obj instanceof Serializable)
 		&& ! replaceDone)
 	      {
 		replacedObject = obj;
-		
+
 		if (obj instanceof Serializable)
 		  {
 		    Method m = null;
@@ -294,14 +294,14 @@ public class ObjectOutputStream extends OutputStream
 		      {
 		      }
 		  }
-		
+
 		if (replacementEnabled)
 		  obj = replaceObject (obj);
-		
+
 		replaceDone = true;
 		continue;
 	      }
-	    
+
 	    if (obj instanceof String)
 	      {
 		realOutput.writeByte (TC_STRING);
@@ -309,12 +309,12 @@ public class ObjectOutputStream extends OutputStream
 		realOutput.writeUTF ((String)obj);
 		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);
@@ -323,56 +323,55 @@ public class ObjectOutputStream extends OutputStream
 		writeArraySizeAndElements (obj, clazz.getComponentType ());
 		break;
 	      }
-	    
+
 	    realOutput.writeByte (TC_OBJECT);
 	    writeObject (osc);
-	    
+
 	    if (replaceDone)
 	      assignNewHandle (replacedObject);
 	    else
 	      assignNewHandle (obj);
-	    
+
 	    if (obj instanceof Externalizable)
 	      {
 		if (protocolVersion == PROTOCOL_VERSION_2)
 		  setBlockDataMode (true);
-		
+
 		((Externalizable)obj).writeExternal (this);
-		
+
 		if (protocolVersion == PROTOCOL_VERSION_2)
 		  {
 		    setBlockDataMode (false);
 		    realOutput.writeByte (TC_ENDBLOCKDATA);
 		  }
-		
+
 		break;
 	      }
-	    
+
 	    if (obj instanceof Serializable)
 	      {
 		currentObject = obj;
 		ObjectStreamClass[] hierarchy =
 		  ObjectStreamClass.getObjectStreamClasses (clazz);
-		
+
 		boolean has_write;
 		for (int i=0; i < hierarchy.length; i++)
 		  {
 		    currentObjectStreamClass = hierarchy[i];
-		    
+
 		    fieldsAlreadyWritten = false;
 		    has_write = currentObjectStreamClass.hasWriteMethod ();
-		    
+
 		    writeFields (obj, currentObjectStreamClass.fields,
 				 has_write);
-		    
 		  }
-		
+
 		currentObject = null;
 		currentObjectStreamClass = null;
 		currentPutField = null;
 		break;
 	      }
-	    
+
 	    throw new NotSerializableException (clazz.getName ());
 	  } // end pseudo-loop
       }
@@ -395,18 +394,16 @@ public class ObjectOutputStream extends OutputStream
 	  {
 	    throw new StreamCorruptedException ("Exception " + ioe + " thrown while exception was being written to stream.");
 	  }
-	
+
 	reset (true);
       }
     finally
       {
 	isSerializing = was_serializing;
-
 	setBlockDataMode (old_mode);
       }
   }
 
-
   /**
      Writes the current objects non-transient, non-static fields from
      the current class to the underlying output stream.
@@ -464,12 +461,12 @@ public class ObjectOutputStream extends OutputStream
   private void reset (boolean internal) throws IOException
   {
     if (!internal)
-    {
-      if (isSerializing)
-	throw new IOException ("Reset called while serialization in progress");
+      {
+	if (isSerializing)
+	  throw new IOException ("Reset called while serialization in progress");
 
-      realOutput.writeByte (TC_RESET);
-    }
+	realOutput.writeByte (TC_RESET);
+      }
 
     clearHandles ();
   }
@@ -649,12 +646,12 @@ public class ObjectOutputStream extends OutputStream
   public void write (int data) throws IOException
   {
     if (writeDataAsBlocks)
-    {
-      if (blockDataCount == BUFFER_SIZE)
-	drain ();
+      {
+	if (blockDataCount == BUFFER_SIZE)
+	  drain ();
 
-      blockData[ blockDataCount++ ] = (byte)data;
-    }
+	blockData[ blockDataCount++ ] = (byte)data;
+      }
     else
       realOutput.write (data);
   }
@@ -675,22 +672,22 @@ public class ObjectOutputStream extends OutputStream
   public void write (byte[] b, int off, int len) throws IOException
   {
     if (writeDataAsBlocks)
-    {
-      if (len < 0)
-	throw new IndexOutOfBoundsException ();
-
-      if (blockDataCount + len < BUFFER_SIZE)
-      {
-	System.arraycopy (b, off, blockData, blockDataCount, len);
-	blockDataCount += len;
-      }
-      else
       {
-	drain ();
-	writeBlockDataHeader (len);
-	realOutput.write (b, off, len);
+	if (len < 0)
+	  throw new IndexOutOfBoundsException ();
+
+	if (blockDataCount + len < BUFFER_SIZE)
+	  {
+	    System.arraycopy (b, off, blockData, blockDataCount, len);
+	    blockDataCount += len;
+	  }
+	else
+	  {
+	    drain ();
+	    writeBlockDataHeader (len);
+	    realOutput.write (b, off, len);
+	  }
       }
-    }
     else
       realOutput.write (b, off, len);
   }
@@ -871,143 +868,143 @@ public class ObjectOutputStream extends OutputStream
     currentPutField = new PutField ()
       {
 	private byte[] prim_field_data
-	  = new byte[currentObjectStreamClass.primFieldSize];
+	= new byte[currentObjectStreamClass.primFieldSize];
 	private Object[] objs
-	  = new Object[currentObjectStreamClass.objectFieldCount];
+	= new Object[currentObjectStreamClass.objectFieldCount];
 
 	public void put (String name, boolean value)
 	  throws IOException, IllegalArgumentException
-	  {
-	    ObjectStreamField field
-	      = currentObjectStreamClass.getField (name);
-	    checkType (field, 'Z');
-	    prim_field_data[field.getOffset ()] = (byte)(value ? 1 : 0);
-	  }
+	{
+	  ObjectStreamField field
+	    = currentObjectStreamClass.getField (name);
+	  checkType (field, 'Z');
+	  prim_field_data[field.getOffset ()] = (byte)(value ? 1 : 0);
+	}
 
 	public void put (String name, byte value)
 	  throws IOException, IllegalArgumentException
-	  {
-	    ObjectStreamField field
-	      = currentObjectStreamClass.getField (name);
-	    checkType (field, 'B');
-	    prim_field_data[field.getOffset ()] = value;
-	  }
+	{
+	  ObjectStreamField field
+	    = currentObjectStreamClass.getField (name);
+	  checkType (field, 'B');
+	  prim_field_data[field.getOffset ()] = value;
+	}
 
 	public void put (String name, char value)
 	  throws IOException, IllegalArgumentException
-	  {
-	    ObjectStreamField field
-	      = currentObjectStreamClass.getField (name);
-	    checkType (field, 'C');
-	    int off = field.getOffset ();
-	    prim_field_data[off++] = (byte)(value >>> 8);
-	    prim_field_data[off] = (byte)value;
-	  }
+	{
+	  ObjectStreamField field
+	    = currentObjectStreamClass.getField (name);
+	  checkType (field, 'C');
+	  int off = field.getOffset ();
+	  prim_field_data[off++] = (byte)(value >>> 8);
+	  prim_field_data[off] = (byte)value;
+	}
 
 	public void put (String name, double value)
 	  throws IOException, IllegalArgumentException
-	  {
-	    ObjectStreamField field
-	      = currentObjectStreamClass.getField (name);
-	    checkType (field, 'D');
-	    int off = field.getOffset ();
-	    long l_value = Double.doubleToLongBits (value);
-	    prim_field_data[off++] = (byte)(l_value >>> 52);
-	    prim_field_data[off++] = (byte)(l_value >>> 48);
-	    prim_field_data[off++] = (byte)(l_value >>> 40);
-	    prim_field_data[off++] = (byte)(l_value >>> 32);
-	    prim_field_data[off++] = (byte)(l_value >>> 24);
-	    prim_field_data[off++] = (byte)(l_value >>> 16);
-	    prim_field_data[off++] = (byte)(l_value >>> 8);
-	    prim_field_data[off] = (byte)l_value;
-	  }
+	{
+	  ObjectStreamField field
+	    = currentObjectStreamClass.getField (name);
+	  checkType (field, 'D');
+	  int off = field.getOffset ();
+	  long l_value = Double.doubleToLongBits (value);
+	  prim_field_data[off++] = (byte)(l_value >>> 52);
+	  prim_field_data[off++] = (byte)(l_value >>> 48);
+	  prim_field_data[off++] = (byte)(l_value >>> 40);
+	  prim_field_data[off++] = (byte)(l_value >>> 32);
+	  prim_field_data[off++] = (byte)(l_value >>> 24);
+	  prim_field_data[off++] = (byte)(l_value >>> 16);
+	  prim_field_data[off++] = (byte)(l_value >>> 8);
+	  prim_field_data[off] = (byte)l_value;
+	}
 
 	public void put (String name, float value)
 	  throws IOException, IllegalArgumentException
-	  {
-	    ObjectStreamField field
-	      = currentObjectStreamClass.getField (name);
-	    checkType (field, 'F');
-	    int off = field.getOffset ();
-	    int i_value = Float.floatToIntBits (value);
-	    prim_field_data[off++] = (byte)(i_value >>> 24);
-	    prim_field_data[off++] = (byte)(i_value >>> 16);
-	    prim_field_data[off++] = (byte)(i_value >>> 8);
-	    prim_field_data[off] = (byte)i_value;
-	  }
+	{
+	  ObjectStreamField field
+	    = currentObjectStreamClass.getField (name);
+	  checkType (field, 'F');
+	  int off = field.getOffset ();
+	  int i_value = Float.floatToIntBits (value);
+	  prim_field_data[off++] = (byte)(i_value >>> 24);
+	  prim_field_data[off++] = (byte)(i_value >>> 16);
+	  prim_field_data[off++] = (byte)(i_value >>> 8);
+	  prim_field_data[off] = (byte)i_value;
+	}
 
 	public void put (String name, int value)
 	  throws IOException, IllegalArgumentException
-	  {
-	    ObjectStreamField field
-	      = currentObjectStreamClass.getField (name);
-	    checkType (field, 'I');
-	    int off = field.getOffset ();
-	    prim_field_data[off++] = (byte)(value >>> 24);
-	    prim_field_data[off++] = (byte)(value >>> 16);
-	    prim_field_data[off++] = (byte)(value >>> 8);
-	    prim_field_data[off] = (byte)value;
-	  }
+	{
+	  ObjectStreamField field
+	    = currentObjectStreamClass.getField (name);
+	  checkType (field, 'I');
+	  int off = field.getOffset ();
+	  prim_field_data[off++] = (byte)(value >>> 24);
+	  prim_field_data[off++] = (byte)(value >>> 16);
+	  prim_field_data[off++] = (byte)(value >>> 8);
+	  prim_field_data[off] = (byte)value;
+	}
 
 	public void put (String name, long value)
 	  throws IOException, IllegalArgumentException
-	  {
-	    ObjectStreamField field
-	      = currentObjectStreamClass.getField (name);
-	    checkType (field, 'J');
-	    int off = field.getOffset ();
-	    prim_field_data[off++] = (byte)(value >>> 52);
-	    prim_field_data[off++] = (byte)(value >>> 48);
-	    prim_field_data[off++] = (byte)(value >>> 40);
-	    prim_field_data[off++] = (byte)(value >>> 32);
-	    prim_field_data[off++] = (byte)(value >>> 24);
-	    prim_field_data[off++] = (byte)(value >>> 16);
-	    prim_field_data[off++] = (byte)(value >>> 8);
-	    prim_field_data[off] = (byte)value;
-	  }
+	{
+	  ObjectStreamField field
+	    = currentObjectStreamClass.getField (name);
+	  checkType (field, 'J');
+	  int off = field.getOffset ();
+	  prim_field_data[off++] = (byte)(value >>> 52);
+	  prim_field_data[off++] = (byte)(value >>> 48);
+	  prim_field_data[off++] = (byte)(value >>> 40);
+	  prim_field_data[off++] = (byte)(value >>> 32);
+	  prim_field_data[off++] = (byte)(value >>> 24);
+	  prim_field_data[off++] = (byte)(value >>> 16);
+	  prim_field_data[off++] = (byte)(value >>> 8);
+	  prim_field_data[off] = (byte)value;
+	}
 
 	public void put (String name, short value)
 	  throws IOException, IllegalArgumentException
-	  {
-	    ObjectStreamField field
-	      = currentObjectStreamClass.getField (name);
-	    checkType (field, 'S');
-	    int off = field.getOffset ();
-	    prim_field_data[off++] = (byte)(value >>> 8);
-	    prim_field_data[off] = (byte)value;
-	  }
+	{
+	  ObjectStreamField field
+	    = currentObjectStreamClass.getField (name);
+	  checkType (field, 'S');
+	  int off = field.getOffset ();
+	  prim_field_data[off++] = (byte)(value >>> 8);
+	  prim_field_data[off] = (byte)value;
+	}
 
 	public void put (String name, Object value)
 	  throws IOException, IllegalArgumentException
-	  {
-	    ObjectStreamField field
-	      = currentObjectStreamClass.getField (name);
-	    if (field == null)
-	      throw new IllegalArgumentException ();
-	    if (value != null &&
-	    	! field.getType ().isAssignableFrom (value.getClass ()))
-	      throw new IllegalArgumentException ();
-	    objs[field.getOffset ()] = value;
-	  }
+	{
+	  ObjectStreamField field
+	    = currentObjectStreamClass.getField (name);
+	  if (field == null)
+	    throw new IllegalArgumentException ();
+	  if (value != null &&
+	      ! field.getType ().isAssignableFrom (value.getClass ()))
+	    throw new IllegalArgumentException ();
+	  objs[field.getOffset ()] = value;
+	}
 
 	public void write (ObjectOutput out) throws IOException
-	  {
-	    // Apparently Block data is not used with PutField as per
-	    // empirical evidence against JDK 1.2.  Also see Mauve test
-	    // java.io.ObjectInputOutput.Test.GetPutField.
-	    boolean oldmode = setBlockDataMode (false);
-	    out.write (prim_field_data);
-	    for (int i = 0; i < objs.length; ++ i)
-	      out.writeObject (objs[i]);
-	    setBlockDataMode (oldmode);
-	  }
+	{
+	  // Apparently Block data is not used with PutField as per
+	  // empirical evidence against JDK 1.2.  Also see Mauve test
+	  // java.io.ObjectInputOutput.Test.GetPutField.
+	  boolean oldmode = setBlockDataMode (false);
+	  out.write (prim_field_data);
+	  for (int i = 0; i < objs.length; ++ i)
+	    out.writeObject (objs[i]);
+	  setBlockDataMode (oldmode);
+	}
 
 	private void checkType (ObjectStreamField field, char type)
 	  throws IllegalArgumentException
-	  {
-	    if (TypeSignature.getEncodingOfClass (field.getType ()).charAt (0) != type)
-	      throw new IllegalArgumentException ();
-	  }
+	{
+	  if (TypeSignature.getEncodingOfClass (field.getType ()).charAt (0) != type)
+	    throw new IllegalArgumentException ();
+	}
       };
     // end PutFieldImpl
 
@@ -1029,15 +1026,15 @@ public class ObjectOutputStream extends OutputStream
   private void writeBlockDataHeader (int size) throws IOException
   {
     if (size < 256)
-    {
-      realOutput.writeByte (TC_BLOCKDATA);
-      realOutput.write (size);
-    }
+      {
+	realOutput.writeByte (TC_BLOCKDATA);
+	realOutput.write (size);
+      }
     else
-    {
-      realOutput.writeByte (TC_BLOCKDATALONG);
-      realOutput.writeInt (size);
-    }
+      {
+	realOutput.writeByte (TC_BLOCKDATALONG);
+	realOutput.writeInt (size);
+      }
   }
 
 
@@ -1073,78 +1070,78 @@ public class ObjectOutputStream extends OutputStream
     int length = Array.getLength (array);
 
     if (clazz.isPrimitive ())
-    {
-      if (clazz == Boolean.TYPE)
-      {
-	boolean[] cast_array = (boolean[])array;
-	realOutput.writeInt (length);
-	for (int i=0; i < length; i++)
-	  realOutput.writeBoolean (cast_array[i]);
-	return;
-      }
-      if (clazz == Byte.TYPE)
-      {
-	byte[] cast_array = (byte[])array;
-	realOutput.writeInt (length);
-	realOutput.write(cast_array, 0, length);
-	return;
-      }
-      if (clazz == Character.TYPE)
-      {
-	char[] cast_array = (char[])array;
-	realOutput.writeInt (length);
-	for (int i=0; i < length; i++)
-	  realOutput.writeChar (cast_array[i]);
-	return;
-      }
-      if (clazz == Double.TYPE)
-      {
-	double[] cast_array = (double[])array;
-	realOutput.writeInt (length);
-	for (int i=0; i < length; i++)
-	  realOutput.writeDouble (cast_array[i]);
-	return;
-      }
-      if (clazz == Float.TYPE)
-      {
-	float[] cast_array = (float[])array;
-	realOutput.writeInt (length);
-	for (int i=0; i < length; i++)
-	  realOutput.writeFloat (cast_array[i]);
-	return;
-      }
-      if (clazz == Integer.TYPE)
-      {
-	int[] cast_array = (int[])array;
-	realOutput.writeInt (length);
-	for (int i=0; i < length; i++)
-	  realOutput.writeInt (cast_array[i]);
-	return;
-      }
-      if (clazz == Long.TYPE)
       {
-	long[] cast_array = (long[])array;
-	realOutput.writeInt (length);
-	for (int i=0; i < length; i++)
-	  realOutput.writeLong (cast_array[i]);
-	return;
+	if (clazz == Boolean.TYPE)
+	  {
+	    boolean[] cast_array = (boolean[])array;
+	    realOutput.writeInt (length);
+	    for (int i=0; i < length; i++)
+	      realOutput.writeBoolean (cast_array[i]);
+	    return;
+	  }
+	if (clazz == Byte.TYPE)
+	  {
+	    byte[] cast_array = (byte[])array;
+	    realOutput.writeInt (length);
+	    realOutput.write(cast_array, 0, length);
+	    return;
+	  }
+	if (clazz == Character.TYPE)
+	  {
+	    char[] cast_array = (char[])array;
+	    realOutput.writeInt (length);
+	    for (int i=0; i < length; i++)
+	      realOutput.writeChar (cast_array[i]);
+	    return;
+	  }
+	if (clazz == Double.TYPE)
+	  {
+	    double[] cast_array = (double[])array;
+	    realOutput.writeInt (length);
+	    for (int i=0; i < length; i++)
+	      realOutput.writeDouble (cast_array[i]);
+	    return;
+	  }
+	if (clazz == Float.TYPE)
+	  {
+	    float[] cast_array = (float[])array;
+	    realOutput.writeInt (length);
+	    for (int i=0; i < length; i++)
+	      realOutput.writeFloat (cast_array[i]);
+	    return;
+	  }
+	if (clazz == Integer.TYPE)
+	  {
+	    int[] cast_array = (int[])array;
+	    realOutput.writeInt (length);
+	    for (int i=0; i < length; i++)
+	      realOutput.writeInt (cast_array[i]);
+	    return;
+	  }
+	if (clazz == Long.TYPE)
+	  {
+	    long[] cast_array = (long[])array;
+	    realOutput.writeInt (length);
+	    for (int i=0; i < length; i++)
+	      realOutput.writeLong (cast_array[i]);
+	    return;
+	  }
+	if (clazz == Short.TYPE)
+	  {
+	    short[] cast_array = (short[])array;
+	    realOutput.writeInt (length);
+	    for (int i=0; i < length; i++)
+	      realOutput.writeShort (cast_array[i]);
+	    return;
+	  }
       }
-      if (clazz == Short.TYPE)
+    else
       {
-	short[] cast_array = (short[])array;
+	Object[] cast_array = (Object[])array;
 	realOutput.writeInt (length);
 	for (int i=0; i < length; i++)
-	  realOutput.writeShort (cast_array[i]);
-	return;
+	  writeObject (cast_array[i]);
       }
-    }
-    else
-    {
-      Object[] cast_array = (Object[])array;
-      realOutput.writeInt (length);
-      for (int i=0; i < length; i++)
-	writeObject (cast_array[i]);
-    }
   }
 
 
@@ -1156,43 +1153,43 @@ public class ObjectOutputStream extends OutputStream
 			    boolean call_write_method) throws IOException
   {
     if (call_write_method)
-    {
-      setBlockDataMode (true);
-      callWriteMethod (obj);
-      setBlockDataMode (false);
-      realOutput.writeByte (TC_ENDBLOCKDATA);
-      return;
-    }
+      {
+	setBlockDataMode (true);
+	callWriteMethod (obj);
+	setBlockDataMode (false);
+	realOutput.writeByte (TC_ENDBLOCKDATA);
+	return;
+      }
 
     boolean oldmode = setBlockDataMode (false);
     String field_name;
     Class type;
     for (int i=0; i < fields.length; i++)
-    {
-      field_name = fields[i].getName ();
-      type = fields[i].getType ();
-
-      if (type == Boolean.TYPE)
-	realOutput.writeBoolean (getBooleanField (obj, field_name));
-      else if (type == Byte.TYPE)
-	realOutput.writeByte (getByteField (obj, field_name));
-      else if (type == Character.TYPE)
-	realOutput.writeChar (getCharField (obj, field_name));
-      else if (type == Double.TYPE)
-	realOutput.writeDouble (getDoubleField (obj, field_name));
-      else if (type == Float.TYPE)
-	realOutput.writeFloat (getFloatField (obj, field_name));
-      else if (type == Integer.TYPE)
-	realOutput.writeInt (getIntField (obj, field_name));
-      else if (type == Long.TYPE)
-	realOutput.writeLong (getLongField (obj, field_name));
-      else if (type == Short.TYPE)
-	realOutput.writeShort (getShortField (obj, field_name));
-      else
-	writeObject (getObjectField (obj, field_name,
-				     fields[i].getTypeString ()));
-    }
-    setBlockDataMode(oldmode);
+      {
+	field_name = fields[i].getName ();
+	type = fields[i].getType ();
+
+	if (type == Boolean.TYPE)
+	  realOutput.writeBoolean (getBooleanField (obj, field_name));
+	else if (type == Byte.TYPE)
+	  realOutput.writeByte (getByteField (obj, field_name));
+	else if (type == Character.TYPE)
+	  realOutput.writeChar (getCharField (obj, field_name));
+	else if (type == Double.TYPE)
+	  realOutput.writeDouble (getDoubleField (obj, field_name));
+	else if (type == Float.TYPE)
+	  realOutput.writeFloat (getFloatField (obj, field_name));
+	else if (type == Integer.TYPE)
+	  realOutput.writeInt (getIntField (obj, field_name));
+	else if (type == Long.TYPE)
+	  realOutput.writeLong (getLongField (obj, field_name));
+	else if (type == Short.TYPE)
+	  realOutput.writeShort (getShortField (obj, field_name));
+	else
+	  writeObject (getObjectField (obj, field_name,
+				       fields[i].getTypeString ()));
+      }
+    setBlockDataMode (oldmode);
   }
 
 
@@ -1246,7 +1243,8 @@ public class ObjectOutputStream extends OutputStream
       }
   }
 
-  private boolean getBooleanField (Object obj, String field_name) throws IOException
+  private boolean getBooleanField (Object obj, String field_name)
+    throws IOException
   {
     try
       {
@@ -1291,7 +1289,8 @@ public class ObjectOutputStream extends OutputStream
       }    
   }
 
-  private double getDoubleField (Object obj, String field_name) throws IOException
+  private double getDoubleField (Object obj, String field_name)
+    throws IOException
   {
     try
       {
@@ -1306,7 +1305,8 @@ public class ObjectOutputStream extends OutputStream
       }    
   }
 
-  private float getFloatField (Object obj, String field_name) throws IOException
+  private float getFloatField (Object obj, String field_name)
+    throws IOException
   {
     try
       {
@@ -1351,7 +1351,8 @@ public class ObjectOutputStream extends OutputStream
       }    
   }
 
-  private short getShortField (Object obj, String field_name) throws IOException
+  private short getShortField (Object obj, String field_name)
+    throws IOException
   {
     try
       {
@@ -1388,13 +1389,13 @@ public class ObjectOutputStream extends OutputStream
   {
     return klass.getDeclaredField(name);
   }
-                                                                                
+
   private static Method getMethod (Class klass, String name, Class[] args)
     throws java.lang.NoSuchMethodException
   {
     return klass.getDeclaredMethod(name, args);
   }
-                                                                                
+
   // this value comes from 1.2 spec, but is used in 1.1 as well
   private final static int BUFFER_SIZE = 1024;