ObjectInputStream.java, [...]: Reformated, no functional code changes.

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.

From-SVN: r75236

1 files changed, 412 insertions, 406 deletions

diff --git a/libjava/java/io/ObjectStreamClass.java b/libjava/java/io/ObjectStreamClass.java
index 9d9d99d..5bd0e68 100644
--- a/libjava/java/io/ObjectStreamClass.java
+++ b/libjava/java/io/ObjectStreamClass.java
@@ -2,39 +2,39 @@
    about serialized objects.
    Copyright (C) 1998, 1999, 2000, 2001, 2003  Free Software Foundation, Inc.
 
-This file is part of GNU Classpath.
+   This file is part of GNU Classpath.
 
-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 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
-General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with GNU Classpath; see the file COPYING.  If not, write to the
-Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-02111-1307 USA.
-
-Linking this library statically or dynamically with other modules is
-making a combined work based on this library.  Thus, the terms and
-conditions of the GNU General Public License cover the whole
-combination.
-
-As a special exception, the copyright holders of this library give you
-permission to link this library with independent modules to produce an
-executable, regardless of the license terms of these independent
-modules, and to copy and distribute the resulting executable under
-terms of your choice, provided that you also meet, for each linked
-independent module, the terms and conditions of the license of that
-module.  An independent module is a module which is not derived from
-or based on this library.  If you modify this library, you may extend
-this exception to your version of the library, but you are not
-obligated to do so.  If you do not wish to do so, delete this
-exception statement from your 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
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with GNU Classpath; see the file COPYING.  If not, write to the
+   Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.
+
+   Linking this library statically or dynamically with other modules is
+   making a combined work based on this library.  Thus, the terms and
+   conditions of the GNU General Public License cover the whole
+   combination.
+
+   As a special exception, the copyright holders of this library give you
+   permission to link this library with independent modules to produce an
+   executable, regardless of the license terms of these independent
+   modules, and to copy and distribute the resulting executable under
+   terms of your choice, provided that you also meet, for each linked
+   independent module, the terms and conditions of the license of that
+   module.  An independent module is a module which is not derived from
+   or based on this library.  If you modify this library, you may extend
+   this exception to your version of the library, but you are not
+   obligated to do so.  If you do not wish to do so, delete this
+   exception statement from your version. */
 
 
 package java.io;
@@ -61,23 +61,23 @@ import gnu.java.security.provider.Gnu;
 public class ObjectStreamClass implements Serializable
 {
   /**
-     Returns the <code>ObjectStreamClass</code> for <code>cl</code>.
-     If <code>cl</code> is null, or is not <code>Serializable</code>,
-     null is returned.  <code>ObjectStreamClass</code>'s are memorized;
-     later calls to this method with the same class will return the
-     same <code>ObjectStreamClass</code> object and no recalculation
-     will be done.
-
-     @see java.io.Serializable
-  */
-  public static ObjectStreamClass lookup (Class cl)
+   * Returns the <code>ObjectStreamClass</code> for <code>cl</code>.
+   * If <code>cl</code> is null, or is not <code>Serializable</code>,
+   * null is returned.  <code>ObjectStreamClass</code>'s are memorized;
+   * later calls to this method with the same class will return the
+   * same <code>ObjectStreamClass</code> object and no recalculation
+   * will be done.
+   *
+   * @see java.io.Serializable
+   */
+  public static ObjectStreamClass lookup(Class cl)
   {
     if (cl == null)
       return null;
-    if (! (Serializable.class).isAssignableFrom (cl))
+    if (! (Serializable.class).isAssignableFrom(cl))
       return null;
 
-    return lookupForClassObject (cl);
+    return lookupForClassObject(cl);
   }
 
   /**
@@ -85,57 +85,57 @@ public class ObjectStreamClass implements Serializable
    * we have a java.lang.Class object C for class A, though A is not
    * serializable, but it's okay to serialize C.
    */
-  static ObjectStreamClass lookupForClassObject (Class cl)
+  static ObjectStreamClass lookupForClassObject(Class cl)
   {
     if (cl == null)
       return null;
 
-    ObjectStreamClass osc = (ObjectStreamClass)classLookupTable.get (cl);
+    ObjectStreamClass osc = (ObjectStreamClass) classLookupTable.get(cl);
 
     if (osc != null)
       return osc;
     else
-    {
-      osc = new ObjectStreamClass (cl);
-      classLookupTable.put (cl, osc);
-      return osc;
-    }
+      {
+	osc = new ObjectStreamClass(cl);
+	classLookupTable.put(cl, osc);
+	return osc;
+      }
   }
 
 
   /**
-     Returns the name of the class that this
-     <code>ObjectStreamClass</code> represents.
-  */
-  public String getName ()
+   * Returns the name of the class that this
+   * <code>ObjectStreamClass</code> represents.
+   */
+  public String getName()
   {
     return name;
   }
 
 
   /**
-     Returns the class that this <code>ObjectStreamClass</code>
-     represents.  Null could be returned if this
-     <code>ObjectStreamClass</code> was read from an
-     <code>ObjectInputStream</code> and the class it represents cannot
-     be found or loaded.
-
-     @see java.io.ObjectInputStream
-  */
-  public Class forClass ()
+   * Returns the class that this <code>ObjectStreamClass</code>
+   * represents.  Null could be returned if this
+   * <code>ObjectStreamClass</code> was read from an
+   * <code>ObjectInputStream</code> and the class it represents cannot
+   * be found or loaded.
+   *
+   * @see java.io.ObjectInputStream
+   */
+  public Class forClass()
   {
     return clazz;
   }
 
 
   /**
-     Returns the serial version stream-unique identifier for the class
-     represented by this <code>ObjectStreamClass</code>.  This SUID is
-     either defined by the class as <code>static final long
-     serialVersionUID</code> or is calculated as specified in
-     Javasoft's "Object Serialization Specification" XXX: add reference
-  */
-  public long getSerialVersionUID ()
+   * Returns the serial version stream-unique identifier for the class
+   * represented by this <code>ObjectStreamClass</code>.  This SUID is
+   * either defined by the class as <code>static final long
+   * serialVersionUID</code> or is calculated as specified in
+   * Javasoft's "Object Serialization Specification" XXX: add reference
+   */
+  public long getSerialVersionUID()
   {
     return uid;
   }
@@ -145,10 +145,10 @@ public class ObjectStreamClass implements Serializable
   // of the class represented by this ObjectStreamClass.  The Fields
   // are sorted by name.
   // XXX doc
-  public ObjectStreamField[] getFields ()
+  public ObjectStreamField[] getFields()
   {
     ObjectStreamField[] copy = new ObjectStreamField[ fields.length ];
-    System.arraycopy (fields, 0, copy, 0, fields.length);
+    System.arraycopy(fields, 0, copy, 0, fields.length);
     return copy;
   }
 
@@ -158,8 +158,8 @@ public class ObjectStreamClass implements Serializable
   // primitiveness.
   public ObjectStreamField getField (String name)
   {
-    for (int i=0; i < fields.length; i++)
-      if (fields[i].getName ().equals (name))
+    for (int i = 0; i < fields.length; i++)
+      if (fields[i].getName().equals(name))
 	return fields[i];
     return null;
   }
@@ -174,7 +174,7 @@ public class ObjectStreamClass implements Serializable
    * @see #getSerialVersionUID()
    * @see #getName()
    */
-  public String toString ()
+  public String toString()
   {
     return "java.io.ObjectStreamClass< " + name + ", " + uid + " >";
   }
@@ -187,7 +187,7 @@ public class ObjectStreamClass implements Serializable
   //
   // This method is used by the class to override default
   // serialization behavior.
-  boolean hasWriteMethod ()
+  boolean hasWriteMethod()
   {
     return (flags & ObjectStreamConstants.SC_WRITE_METHOD) != 0;
   }
@@ -200,24 +200,24 @@ public class ObjectStreamClass implements Serializable
   //
   // This method is used by the class to override default
   // serialization behavior.
-  boolean hasReadMethod ()
+  boolean hasReadMethod()
   {
-      try
+    try
       {
-	  Class[] readObjectParams = { ObjectInputStream.class };
-	  forClass ().getDeclaredMethod ("readObject", readObjectParams);
-	  return true;
+	Class[] readObjectParams = { ObjectInputStream.class };
+	forClass().getDeclaredMethod("readObject", readObjectParams);
+	return true;
       }
-      catch (NoSuchMethodException e)
+    catch (NoSuchMethodException e)
       {
-	  return false;
+	return false;
       }
   }
 
 
   // Returns true iff the class that this ObjectStreamClass represents
   // implements Serializable but does *not* implement Externalizable.
-  boolean isSerializable ()
+  boolean isSerializable()
   {
     return (flags & ObjectStreamConstants.SC_SERIALIZABLE) != 0;
   }
@@ -225,7 +225,7 @@ public class ObjectStreamClass implements Serializable
 
   // Returns true iff the class that this ObjectStreamClass represents
   // implements Externalizable.
-  boolean isExternalizable ()
+  boolean isExternalizable()
   {
     return (flags & ObjectStreamConstants.SC_EXTERNALIZABLE) != 0;
   }
@@ -235,7 +235,7 @@ public class ObjectStreamClass implements Serializable
   // class that is the superclass of the class this
   // <code>ObjectStreamClass</code> represents.  If the superclass is
   // not Serializable, null is returned.
-  ObjectStreamClass getSuper ()
+  ObjectStreamClass getSuper()
   {
     return superClass;
   }
@@ -245,30 +245,30 @@ public class ObjectStreamClass implements Serializable
   // classes of CLAZZ and CLAZZ itself in order from most super to
   // CLAZZ.  ObjectStreamClass[0] is the highest superclass of CLAZZ
   // that is serializable.
-  static ObjectStreamClass[] getObjectStreamClasses (Class clazz)
+  static ObjectStreamClass[] getObjectStreamClasses(Class clazz)
   {
-    ObjectStreamClass osc = ObjectStreamClass.lookup (clazz);
+    ObjectStreamClass osc = ObjectStreamClass.lookup(clazz);
 
     if (osc == null)
       return new ObjectStreamClass[0];
     else
-    {
-      Vector oscs = new Vector ();
-
-      while (osc != null)
       {
-	oscs.addElement (osc);
-	osc = osc.getSuper ();
-      }
+	Vector oscs = new Vector();
 
-      int count = oscs.size ();
-      ObjectStreamClass[] sorted_oscs = new ObjectStreamClass[ count ];
+	while (osc != null)
+	  {
+	    oscs.addElement (osc);
+	    osc = osc.getSuper();
+	  }
+
+	int count = oscs.size();
+	ObjectStreamClass[] sorted_oscs = new ObjectStreamClass[ count ];
 
-      for (int i = count - 1; i >= 0; i--)
-	sorted_oscs[ count - i - 1 ] = (ObjectStreamClass)oscs.elementAt (i);
+	for (int i = count - 1; i >= 0; i--)
+	  sorted_oscs[ count - i - 1 ] = (ObjectStreamClass) oscs.elementAt(i);
 
-      return sorted_oscs;
-    }
+	return sorted_oscs;
+      }
   }
 
 
@@ -276,14 +276,14 @@ public class ObjectStreamClass implements Serializable
   // properties of the class represented by this ObjectStreamClass.
   // The bit-flags that could be present are those defined in
   // ObjectStreamConstants that begin with `SC_'
-  int getFlags ()
+  int getFlags()
   {
     return flags;
   }
 
 
-  ObjectStreamClass (String name, long uid, byte flags,
-		     ObjectStreamField[] fields)
+  ObjectStreamClass(String name, long uid, byte flags,
+		    ObjectStreamField[] fields)
   {
     this.name = name;
     this.uid = uid;
@@ -302,11 +302,11 @@ public class ObjectStreamClass implements Serializable
    * @throws InvalidClassException if an incompatibility between computed UID and
    * already set UID is found.
    */
-  void setClass (Class cl, ObjectStreamClass superClass) throws InvalidClassException
+  void setClass(Class cl, ObjectStreamClass superClass) throws InvalidClassException
   {
     this.clazz = cl;
 
-    long class_uid = getClassUID (cl);
+    long class_uid = getClassUID(cl);
     if (uid == 0)
       uid = class_uid;
     else
@@ -322,87 +322,89 @@ public class ObjectStreamClass implements Serializable
 	  }
       }
 
-    isProxyClass = clazz != null && Proxy.isProxyClass (clazz);
+    isProxyClass = clazz != null && Proxy.isProxyClass(clazz);
     this.superClass = superClass;
-    calculateOffsets ();
-
+    calculateOffsets();
+    
     try
       {
-        ObjectStreamField[] exportedFields = getSerialPersistentFields (clazz);
-
-        if (exportedFields == null)
-          return;
-
-        ObjectStreamField[] newFieldList = new ObjectStreamField[exportedFields.length + fields.length];
-        int i, j, k;
-
-        /* We now check the import fields against the exported fields.
-         * There should not be contradiction (e.g. int x and String x)
-         * but extra virtual fields can be added to the class.
-         */
-
-        Arrays.sort(exportedFields);
-
-        i = 0; j = 0; k = 0;
-        while (i < fields.length && j < exportedFields.length)
-          {
-            int comp = fields[i].getName().compareTo (exportedFields[j].getName());
-            if (comp < 0)
-              {
-                newFieldList[k] = fields[i];
-                fields[i].setPersistent(false);
-                fields[i].setToSet(false);
-                i++;
-              }
-            else if (comp > 0)
-              {
-                /* field not found in imported fields. We add it
-                 * in the list of supported fields.
-                 */
-                newFieldList[k] = exportedFields[j];
-                newFieldList[k].setPersistent(true);
-                newFieldList[k].setToSet(false);
-                j++;
-              }
-            else
-              {
-                if (!fields[i].getType().equals (exportedFields[j].getType()))
-                  throw new InvalidClassException ("serialPersistentFields must be compatible with" +
-                                                   " imported fields (about " + fields[i].getName() + ")");
-                newFieldList[k] = fields[i];
-                fields[i].setPersistent(true);
-                i++;
-                j++;
-              }
-            k++;
-          }
-
-        if (i < fields.length)
-          for (; i < fields.length; i++, k++)
-            {
-              fields[i].setPersistent(false);
-              fields[i].setToSet(false);
-              newFieldList[k] = fields[i];
-            }
-          else
-            if (j < exportedFields.length)
-              for (; j < exportedFields.length; j++, k++)
-                {
-                  exportedFields[j].setPersistent(true);
-                  exportedFields[j].setToSet(false);
-                  newFieldList[k] = exportedFields[j];
-               }
-
-        fields = new ObjectStreamField[k];
-        System.arraycopy (newFieldList, 0, fields, 0, k);
+	ObjectStreamField[] exportedFields = getSerialPersistentFields (clazz);  
+
+	if (exportedFields == null)
+	  return;
+
+	ObjectStreamField[] newFieldList = new ObjectStreamField[exportedFields.length + fields.length];
+	int i, j, k;
+
+	/* We now check the import fields against the exported fields.
+	 * There should not be contradiction (e.g. int x and String x)
+	 * but extra virtual fields can be added to the class.
+	 */
+
+	Arrays.sort(exportedFields);
+
+	i = 0; j = 0; k = 0;
+	while (i < fields.length && j < exportedFields.length)
+	  {
+	    int comp = fields[i].getName().compareTo(exportedFields[j].getName());
+
+	    if (comp < 0)
+	      {
+		newFieldList[k] = fields[i];
+		fields[i].setPersistent(false);
+		fields[i].setToSet(false);
+		i++;
+	      }
+	    else if (comp > 0)
+	      {
+		/* field not found in imported fields. We add it
+		 * in the list of supported fields.
+		 */
+		newFieldList[k] = exportedFields[j];
+		newFieldList[k].setPersistent(true);
+		newFieldList[k].setToSet(false);
+		j++;
+	      }
+	    else
+	      {
+		if (!fields[i].getType().equals(exportedFields[j].getType()))
+		  throw new InvalidClassException
+		    ("serialPersistentFields must be compatible with" +
+		     " imported fields (about " + fields[i].getName() + ")");
+		newFieldList[k] = fields[i];
+		fields[i].setPersistent(true);
+		i++;
+		j++;
+	      }
+	    k++;
+	  }
+
+	if (i < fields.length)
+	  for (;i<fields.length;i++,k++)
+	    {
+	      fields[i].setPersistent(false);
+	      fields[i].setToSet(false);
+	      newFieldList[k] = fields[i];
+	    }
+	else
+	  if (j < exportedFields.length)
+	    for (;j<exportedFields.length;j++,k++)
+	      {
+		exportedFields[j].setPersistent(true);
+		exportedFields[j].setToSet(false);
+		newFieldList[k] = exportedFields[j];
+	      }
+	
+	fields = new ObjectStreamField[k];
+	System.arraycopy(newFieldList, 0, fields, 0, k);
       }
     catch (NoSuchFieldException ignore)
       {
-        return;
+	return;
       }
     catch (IllegalAccessException ignore)
       {
-        return;
+	return;
       }
   }
 
@@ -411,296 +413,300 @@ public class ObjectStreamClass implements Serializable
     superClass = osc;
   }
 
-
-  void calculateOffsets ()
+  void calculateOffsets()
   {
     int i;
     ObjectStreamField field;
     primFieldSize = 0;
     int fcount = fields.length;
     for (i = 0; i < fcount; ++ i)
-    {
-      field = fields[i];
-
-      if (! field.isPrimitive ())
-	break;
-
-      field.setOffset (primFieldSize);
-      switch (field.getTypeCode ())
       {
-	case 'B':
-	case 'Z':
-	  ++ primFieldSize;
-	  break;
-	case 'C':
-	case 'S':
-	  primFieldSize += 2;
-	  break;
-	case 'I':
-	case 'F':
-	  primFieldSize += 4;
-	  break;
-	case 'D':
-	case 'J':
-	  primFieldSize += 8;
+	field = fields[i];
+
+	if (! field.isPrimitive())
 	  break;
+
+	field.setOffset(primFieldSize);
+	switch (field.getTypeCode())
+	  {
+	  case 'B':
+	  case 'Z':
+	    ++ primFieldSize;
+	    break;
+	  case 'C':
+	  case 'S':
+	    primFieldSize += 2;
+	    break;
+	  case 'I':
+	  case 'F':
+	    primFieldSize += 4;
+	    break;
+	  case 'D':
+	  case 'J':
+	    primFieldSize += 8;
+	    break;
+	  }
       }
-    }
 
     for (objectFieldCount = 0; i < fcount; ++ i)
-      fields[i].setOffset (objectFieldCount++);
+      fields[i].setOffset(objectFieldCount++);
   }
 
 
-  private ObjectStreamClass (Class cl)
+  private ObjectStreamClass(Class cl)
   {
     uid = 0;
     flags = 0;
-    isProxyClass = Proxy.isProxyClass (cl);
+    isProxyClass = Proxy.isProxyClass(cl);
 
     clazz = cl;
-    name = cl.getName ();
-    setFlags (cl);
-    setFields (cl);
+    name = cl.getName();
+    setFlags(cl);
+    setFields(cl);
     // to those class nonserializable, its uid field is 0
-    if ( (Serializable.class).isAssignableFrom (cl) && !isProxyClass)
-      uid = getClassUID (cl);
-    superClass = lookup (cl.getSuperclass ());
+    if ( (Serializable.class).isAssignableFrom(cl) && !isProxyClass)
+      uid = getClassUID(cl);
+    superClass = lookup(cl.getSuperclass());
   }
 
 
   // Sets bits in flags according to features of CL.
-  private void setFlags (Class cl)
+  private void setFlags(Class cl)
   {
-    if ((java.io.Externalizable.class).isAssignableFrom (cl))
+    if ((java.io.Externalizable.class).isAssignableFrom(cl))
       flags |= ObjectStreamConstants.SC_EXTERNALIZABLE;
-    else if ((java.io.Serializable.class).isAssignableFrom (cl))
+    else if ((java.io.Serializable.class).isAssignableFrom(cl))
       // only set this bit if CL is NOT Externalizable
       flags |= ObjectStreamConstants.SC_SERIALIZABLE;
 
     try
-    {
-      Method writeMethod = cl.getDeclaredMethod ("writeObject",
-						 writeMethodArgTypes);
-      int modifiers = writeMethod.getModifiers ();
-
-      if (writeMethod.getReturnType () == Void.TYPE
-	  && Modifier.isPrivate (modifiers)
-	  && !Modifier.isStatic (modifiers))
-	flags |= ObjectStreamConstants.SC_WRITE_METHOD;
-    }
-    catch (NoSuchMethodException oh_well)
-    {}
+      {
+	Method writeMethod = cl.getDeclaredMethod("writeObject",
+						  writeMethodArgTypes);
+	int modifiers = writeMethod.getModifiers();
+
+	if (writeMethod.getReturnType() == Void.TYPE
+	    && Modifier.isPrivate(modifiers)
+	    && !Modifier.isStatic(modifiers))
+	  flags |= ObjectStreamConstants.SC_WRITE_METHOD;
+      }
+    catch(NoSuchMethodException oh_well)
+      {
+      }
   }
 
 
   // Sets fields to be a sorted array of the serializable fields of
   // clazz.
-  private void setFields (Class cl)
+  private void setFields(Class cl)
   {
-    if (! isSerializable () || isExternalizable ())
-    {
-      fields = NO_FIELDS;
-      return;
-    }
+    if (!isSerializable() || isExternalizable())
+      {
+	fields = NO_FIELDS;
+	return;
+      }
 
     try
-    {
-      Field serialPersistentFields
-	= cl.getDeclaredField ("serialPersistentFields");
-      serialPersistentFields.setAccessible(true);
-      int modifiers = serialPersistentFields.getModifiers ();
-
-      if (Modifier.isStatic (modifiers)
-	  && Modifier.isFinal (modifiers)
-	  && Modifier.isPrivate (modifiers))
       {
-	fields = getSerialPersistentFields (cl);
-	if (fields != null)
+	Field serialPersistentFields =
+	  cl.getDeclaredField("serialPersistentFields");
+	serialPersistentFields.setAccessible(true);
+	int modifiers = serialPersistentFields.getModifiers();
+
+	if (Modifier.isStatic(modifiers)
+	    && Modifier.isFinal(modifiers)
+	    && Modifier.isPrivate(modifiers))
 	  {
-	    Arrays.sort(fields);
-	    calculateOffsets();
-	    return;
+	    fields = getSerialPersistentFields(cl);
+	    if (fields != null)
+	      {
+		Arrays.sort (fields);
+		calculateOffsets();
+		return;
+	      }
 	  }
       }
-    }
     catch (NoSuchFieldException ignore)
-    {}
+      {
+      }
     catch (IllegalAccessException ignore)
       {
       }
 
     int num_good_fields = 0;
-    Field[] all_fields = cl.getDeclaredFields ();
+    Field[] all_fields = cl.getDeclaredFields();
 
     int modifiers;
     // set non-serializable fields to null in all_fields
-    for (int i=0; i < all_fields.length; i++)
-    {
-      modifiers = all_fields[i].getModifiers ();
-      if (Modifier.isTransient (modifiers)
-	  || Modifier.isStatic (modifiers))
-	all_fields[i] = null;
-      else
-	num_good_fields++;
-    }
+    for (int i = 0; i < all_fields.length; i++)
+      {
+	modifiers = all_fields[i].getModifiers();
+	if (Modifier.isTransient(modifiers)
+	    || Modifier.isStatic(modifiers))
+	  all_fields[i] = null;
+	else
+	  num_good_fields++;
+      }
 
     // make a copy of serializable (non-null) fields
     fields = new ObjectStreamField[ num_good_fields ];
-    for (int from=0, to=0; from < all_fields.length; from++)
+    for (int from = 0, to = 0; from < all_fields.length; from++)
       if (all_fields[from] != null)
-      {
-	Field f = all_fields[from];
-	fields[to] = new ObjectStreamField (f.getName (), f.getType ());
-	to++;
-      }
+	{
+	  Field f = all_fields[from];
+	  fields[to] = new ObjectStreamField(f.getName(), f.getType());
+	  to++;
+	}
 
-    Arrays.sort (fields);
-    calculateOffsets ();
+    Arrays.sort(fields);
+    calculateOffsets();
   }
 
   // Returns the serial version UID defined by class, or if that
   // isn't present, calculates value of serial version UID.
-  private long getClassUID (Class cl)
+  private long getClassUID(Class cl)
   {
     try
-    {
-      // Use getDeclaredField rather than getField, since serialVersionUID
-      // may not be public AND we only want the serialVersionUID of this
-      // class, not a superclass or interface.
-      Field suid = cl.getDeclaredField ("serialVersionUID");
-      suid.setAccessible(true);
-      int modifiers = suid.getModifiers ();
-
-      if (Modifier.isStatic (modifiers)
-	  && Modifier.isFinal (modifiers)
-	  && suid.getType() == Long.TYPE)
-	return suid.getLong (null);
-    }
+      {
+	// Use getDeclaredField rather than getField, since serialVersionUID
+	// may not be public AND we only want the serialVersionUID of this
+	// class, not a superclass or interface.
+	Field suid = cl.getDeclaredField("serialVersionUID");
+	suid.setAccessible(true);
+	int modifiers = suid.getModifiers();
+
+	if (Modifier.isStatic(modifiers)
+	    && Modifier.isFinal(modifiers)
+	    && suid.getType() == Long.TYPE)
+	  return suid.getLong(null);
+      }
     catch (NoSuchFieldException ignore)
-    {}
+      {
+      }
     catch (IllegalAccessException ignore)
-    {}
+      {
+      }
 
     // cl didn't define serialVersionUID, so we have to compute it
     try
-    {
-      MessageDigest md;
-      try 
-	{
-	  md = MessageDigest.getInstance ("SHA");
-	}
-      catch (NoSuchAlgorithmException e)
-	{
-	  // If a provider already provides SHA, use it; otherwise, use this.
-	  Gnu gnuProvider = new Gnu();
-	  Security.addProvider(gnuProvider);
-	  md = MessageDigest.getInstance ("SHA");
-	}
+      {
+	MessageDigest md;
+	try 
+	  {
+	    md = MessageDigest.getInstance("SHA");
+	  }
+	catch (NoSuchAlgorithmException e)
+	  {
+	    // If a provider already provides SHA, use it; otherwise, use this.
+	    Gnu gnuProvider = new Gnu();
+	    Security.addProvider(gnuProvider);
+	    md = MessageDigest.getInstance("SHA");
+	  }
 
-      DigestOutputStream digest_out =
-	new DigestOutputStream (nullOutputStream, md);
-      DataOutputStream data_out = new DataOutputStream (digest_out);
+	DigestOutputStream digest_out =
+	  new DigestOutputStream(nullOutputStream, md);
+	DataOutputStream data_out = new DataOutputStream(digest_out);
 
-      data_out.writeUTF (cl.getName ());
+	data_out.writeUTF(cl.getName());
 
-      int modifiers = cl.getModifiers ();
-      // just look at interesting bits
-      modifiers = modifiers & (Modifier.ABSTRACT | Modifier.FINAL
-  				| Modifier.INTERFACE | Modifier.PUBLIC);
-      data_out.writeInt (modifiers);
+	int modifiers = cl.getModifiers();
+	// just look at interesting bits
+	modifiers = modifiers & (Modifier.ABSTRACT | Modifier.FINAL
+				 | Modifier.INTERFACE | Modifier.PUBLIC);
+	data_out.writeInt(modifiers);
 
-      // Pretend that an array has no interfaces, because when array
-      // serialization was defined (JDK 1.1), arrays didn't have it.
-      if (! cl.isArray ())
-	{
-	  Class[] interfaces = cl.getInterfaces ();
-	  Arrays.sort (interfaces, interfaceComparator);
-	  for (int i=0; i < interfaces.length; i++)
-	    data_out.writeUTF (interfaces[i].getName ());
-	}
+	// Pretend that an array has no interfaces, because when array
+	// serialization was defined (JDK 1.1), arrays didn't have it.
+	if (! cl.isArray())
+	  {
+	    Class[] interfaces = cl.getInterfaces();
+	    Arrays.sort(interfaces, interfaceComparator);
+	    for (int i = 0; i < interfaces.length; i++)
+	      data_out.writeUTF(interfaces[i].getName());
+	  }
 
-      Field field;
-      Field[] fields = cl.getDeclaredFields ();
-      Arrays.sort (fields, memberComparator);
-      for (int i=0; i < fields.length; i++)
-      {
-	field = fields[i];
-	modifiers = field.getModifiers ();
-	if (Modifier.isPrivate (modifiers)
-	    && (Modifier.isStatic (modifiers)
-		 || Modifier.isTransient (modifiers)))
-	  continue;
-
-	data_out.writeUTF (field.getName ());
-	data_out.writeInt (modifiers);
-	data_out.writeUTF (TypeSignature.getEncodingOfClass (field.getType ()));
-      }
+	Field field;
+	Field[] fields = cl.getDeclaredFields();
+	Arrays.sort(fields, memberComparator);
+	for (int i = 0; i < fields.length; i++)
+	  {
+	    field = fields[i];
+	    modifiers = field.getModifiers();
+	    if (Modifier.isPrivate(modifiers)
+		&& (Modifier.isStatic(modifiers)
+		    || Modifier.isTransient(modifiers)))
+	      continue;
+
+	    data_out.writeUTF(field.getName());
+	    data_out.writeInt(modifiers);
+	    data_out.writeUTF(TypeSignature.getEncodingOfClass (field.getType()));
+	  }
 
-      // write class initializer method if present
-      if (VMObjectStreamClass.hasClassInitializer (cl))
-      {
-	data_out.writeUTF ("<clinit>");
-	data_out.writeInt (Modifier.STATIC);
-	data_out.writeUTF ("()V");
-      }
+	// write class initializer method if present
+	if (VMObjectStreamClass.hasClassInitializer(cl))
+	  {
+	    data_out.writeUTF("<clinit>");
+	    data_out.writeInt(Modifier.STATIC);
+	    data_out.writeUTF("()V");
+	  }
 
-      Constructor constructor;
-      Constructor[] constructors = cl.getDeclaredConstructors ();
-      Arrays.sort (constructors, memberComparator);
-      for (int i=0; i < constructors.length; i++)
-      {
-	constructor = constructors[i];
-	modifiers = constructor.getModifiers ();
-	if (Modifier.isPrivate (modifiers))
-	  continue;
-
-	data_out.writeUTF ("<init>");
-	data_out.writeInt (modifiers);
-
-	// the replacement of '/' with '.' was needed to make computed
-	// SUID's agree with those computed by JDK
-	data_out.writeUTF (
-	  TypeSignature.getEncodingOfConstructor (constructor).replace ('/','.'));
-      }
+	Constructor constructor;
+	Constructor[] constructors = cl.getDeclaredConstructors();
+	Arrays.sort (constructors, memberComparator);
+	for (int i = 0; i < constructors.length; i++)
+	  {
+	    constructor = constructors[i];
+	    modifiers = constructor.getModifiers();
+	    if (Modifier.isPrivate(modifiers))
+	      continue;
+
+	    data_out.writeUTF("<init>");
+	    data_out.writeInt(modifiers);
+
+	    // the replacement of '/' with '.' was needed to make computed
+	    // SUID's agree with those computed by JDK
+	    data_out.writeUTF 
+	      (TypeSignature.getEncodingOfConstructor(constructor).replace('/','.'));
+	  }
 
-      Method method;
-      Method[] methods = cl.getDeclaredMethods ();
-      Arrays.sort (methods, memberComparator);
-      for (int i=0; i < methods.length; i++)
-      {
-	method = methods[i];
-	modifiers = method.getModifiers ();
-	if (Modifier.isPrivate (modifiers))
-	  continue;
-
-	data_out.writeUTF (method.getName ());
-	data_out.writeInt (modifiers);
-
-	// the replacement of '/' with '.' was needed to make computed
-	// SUID's agree with those computed by JDK
-	data_out.writeUTF (
-	  TypeSignature.getEncodingOfMethod (method).replace ('/', '.'));
-      }
+	Method method;
+	Method[] methods = cl.getDeclaredMethods();
+	Arrays.sort(methods, memberComparator);
+	for (int i = 0; i < methods.length; i++)
+	  {
+	    method = methods[i];
+	    modifiers = method.getModifiers();
+	    if (Modifier.isPrivate(modifiers))
+	      continue;
+
+	    data_out.writeUTF(method.getName());
+	    data_out.writeInt(modifiers);
+
+	    // the replacement of '/' with '.' was needed to make computed
+	    // SUID's agree with those computed by JDK
+	    data_out.writeUTF
+	      (TypeSignature.getEncodingOfMethod(method).replace('/', '.'));
+	  }
 
-      data_out.close ();
-      byte[] sha = md.digest ();
-      long result = 0;
-      int len = sha.length < 8 ? sha.length : 8;
-      for (int i=0; i < len; i++)
-	result += (long)(sha[i] & 0xFF) << (8 * i);
+	data_out.close();
+	byte[] sha = md.digest();
+	long result = 0;
+	int len = sha.length < 8 ? sha.length : 8;
+	for (int i = 0; i < len; i++)
+	  result += (long) (sha[i] & 0xFF) << (8 * i);
 
-      return result;
-    }
+	return result;
+      }
     catch (NoSuchAlgorithmException e)
-    {
-      throw new RuntimeException ("The SHA algorithm was not found to use in computing the Serial Version UID for class "
-				  + cl.getName (), e);
-    }
+      {
+	throw new RuntimeException
+	  ("The SHA algorithm was not found to use in computing the Serial Version UID for class "
+	   + cl.getName(), e);
+      }
     catch (IOException ioe)
-    {
-      throw new RuntimeException (ioe);
-    }
+      {
+	throw new RuntimeException(ioe);
+      }
   }
 
   /**
@@ -712,7 +718,7 @@ public class ObjectStreamClass implements Serializable
    * @param clazz Class to retrieve 'serialPersistentFields' from.
    * @return The content of 'serialPersistentFields'.
    */
-  private ObjectStreamField[] getSerialPersistentFields (Class clazz)
+  private ObjectStreamField[] getSerialPersistentFields(Class clazz) 
     throws NoSuchFieldException, IllegalAccessException
   {
     ObjectStreamField[] fieldsArray = null;
@@ -724,9 +730,9 @@ public class ObjectStreamClass implements Serializable
     f.setAccessible(true);
 
     int modifiers = f.getModifiers();
-    if (!(Modifier.isStatic(modifiers)
-	&& Modifier.isFinal(modifiers)
-	&& Modifier.isPrivate(modifiers)))
+    if (!(Modifier.isStatic(modifiers) &&
+	  Modifier.isFinal(modifiers) &&
+	  Modifier.isPrivate(modifiers)))
       return null;
     
     o = (ObjectStreamField[]) f.get(null);
@@ -734,7 +740,7 @@ public class ObjectStreamClass implements Serializable
     if (o == null)
       return null;
 
-    fieldsArray = new ObjectStreamField[o.length];
+    fieldsArray = new ObjectStreamField[ o.length ];
     System.arraycopy(o, 0, fieldsArray, 0, o.length);
     
     return fieldsArray;
@@ -742,10 +748,10 @@ public class ObjectStreamClass implements Serializable
 
   public static final ObjectStreamField[] NO_FIELDS = {};
 
-  private static Hashtable classLookupTable = new Hashtable ();
-  private static final NullOutputStream nullOutputStream = new NullOutputStream ();
-  private static final Comparator interfaceComparator = new InterfaceComparator ();
-  private static final Comparator memberComparator = new MemberComparator ();
+  private static Hashtable classLookupTable = new Hashtable();
+  private static final NullOutputStream nullOutputStream = new NullOutputStream();
+  private static final Comparator interfaceComparator = new InterfaceComparator();
+  private static final Comparator memberComparator = new MemberComparator();
   private static final
     Class[] writeMethodArgTypes = { java.io.ObjectOutputStream.class };
 
@@ -775,9 +781,9 @@ public class ObjectStreamClass implements Serializable
 // interfaces are compared only by name
 class InterfaceComparator implements Comparator
 {
-  public int compare (Object o1, Object o2)
+  public int compare(Object o1, Object o2)
   {
-    return ((Class)o1).getName ().compareTo (((Class)o2).getName ());
+    return ((Class) o1).getName().compareTo(((Class) o2).getName());
   }
 }
 
@@ -786,16 +792,16 @@ class InterfaceComparator implements Comparator
 // conflicts are resolved by comparing type signatures
 class MemberComparator implements Comparator
 {
-  public int compare (Object o1, Object o2)
+  public int compare(Object o1, Object o2)
   {
-    Member m1 = (Member)o1;
-    Member m2 = (Member)o2;
+    Member m1 = (Member) o1;
+    Member m2 = (Member) o2;
 
-    int comp = m1.getName ().compareTo (m2.getName ());
+    int comp = m1.getName().compareTo(m2.getName());
 
     if (comp == 0)
-      return TypeSignature.getEncodingOfMember (m1).
-	compareTo (TypeSignature.getEncodingOfMember (m2));
+      return TypeSignature.getEncodingOfMember(m1).
+	compareTo(TypeSignature.getEncodingOfMember(m2));
     else
       return comp;
   }