2003-12-30 Michael Koch <konqueror@gmx.de>

	* java/io/ObjectInputStream.java,
	java/io/ObjectOutputStream.java,
	java/io/ObjectStreamClass.java:
	Reformated, no functional code changes.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@75236 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 342 insertions, 338 deletions

diff --git a/libjava/java/io/ObjectOutputStream.java b/libjava/java/io/ObjectOutputStream.java
index 0244e2d2c91..8f991f0baa1 100644
--- a/libjava/java/io/ObjectOutputStream.java
+++ b/libjava/java/io/ObjectOutputStream.java
@@ -132,18 +132,18 @@ public class ObjectOutputStream extends OutputStream
    */
   public ObjectOutputStream (OutputStream out) throws IOException
   {
-    realOutput = new DataOutputStream (out);
+    realOutput = new DataOutputStream(out);
     blockData = new byte[ BUFFER_SIZE ];
     blockDataCount = 0;
-    blockDataOutput = new DataOutputStream (this);
-    setBlockDataMode (true);
+    blockDataOutput = new DataOutputStream(this);
+    setBlockDataMode(true);
     replacementEnabled = false;
     isSerializing = false;
     nextOID = baseWireHandle;
-    OIDLookupTable = new Hashtable ();
+    OIDLookupTable = new Hashtable();
     protocolVersion = defaultProtocolVersion;
     useSubclassMethod = false;
-    writeStreamHeader ();
+    writeStreamHeader();
   }
 
   /**
@@ -165,16 +165,16 @@ public class ObjectOutputStream extends OutputStream
    * @exception IOException Exception from underlying
    * <code>OutputStream</code>.
    */
-  public final void writeObject (Object obj) throws IOException
+  public final void writeObject(Object obj) throws IOException
   {
     if (useSubclassMethod)
       {
-	writeObjectOverride (obj);
+	writeObjectOverride(obj);
 	return;
       }
 
     boolean was_serializing = isSerializing;
-    boolean old_mode = setBlockDataMode (false);
+    boolean old_mode = setBlockDataMode(false);
     try
       {
 	isSerializing = true;
@@ -185,49 +185,49 @@ public class ObjectOutputStream extends OutputStream
 	  {
 	    if (obj == null)
 	      {
-		realOutput.writeByte (TC_NULL);
+		realOutput.writeByte(TC_NULL);
 		break;
 	      }
 
-	    Integer handle = findHandle (obj);
+	    Integer handle = findHandle(obj);
 	    if (handle != null)
 	      {
-		realOutput.writeByte (TC_REFERENCE);
-		realOutput.writeInt (handle.intValue ());
+		realOutput.writeByte(TC_REFERENCE);
+		realOutput.writeInt(handle.intValue());
 		break;
 	      }
 
 	    if (obj instanceof Class)
 	      {
 		Class cl = (Class)obj;
-		ObjectStreamClass osc = ObjectStreamClass.lookupForClassObject (cl);
-		assignNewHandle (obj);
-		realOutput.writeByte (TC_CLASS);
+		ObjectStreamClass osc = ObjectStreamClass.lookupForClassObject(cl);
+		assignNewHandle(obj);
+		realOutput.writeByte(TC_CLASS);
 		if (!osc.isProxyClass)
 		  {
 		    writeObject (osc);
 		  }
 		else
 		  {
-		    realOutput.writeByte (TC_PROXYCLASSDESC);
+		    realOutput.writeByte(TC_PROXYCLASSDESC);
 		    Class[] intfs = cl.getInterfaces();
 		    realOutput.writeInt(intfs.length);
 		    for (int i = 0; i < intfs.length; i++)
 		      realOutput.writeUTF(intfs[i].getName());
 		    
-		    boolean oldmode = setBlockDataMode (true);
+		    boolean oldmode = setBlockDataMode(true);
 		    annotateProxyClass(cl);
-		    setBlockDataMode (oldmode);
+		    setBlockDataMode(oldmode);
 		    realOutput.writeByte(TC_ENDBLOCKDATA);
 		    
-		    writeObject (osc.getSuper());
+		    writeObject(osc.getSuper());
 		  }
 		break;
 	      }
 
 	    if (obj instanceof ObjectStreamClass)
 	      {
-		writeClassDescriptor ((ObjectStreamClass) obj);
+		writeClassDescriptor((ObjectStreamClass) obj);
 		break;
 	      }
 
@@ -235,7 +235,7 @@ public class ObjectOutputStream extends OutputStream
 		&& ! replaceDone)
 	      {
 		replacedObject = obj;
-
+		
 		if (obj instanceof Serializable)
 		  {
 		    Method m = null;
@@ -247,7 +247,7 @@ public class ObjectOutputStream extends OutputStream
 			// 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[] {});
+			obj = m.invoke(obj, new Object[] {});
 		      }
 		    catch (NoSuchMethodException ignore)
 		      {
@@ -259,55 +259,55 @@ public class ObjectOutputStream extends OutputStream
 		      {
 		      }
 		  }
-
+		
 		if (replacementEnabled)
-		  obj = replaceObject (obj);
-
+		  obj = replaceObject(obj);
+		
 		replaceDone = true;
 		continue;
 	      }
 
 	    if (obj instanceof String)
 	      {
-		realOutput.writeByte (TC_STRING);
-		assignNewHandle (obj);
-		realOutput.writeUTF ((String)obj);
+		realOutput.writeByte(TC_STRING);
+		assignNewHandle(obj);
+		realOutput.writeUTF((String)obj);
 		break;
 	      }
 
-	    Class clazz = obj.getClass ();
-	    ObjectStreamClass osc = ObjectStreamClass.lookupForClassObject (clazz);
+	    Class clazz = obj.getClass();
+	    ObjectStreamClass osc = ObjectStreamClass.lookupForClassObject(clazz);
 	    if (osc == null)
-	      throw new NotSerializableException (clazz.getName ());
-
+	      throw new NotSerializableException(clazz.getName());
+	    
 	    if (clazz.isArray ())
 	      {
-		realOutput.writeByte (TC_ARRAY);
-		writeObject (osc);
-		assignNewHandle (obj);
-		writeArraySizeAndElements (obj, clazz.getComponentType ());
+		realOutput.writeByte(TC_ARRAY);
+		writeObject(osc);
+		assignNewHandle(obj);
+		writeArraySizeAndElements(obj, clazz.getComponentType());
 		break;
 	      }
-
-	    realOutput.writeByte (TC_OBJECT);
-	    writeObject (osc);
+	    
+	    realOutput.writeByte(TC_OBJECT);
+	    writeObject(osc);
 
 	    if (replaceDone)
-	      assignNewHandle (replacedObject);
+	      assignNewHandle(replacedObject);
 	    else
-	      assignNewHandle (obj);
+	      assignNewHandle(obj);
 
 	    if (obj instanceof Externalizable)
 	      {
 		if (protocolVersion == PROTOCOL_VERSION_2)
-		  setBlockDataMode (true);
-
-		((Externalizable)obj).writeExternal (this);
-
+		  setBlockDataMode(true);
+		
+		((Externalizable)obj).writeExternal(this);
+		
 		if (protocolVersion == PROTOCOL_VERSION_2)
 		  {
-		    setBlockDataMode (false);
-		    realOutput.writeByte (TC_ENDBLOCKDATA);
+		    setBlockDataMode(false);
+		    realOutput.writeByte(TC_ENDBLOCKDATA);
 		  }
 
 		break;
@@ -317,22 +317,22 @@ public class ObjectOutputStream extends OutputStream
 	      {
 		currentObject = obj;
 		ObjectStreamClass[] hierarchy =
-		  ObjectStreamClass.getObjectStreamClasses (clazz);
-
-		for (int i=0; i < hierarchy.length; i++)
+		  ObjectStreamClass.getObjectStreamClasses(clazz);
+		
+		for (int i = 0; i < hierarchy.length; i++)
 		  {
 		    currentObjectStreamClass = hierarchy[i];
-
+		    
 		    fieldsAlreadyWritten = false;
-		    if (currentObjectStreamClass.hasWriteMethod ())
+		    if (currentObjectStreamClass.hasWriteMethod())
 		      {
-			setBlockDataMode (true);
-			callWriteMethod (obj, currentObjectStreamClass);
-			setBlockDataMode (false);
-			realOutput.writeByte (TC_ENDBLOCKDATA);
+			setBlockDataMode(true);
+			callWriteMethod(obj, currentObjectStreamClass);
+			setBlockDataMode(false);
+			realOutput.writeByte(TC_ENDBLOCKDATA);
 		      }
 		    else
-		      writeFields (obj, currentObjectStreamClass);
+		      writeFields(obj, currentObjectStreamClass);
 		  }
 
 		currentObject = null;
@@ -341,7 +341,7 @@ public class ObjectOutputStream extends OutputStream
 		break;
 	      }
 
-	    throw new NotSerializableException (clazz.getName ());
+	    throw new NotSerializableException(clazz.getName ());
 	  } // end pseudo-loop
       }
     catch (ObjectStreamException ose)
@@ -351,243 +351,247 @@ public class ObjectOutputStream extends OutputStream
       }
     catch (IOException e)
       {
-	realOutput.writeByte (TC_EXCEPTION);
-	reset (true);
+	realOutput.writeByte(TC_EXCEPTION);
+	reset(true);
 
-	setBlockDataMode (false);
+	setBlockDataMode(false);
 	try
 	  {
-	    writeObject (e);
+	    writeObject(e);
 	  }
 	catch (IOException ioe)
 	  {
-	    throw new StreamCorruptedException ("Exception " + ioe + " thrown while exception ("+e+") was being written to stream.");
+	    throw new StreamCorruptedException
+	      ("Exception " + ioe + " thrown while exception was being written to stream.");
 	  }
 
 	reset (true);
+	
       }
     finally
       {
 	isSerializing = was_serializing;
-	setBlockDataMode (old_mode);
+	setBlockDataMode(old_mode);
       }
   }
 
-  protected void writeClassDescriptor (ObjectStreamClass osc) throws IOException
+  protected void writeClassDescriptor(ObjectStreamClass osc) throws IOException
   {
-    realOutput.writeByte (TC_CLASSDESC);
-    realOutput.writeUTF (osc.getName ());
-    realOutput.writeLong (osc.getSerialVersionUID ());
-    assignNewHandle (osc);
+    realOutput.writeByte(TC_CLASSDESC);
+    realOutput.writeUTF(osc.getName());
+    realOutput.writeLong(osc.getSerialVersionUID());
+    assignNewHandle(osc);
 
-    int flags = osc.getFlags ();
+    int flags = osc.getFlags();
 
     if (protocolVersion == PROTOCOL_VERSION_2
-	&& osc.isExternalizable ())
+	&& osc.isExternalizable())
       flags |= SC_BLOCK_DATA;
 
-    realOutput.writeByte (flags);
+    realOutput.writeByte(flags);
 
     ObjectStreamField[] fields = osc.fields;
-    realOutput.writeShort (fields.length);
+    realOutput.writeShort(fields.length);
 
     ObjectStreamField field;
-    for (int i=0; i < fields.length; i++)
+    for (int i = 0; i < fields.length; i++)
       {
 	field = fields[i];
-	realOutput.writeByte (field.getTypeCode ());
-	realOutput.writeUTF (field.getName ());
+	realOutput.writeByte(field.getTypeCode ());
+	realOutput.writeUTF(field.getName ());
 
-	if (! field.isPrimitive ())
-	  writeObject (field.getTypeString ());
+	if (! field.isPrimitive())
+	  writeObject(field.getTypeString());
       }
 
-    boolean oldmode = setBlockDataMode (true);
-    annotateClass (osc.forClass ());
-    setBlockDataMode (oldmode);
-    realOutput.writeByte (TC_ENDBLOCKDATA);
+    boolean oldmode = setBlockDataMode(true);
+    annotateClass(osc.forClass());
+    setBlockDataMode(oldmode);
+    realOutput.writeByte(TC_ENDBLOCKDATA);
 
-    if (osc.isSerializable()
-	|| osc.isExternalizable())
-      writeObject (osc.getSuper ());
+    if (osc.isSerializable() || osc.isExternalizable())
+      writeObject(osc.getSuper());
     else
-      writeObject (null);
+      writeObject(null);
   }
   
   /**
-     Writes the current objects non-transient, non-static fields from
-     the current class to the underlying output stream.
-
-     This method is intended to be called from within a object's
-     <code>private void writeObject (ObjectOutputStream)</code>
-     method.
-
-     @exception NotActiveException This method was called from a
-     context other than from the current object's and current class's
-     <code>private void writeObject (ObjectOutputStream)</code>
-     method.
-
-     @exception IOException Exception from underlying
-     <code>OutputStream</code>.
-  */
-  public void defaultWriteObject ()
+   * Writes the current objects non-transient, non-static fields from
+   * the current class to the underlying output stream.
+   *
+   * This method is intended to be called from within a object's
+   * <code>private void writeObject (ObjectOutputStream)</code>
+   * method.
+   *
+   * @exception NotActiveException This method was called from a
+   * context other than from the current object's and current class's
+   * <code>private void writeObject (ObjectOutputStream)</code>
+   * method.
+   *
+   * @exception IOException Exception from underlying
+   * <code>OutputStream</code>.
+   */
+  public void defaultWriteObject()
     throws IOException, NotActiveException
   {
-    markFieldsWritten ();
-    writeFields (currentObject, currentObjectStreamClass);
+    markFieldsWritten();
+    writeFields(currentObject, currentObjectStreamClass);
   }
 
 
-  private void markFieldsWritten () throws IOException
+  private void markFieldsWritten() throws IOException
   {
     if (currentObject == null || currentObjectStreamClass == null)
-      throw new NotActiveException ("defaultWriteObject called by non-active class and/or object");
+      throw new NotActiveException
+	("defaultWriteObject called by non-active class and/or object");
 
     if (fieldsAlreadyWritten)
-      throw new IOException ("Only one of writeFields and defaultWriteObject may be called, and it may only be called once");
+      throw new IOException
+	("Only one of putFields and defaultWriteObject may be called, and it may only be called once");
 
     fieldsAlreadyWritten = true;
   }
 
-
   /**
-     Resets stream to state equivalent to the state just after it was
-     constructed.
-
-     Causes all objects previously written to the stream to be
-     forgotten.  A notification of this reset is also written to the
-     underlying stream.
-
-     @exception IOException Exception from underlying
-     <code>OutputStream</code> or reset called while serialization is
-     in progress.
-  */
-  public void reset () throws IOException
+   * Resets stream to state equivalent to the state just after it was
+   * constructed.
+   *
+   * Causes all objects previously written to the stream to be
+   * forgotten.  A notification of this reset is also written to the
+   * underlying stream.
+   *
+   * @exception IOException Exception from underlying
+   * <code>OutputStream</code> or reset called while serialization is
+   * in progress.
+   */
+  public void reset() throws IOException
   {
-    reset (false);
+    reset(false);
   }
 
 
-  private void reset (boolean internal) throws IOException
+  private void reset(boolean internal) throws IOException
   {
     if (!internal)
       {
 	if (isSerializing)
-	  throw new IOException ("Reset called while serialization in progress");
+	  throw new IOException("Reset called while serialization in progress");
 
-	realOutput.writeByte (TC_RESET);
+	realOutput.writeByte(TC_RESET);
       }
-
-    clearHandles ();
+    
+    clearHandles();
   }
 
 
   /**
-     Informs this <code>ObjectOutputStream</code> to write data
-     according to the specified protocol.  There are currently two
-     different protocols, specified by <code>PROTOCOL_VERSION_1</code>
-     and <code>PROTOCOL_VERSION_2</code>.  This implementation writes
-     data using <code>PROTOCOL_VERSION_2</code> by default, as is done
-     by the JDK 1.2.
-
-     A non-portable method, <code>setDefaultProtocolVersion (int
-     version)</code> is provided to change the default protocol
-     version.
-
-     For an explination of the differences beween the two protocols
-     see XXX: the Java ObjectSerialization Specification.
-
-     @exception IOException if <code>version</code> is not a valid
-     protocol
-
-     @see #setDefaultProtocolVersion(int)
-  */
-  public void useProtocolVersion (int version) throws IOException
+   * Informs this <code>ObjectOutputStream</code> to write data
+   * according to the specified protocol.  There are currently two
+   * different protocols, specified by <code>PROTOCOL_VERSION_1</code>
+   * and <code>PROTOCOL_VERSION_2</code>.  This implementation writes
+   * data using <code>PROTOCOL_VERSION_2</code> by default, as is done
+   * by the JDK 1.2.
+   *
+   * A non-portable method, <code>setDefaultProtocolVersion (int
+   * version)</code> is provided to change the default protocol
+   * version.
+   *
+   * For an explination of the differences beween the two protocols
+   * see XXX: the Java ObjectSerialization Specification.
+   *
+   * @exception IOException if <code>version</code> is not a valid
+   * protocol
+   *
+   * @see #setDefaultProtocolVersion(int)
+   */
+  public void useProtocolVersion(int version) throws IOException
   {
     if (version != PROTOCOL_VERSION_1 && version != PROTOCOL_VERSION_2)
-      throw new IOException ("Invalid protocol version requested.");
-
+      throw new IOException("Invalid protocol version requested.");
+    
     protocolVersion = version;
   }
 
 
   /**
-     <em>GNU $classpath specific</em>
-
-     Changes the default stream protocol used by all
-     <code>ObjectOutputStream</code>s.  There are currently two
-     different protocols, specified by <code>PROTOCOL_VERSION_1</code>
-     and <code>PROTOCOL_VERSION_2</code>.  The default default is
-     <code>PROTOCOL_VERSION_1</code>.
-
-     @exception IOException if <code>version</code> is not a valid
-     protocol
-
-     @see #useProtocolVersion(int)
-  */
-  public static void setDefaultProtocolVersion (int version)
+   * <em>GNU $classpath specific</em>
+   *
+   * Changes the default stream protocol used by all
+   * <code>ObjectOutputStream</code>s.  There are currently two
+   * different protocols, specified by <code>PROTOCOL_VERSION_1</code>
+   * and <code>PROTOCOL_VERSION_2</code>.  The default default is
+   * <code>PROTOCOL_VERSION_1</code>.
+   *
+   * @exception IOException if <code>version</code> is not a valid
+   * protocol
+   *
+   * @see #useProtocolVersion(int)
+   */
+  public static void setDefaultProtocolVersion(int version)
     throws IOException
   {
     if (version != PROTOCOL_VERSION_1 && version != PROTOCOL_VERSION_2)
-      throw new IOException ("Invalid protocol version requested.");
+      throw new IOException("Invalid protocol version requested.");
 
     defaultProtocolVersion = version;
   }
 
 
   /**
-     An empty hook that allows subclasses to write extra information
-     about classes to the stream.  This method is called the first
-     time each class is seen, and after all of the standard
-     information about the class has been written.
-
-     @exception IOException Exception from underlying
-     <code>OutputStream</code>.
-
-     @see ObjectInputStream#resolveClass(java.io.ObjectStreamClass)
-  */
-  protected void annotateClass (Class cl) throws IOException
-  {}
+   * An empty hook that allows subclasses to write extra information
+   * about classes to the stream.  This method is called the first
+   * time each class is seen, and after all of the standard
+   * information about the class has been written.
+   *
+   * @exception IOException Exception from underlying
+   * <code>OutputStream</code>.
+   *
+   * @see ObjectInputStream#resolveClass(java.io.ObjectStreamClass)
+   */
+  protected void annotateClass(Class cl) throws IOException
+  {
+  }
 
   protected void annotateProxyClass(Class cl) throws IOException
-  {}
+  {
+  }
 
   /**
-     Allows subclasses to replace objects that are written to the
-     stream with other objects to be written in their place.  This
-     method is called the first time each object is encountered
-     (modulo reseting of the stream).
-
-     This method must be enabled before it will be called in the
-     serialization process.
-
-     @exception IOException Exception from underlying
-     <code>OutputStream</code>.
-
-     @see #enableReplaceObject(boolean)
-  */
-  protected Object replaceObject (Object obj) throws IOException
+   * Allows subclasses to replace objects that are written to the
+   * stream with other objects to be written in their place.  This
+   * method is called the first time each object is encountered
+   * (modulo reseting of the stream).
+   *
+   * This method must be enabled before it will be called in the
+   * serialization process.
+   *
+   * @exception IOException Exception from underlying
+   * <code>OutputStream</code>.
+   *
+   * @see #enableReplaceObject(boolean)
+   */
+  protected Object replaceObject(Object obj) throws IOException
   {
     return obj;
   }
 
 
   /**
-     If <code>enable</code> is <code>true</code> and this object is
-     trusted, then <code>replaceObject (Object)</code> will be called
-     in subsequent calls to <code>writeObject (Object)</code>.
-     Otherwise, <code>replaceObject (Object)</code> will not be called.
-
-     @exception SecurityException This class is not trusted.
-  */
-  protected boolean enableReplaceObject (boolean enable)
+   * If <code>enable</code> is <code>true</code> and this object is
+   * trusted, then <code>replaceObject (Object)</code> will be called
+   * in subsequent calls to <code>writeObject (Object)</code>.
+   * Otherwise, <code>replaceObject (Object)</code> will not be called.
+   *
+   * @exception SecurityException This class is not trusted.
+   */
+  protected boolean enableReplaceObject(boolean enable)
     throws SecurityException
   {
     if (enable)
       {
-	SecurityManager sm = System.getSecurityManager ();
+	SecurityManager sm = System.getSecurityManager();
 	if (sm != null)
-	  sm.checkPermission (new SerializablePermission ("enableSubstitution"));
+	  sm.checkPermission(new SerializablePermission("enableSubstitution"));
       }
 
     boolean old_val = replacementEnabled;
@@ -597,20 +601,18 @@ public class ObjectOutputStream extends OutputStream
 
 
   /**
-     Writes stream magic and stream version information to the
-     underlying stream.
-
-     @exception IOException Exception from underlying
-     <code>OutputStream</code>.
-  */
-  protected void writeStreamHeader () throws IOException
+   * Writes stream magic and stream version information to the
+   * underlying stream.
+   *
+   * @exception IOException Exception from underlying
+   * <code>OutputStream</code>.
+   */
+  protected void writeStreamHeader() throws IOException
   {
-    realOutput.writeShort (STREAM_MAGIC);
-    realOutput.writeShort (STREAM_VERSION);
+    realOutput.writeShort(STREAM_MAGIC);
+    realOutput.writeShort(STREAM_VERSION);
   }
 
-
-
   /**
    * Protected constructor that allows subclasses to override
    * serialization.  This constructor should be called by subclasses
@@ -622,11 +624,11 @@ public class ObjectOutputStream extends OutputStream
    *
    * @see #writeObjectOverride(Object)
    */
-  protected ObjectOutputStream () throws IOException, SecurityException
+  protected ObjectOutputStream() throws IOException, SecurityException
   {
     SecurityManager sec_man = System.getSecurityManager ();
     if (sec_man != null)
-      sec_man.checkPermission (SUBCLASS_IMPLEMENTATION_PERMISSION);
+      sec_man.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
     useSubclassMethod = true;
   }
 
@@ -643,10 +645,11 @@ public class ObjectOutputStream extends OutputStream
    * @exception NotActiveException Subclass has arranged for this
    * method to be called, but did not implement this method.
    */
-  protected void writeObjectOverride (Object obj) throws NotActiveException,
+  protected void writeObjectOverride(Object obj) throws NotActiveException,
     IOException
   {
-    throw new NotActiveException ("Subclass of ObjectOutputStream must implement writeObjectOverride");
+    throw new NotActiveException
+      ("Subclass of ObjectOutputStream must implement writeObjectOverride");
   }
 
 
@@ -658,48 +661,48 @@ public class ObjectOutputStream extends OutputStream
     if (writeDataAsBlocks)
       {
 	if (blockDataCount == BUFFER_SIZE)
-	  drain ();
+	  drain();
 
 	blockData[ blockDataCount++ ] = (byte)data;
       }
     else
-      realOutput.write (data);
+      realOutput.write(data);
   }
 
 
   /**
    * @see DataOutputStream#write(byte[])
    */
-  public void write (byte[] b) throws IOException
+  public void write(byte[] b) throws IOException
   {
-    write (b, 0, b.length);
+    write(b, 0, b.length);
   }
 
 
   /**
    * @see DataOutputStream#write(byte[],int,int)
    */
-  public void write (byte[] b, int off, int len) throws IOException
+  public void write(byte[] b, int off, int len) throws IOException
   {
     if (writeDataAsBlocks)
       {
 	if (len < 0)
-	  throw new IndexOutOfBoundsException ();
+	  throw new IndexOutOfBoundsException();
 
 	if (blockDataCount + len < BUFFER_SIZE)
 	  {
-	    System.arraycopy (b, off, blockData, blockDataCount, len);
+	    System.arraycopy(b, off, blockData, blockDataCount, len);
 	    blockDataCount += len;
 	  }
 	else
 	  {
-	    drain ();
-	    writeBlockDataHeader (len);
-	    realOutput.write (b, off, len);
+	    drain();
+	    writeBlockDataHeader(len);
+	    realOutput.write(b, off, len);
 	  }
       }
     else
-      realOutput.write (b, off, len);
+      realOutput.write(b, off, len);
   }
 
 
@@ -708,8 +711,8 @@ public class ObjectOutputStream extends OutputStream
    */
   public void flush () throws IOException
   {
-    drain ();
-    realOutput.flush ();
+    drain();
+    realOutput.flush();
   }
 
 
@@ -720,14 +723,14 @@ public class ObjectOutputStream extends OutputStream
    * @exception IOException Exception from underlying
    * <code>OutputStream</code>.
    */
-  protected void drain () throws IOException
+  protected void drain() throws IOException
   {
     if (blockDataCount == 0)
       return;
 
     if (writeDataAsBlocks)
-      writeBlockDataHeader (blockDataCount);
-    realOutput.write (blockData, 0, blockDataCount);
+      writeBlockDataHeader(blockDataCount);
+    realOutput.write(blockData, 0, blockDataCount);
     blockDataCount = 0;
   }
 
@@ -735,28 +738,28 @@ public class ObjectOutputStream extends OutputStream
   /**
    * @see java.io.DataOutputStream#close ()
    */
-  public void close () throws IOException
+  public void close() throws IOException
   {
-    flush ();
-    realOutput.close ();
+    flush();
+    realOutput.close();
   }
 
 
   /**
    * @see java.io.DataOutputStream#writeBoolean (boolean)
    */
-  public void writeBoolean (boolean data) throws IOException
+  public void writeBoolean(boolean data) throws IOException
   {
-    blockDataOutput.writeBoolean (data);
+    blockDataOutput.writeBoolean(data);
   }
 
 
   /**
    * @see java.io.DataOutputStream#writeByte (int)
    */
-  public void writeByte (int data) throws IOException
+  public void writeByte(int data) throws IOException
   {
-    blockDataOutput.writeByte (data);
+    blockDataOutput.writeByte(data);
   }
 
 
@@ -765,79 +768,79 @@ public class ObjectOutputStream extends OutputStream
    */
   public void writeShort (int data) throws IOException
   {
-    blockDataOutput.writeShort (data);
+    blockDataOutput.writeShort(data);
   }
 
 
   /**
    * @see java.io.DataOutputStream#writeChar (int)
    */
-  public void writeChar (int data) throws IOException
+  public void writeChar(int data) throws IOException
   {
-    blockDataOutput.writeChar (data);
+    blockDataOutput.writeChar(data);
   }
 
 
   /**
    * @see java.io.DataOutputStream#writeInt (int)
    */
-  public void writeInt (int data) throws IOException
+  public void writeInt(int data) throws IOException
   {
-    blockDataOutput.writeInt (data);
+    blockDataOutput.writeInt(data);
   }
 
 
   /**
    * @see java.io.DataOutputStream#writeLong (long)
    */
-  public void writeLong (long data) throws IOException
+  public void writeLong(long data) throws IOException
   {
-    blockDataOutput.writeLong (data);
+    blockDataOutput.writeLong(data);
   }
 
 
   /**
    * @see java.io.DataOutputStream#writeFloat (float)
    */
-  public void writeFloat (float data) throws IOException
+  public void writeFloat(float data) throws IOException
   {
-    blockDataOutput.writeFloat (data);
+    blockDataOutput.writeFloat(data);
   }
 
 
   /**
    * @see java.io.DataOutputStream#writeDouble (double)
    */
-  public void writeDouble (double data) throws IOException
+  public void writeDouble(double data) throws IOException
   {
-    blockDataOutput.writeDouble (data);
+    blockDataOutput.writeDouble(data);
   }
 
 
   /**
    * @see java.io.DataOutputStream#writeBytes (java.lang.String)
    */
-  public void writeBytes (String data) throws IOException
+  public void writeBytes(String data) throws IOException
   {
-    blockDataOutput.writeBytes (data);
+    blockDataOutput.writeBytes(data);
   }
 
 
   /**
    * @see java.io.DataOutputStream#writeChars (java.lang.String)
    */
-  public void writeChars (String data) throws IOException
+  public void writeChars(String data) throws IOException
   {
-    dataOutput.writeChars (data);
+    dataOutput.writeChars(data);
   }
 
 
   /**
    * @see java.io.DataOutputStream#writeUTF (java.lang.String)
    */
-  public void writeUTF (String data) throws IOException
+  public void writeUTF(String data) throws IOException
   {
-    dataOutput.writeUTF (data);
+    dataOutput.writeUTF(data);
   }
 
 
@@ -865,7 +868,7 @@ public class ObjectOutputStream extends OutputStream
     public abstract void write (ObjectOutput out) throws IOException;
   }
 
-  public PutField putFields () throws IOException
+  public PutField putFields() throws IOException
   {
     if (currentPutField == null)
       {
@@ -1008,183 +1011,184 @@ public class ObjectOutputStream extends OutputStream
   }
 
 
-  public void writeFields () throws IOException
+  public void writeFields() throws IOException
   {
     if (currentPutField == null)
-      throw new NotActiveException ("writeFields can only be called after putFields has been called");
+      throw new NotActiveException("writeFields can only be called after putFields has been called");
 
     // putFields may be called more than once, but not writeFields.
     markFieldsWritten();
 
-    currentPutField.write (this);
+    currentPutField.write(this);
     currentPutField = null;
   }
 
 
   // write out the block-data buffer, picking the correct header
   // depending on the size of the buffer
-  private void writeBlockDataHeader (int size) throws IOException
+  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);
       }
   }
 
 
   // lookup the handle for OBJ, return null if OBJ doesn't have a
   // handle yet
-  private Integer findHandle (Object obj)
+  private Integer findHandle(Object obj)
   {
-    return (Integer)OIDLookupTable.get (new ObjectIdentityWrapper (obj));
+    return (Integer)OIDLookupTable.get(new ObjectIdentityWrapper(obj));
   }
 
 
   // assigns the next availible handle to OBJ
-  private int assignNewHandle (Object obj)
+  private int assignNewHandle(Object obj)
   {
-    OIDLookupTable.put (new ObjectIdentityWrapper (obj),
-			new Integer (nextOID));
+    OIDLookupTable.put(new ObjectIdentityWrapper(obj),
+		       new Integer(nextOID));
     return nextOID++;
   }
 
 
   // resets mapping from objects to handles
-  private void clearHandles ()
+  private void clearHandles()
   {
     nextOID = baseWireHandle;
-    OIDLookupTable.clear ();
+    OIDLookupTable.clear();
   }
 
 
   // write out array size followed by each element of the array
-  private void writeArraySizeAndElements (Object array, Class clazz)
+  private void writeArraySizeAndElements(Object array, Class clazz)
     throws IOException
   {
-    int length = Array.getLength (array);
+    int length = Array.getLength(array);
 
-    if (clazz.isPrimitive ())
+    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]);
+	    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.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]);
+	    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]);
+	    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]);
+	    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]);
+	    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]);
+	    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]);
+	    for (int i = 0; i < length; i++)
+	      realOutput.writeShort(cast_array[i]);
 	    return;
 	  }
       }
     else
       {
 	Object[] cast_array = (Object[])array;
-	realOutput.writeInt (length);
-	for (int i=0; i < length; i++)
-	  writeObject (cast_array[i]);
+	realOutput.writeInt(length);
+	for (int i = 0; i < length; i++)
+	  writeObject(cast_array[i]);
       }
   }
 
 
   // writes out FIELDS of OBJECT for the specified ObjectStreamClass.
   // FIELDS are already in canonical order.
-  private void writeFields (Object obj, ObjectStreamClass osc)
+  private void writeFields(Object obj, ObjectStreamClass osc)
     throws IOException
   {
     ObjectStreamField[] fields = osc.fields;
-    boolean oldmode = setBlockDataMode (false);
+    boolean oldmode = setBlockDataMode(false);
     String field_name;
     Class type;
-    for (int i=0; i < fields.length; i++)
+
+    for (int i = 0; i < fields.length; i++)
       {
-	field_name = fields[i].getName ();
-	type = fields[i].getType ();
+	field_name = fields[i].getName();
+	type = fields[i].getType();
 
 	if (type == Boolean.TYPE)
-	  realOutput.writeBoolean (getBooleanField (obj, osc.forClass(), field_name));
+	  realOutput.writeBoolean(getBooleanField(obj, osc.forClass(), field_name));
 	else if (type == Byte.TYPE)
-	  realOutput.writeByte (getByteField (obj, osc.forClass(), field_name));
+	  realOutput.writeByte(getByteField(obj, osc.forClass(), field_name));
 	else if (type == Character.TYPE)
-	  realOutput.writeChar (getCharField (obj, osc.forClass(), field_name));
+	  realOutput.writeChar(getCharField(obj, osc.forClass(), field_name));
 	else if (type == Double.TYPE)
-	  realOutput.writeDouble (getDoubleField (obj, osc.forClass(), field_name));
+	  realOutput.writeDouble(getDoubleField(obj, osc.forClass(), field_name));
 	else if (type == Float.TYPE)
-	  realOutput.writeFloat (getFloatField (obj, osc.forClass(), field_name));
+	  realOutput.writeFloat(getFloatField(obj, osc.forClass(), field_name));
 	else if (type == Integer.TYPE)
-	  realOutput.writeInt (getIntField (obj, osc.forClass(), field_name));
+	  realOutput.writeInt(getIntField(obj, osc.forClass(), field_name));
 	else if (type == Long.TYPE)
-	  realOutput.writeLong (getLongField (obj, osc.forClass(), field_name));
+	  realOutput.writeLong(getLongField(obj, osc.forClass(), field_name));
 	else if (type == Short.TYPE)
-	  realOutput.writeShort (getShortField (obj, osc.forClass(), field_name));
+	  realOutput.writeShort(getShortField(obj, osc.forClass(), field_name));
 	else
-	  writeObject (getObjectField (obj, osc.forClass(), field_name,
-				       fields[i].getTypeString ()));
+	  writeObject(getObjectField(obj, osc.forClass(), field_name,
+				     fields[i].getTypeString ()));
       }
-    setBlockDataMode (oldmode);
+    setBlockDataMode(oldmode);
   }
 
 
   // Toggles writing primitive data to block-data buffer.
-  private boolean setBlockDataMode (boolean on) throws IOException
+  private boolean setBlockDataMode(boolean on) throws IOException
   {
     if (on == writeDataAsBlocks)
       return on;
@@ -1202,16 +1206,16 @@ public class ObjectOutputStream extends OutputStream
   }
 
 
-  private void callWriteMethod (Object obj, ObjectStreamClass osc)
+  private void callWriteMethod(Object obj, ObjectStreamClass osc)
     throws IOException
   {
     Class klass = osc.forClass();
     try
       {
 	Class classArgs[] = {ObjectOutputStream.class};
-	Method m = getMethod (klass, "writeObject", classArgs);
+	Method m = getMethod(klass, "writeObject", classArgs);
 	Object args[] = {this};
-	m.invoke (obj, args);	
+	m.invoke(obj, args);	
       }
     catch (NoSuchMethodException nsme)
       {
@@ -1227,34 +1231,34 @@ public class ObjectOutputStream extends OutputStream
 	  throw (IOException) exception;
 
 	IOException ioe
-	  = new IOException ("Exception thrown from writeObject() on " +
-			     klass + ": " + exception.getClass().getName());
+	  = new IOException("Exception thrown from writeObject() on " +
+			    klass + ": " + exception.getClass().getName());
 	ioe.initCause(exception);
 	throw ioe;
       }
     catch (Exception x)
       {
 	IOException ioe
-	  = new IOException ("Failure invoking writeObject() on " +
-			     klass + ": " + x.getClass().getName());
+	  = new IOException("Failure invoking writeObject() on " +
+			    klass + ": " + x.getClass().getName());
 	ioe.initCause(x);
 	throw ioe;
       }
   }
 
-  private boolean getBooleanField (Object obj, Class klass, String field_name)
+  private boolean getBooleanField(Object obj, Class klass, String field_name)
     throws IOException
   {
     try
       {
-	Field f = getField (klass, field_name);
-	boolean b = f.getBoolean (obj);
+	Field f = getField(klass, field_name);
+	boolean b = f.getBoolean(obj);
 	return b;
       }
     catch (Exception _)
       {
-	throw new IOException ("Unexpected Exception "+_);
-      }    
+	throw new IOException("Unexpected exception " + _);
+      }
   }
 
   private byte getByteField (Object obj, Class klass, String field_name)
@@ -1268,7 +1272,7 @@ public class ObjectOutputStream extends OutputStream
       }
     catch (Exception _)
       {
-	throw new IOException ("Unexpected Exception "+_);
+	throw new IOException("Unexpected exception " + _);
       }    
   }
 
@@ -1283,7 +1287,7 @@ public class ObjectOutputStream extends OutputStream
       }
     catch (Exception _)
       {
-	throw new IOException ("Unexpected Exception "+_);
+	throw new IOException("Unexpected exception " + _);
       }    
   }
 
@@ -1298,7 +1302,7 @@ public class ObjectOutputStream extends OutputStream
       }
     catch (Exception _)
       {
-	throw new IOException ("Unexpected Exception "+_);
+	throw new IOException("Unexpected exception " + _);
       }    
   }
 
@@ -1313,8 +1317,8 @@ public class ObjectOutputStream extends OutputStream
       }
     catch (Exception _)
       {
-	throw new IOException ("Unexpected Exception "+_);
-      }    
+	throw new IOException("Unexpected exception " + _);
+      }
   }
 
   private int getIntField (Object obj, Class klass, String field_name)
@@ -1328,8 +1332,8 @@ public class ObjectOutputStream extends OutputStream
       }
     catch (Exception _)
       {
-	throw new IOException ("Unexpected Exception "+_);
-      }    
+	throw new IOException("Unexpected exception " + _);
+      }
   }
 
   private long getLongField (Object obj, Class klass, String field_name)
@@ -1343,7 +1347,7 @@ public class ObjectOutputStream extends OutputStream
       }
     catch (Exception _)
       {
-	throw new IOException ("Unexpected Exception "+_);
+	throw new IOException("Unexpected exception " + _);
       }    
   }
 
@@ -1358,8 +1362,8 @@ public class ObjectOutputStream extends OutputStream
       }
     catch (Exception _)
       {
-	throw new IOException ("Unexpected Exception "+_);
-      }    
+	throw new IOException("Unexpected exception " + _);
+      }
   }
 
   private Object getObjectField (Object obj, Class klass, String field_name,
@@ -1372,9 +1376,9 @@ public class ObjectOutputStream extends OutputStream
 	// FIXME: We should check the type_code here
 	return o;
       }
-    catch (Exception _)
+    catch (Exception e)
       {
-	throw new IOException ("Unexpected Exception "+_);
+	throw new IOException ();
       }    
   }
 
@@ -1434,7 +1438,7 @@ public class ObjectOutputStream extends OutputStream
   {
     if (Configuration.INIT_LOAD_LIBRARY)
       {
-        System.loadLibrary ("javaio");
+        System.loadLibrary("javaio");
       }
   }
 }