commit-classpath
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: FYI: Reindented code in serialization.


From: Guilhem Lavaux
Subject: Re: FYI: Reindented code in serialization.
Date: Sun, 28 Dec 2003 19:30:33 +0100
User-agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.5) Gecko/20031007

Guilhem Lavaux wrote:

Hi,

I've check in a patch to fix the indentation/code aspect in serialization. I hope it's correct now. The files concerned are java/io/ObjectOutputStream.java, java/io/ObjectInputStream.java, java/io/ObjectStreamClass.java.

Guilhem.

With the patch attached.
Index: ChangeLog
===================================================================
RCS file: /cvsroot/classpath/classpath/ChangeLog,v
retrieving revision 1.1732
retrieving revision 1.1733
diff -u -r1.1732 -r1.1733
--- ChangeLog   28 Dec 2003 17:18:24 -0000      1.1732
+++ ChangeLog   28 Dec 2003 18:12:43 -0000      1.1733
@@ -1,5 +1,12 @@
 2003-12-28  Guilhem Lavaux <address@hidden>
 
+       * java/io/ObjectOutputStream.java,
+       java/io/ObjectInputStream.java,
+       java/io/ObjectStreamClass.java: Reindented. Some exception message
+       has been added.
+
+2003-12-28  Guilhem Lavaux <address@hidden>
+
        * java/io/ObjectOutputStream.java
        (writeClassDescriptor): Externalizable class must also write their
        hierarchy.
Index: java/io/ObjectInputStream.java
===================================================================
RCS file: /cvsroot/classpath/classpath/java/io/ObjectInputStream.java,v
retrieving revision 1.34
retrieving revision 1.35
diff -u -r1.34 -r1.35
--- java/io/ObjectInputStream.java      28 Dec 2003 17:18:24 -0000      1.34
+++ java/io/ObjectInputStream.java      28 Dec 2003 18:12:43 -0000      1.35
@@ -73,7 +73,7 @@
    *
    * @see #readStreamHeader()
    */
-  public ObjectInputStream (InputStream in)
+  public ObjectInputStream(InputStream in)
     throws IOException, StreamCorruptedException
   {
     if (Configuration.DEBUG)
@@ -96,13 +96,13 @@
     this.blockDataPosition = 0;
     this.blockDataBytes = 0;
     this.blockData = new byte[BUFFER_SIZE];
-    this.blockDataInput = new DataInputStream (this);
-    this.realInputStream = new DataInputStream (in);
+    this.blockDataInput = new DataInputStream(this);
+    this.realInputStream = new DataInputStream(in);
     this.nextOID = baseWireHandle;
     this.objectLookupTable = new Hashtable();
     this.validators = new Vector();
     this.classLookupTable = new Hashtable();
-    setBlockDataMode (true);
+    setBlockDataMode(true);
     readStreamHeader();
   }
 
@@ -122,10 +122,10 @@
    * @exception IOException Exception from underlying
    * <code>InputStream</code>.
    */
-  public final Object readObject () throws ClassNotFoundException, IOException
+  public final Object readObject() throws ClassNotFoundException, IOException
   {
     if (this.useSubclassMethod)
-      return readObjectOverride ();
+      return readObjectOverride();
 
     boolean was_deserializing;
 
@@ -133,12 +133,12 @@
     was_deserializing = this.isDeserializing;
 
     boolean is_consumed = false;
-    boolean old_mode = setBlockDataMode (false);
+    boolean old_mode = setBlockDataMode(false);
 
     this.isDeserializing = true;
 
-    byte marker = this.realInputStream.readByte ();
-    dumpElement ("MARKER: 0x" + Integer.toHexString(marker) + " ");
+    byte marker = this.realInputStream.readByte();
+    dumpElement("MARKER: 0x" + Integer.toHexString(marker) + " ");
 
     try
       {
@@ -155,43 +155,43 @@
          case TC_BLOCKDATALONG:
            {
              if (marker == TC_BLOCKDATALONG)
-               dumpElementln ("BLOCKDATALONG");
+               dumpElementln("BLOCKDATALONG");
              else
-               dumpElementln ("BLOCKDATA");
-             readNextBlock (marker);
-             throw new StreamCorruptedException ("Unexpected blockData");
+               dumpElementln("BLOCKDATA");
+             readNextBlock(marker);
+             throw new StreamCorruptedException("Unexpected blockData");
            }
 
          case TC_NULL:
            {
-             dumpElementln ("NULL");
+             dumpElementln("NULL");
              ret_val = null;
              break;
            }
 
          case TC_REFERENCE:
            {
-             dumpElement ("REFERENCE ");
-             Integer oid = new Integer (this.realInputStream.readInt ());
-             dumpElementln (Integer.toHexString(oid.intValue()));
+             dumpElement("REFERENCE ");
+             Integer oid = new Integer(this.realInputStream.readInt());
+             dumpElementln(Integer.toHexString(oid.intValue()));
              ret_val = ((ObjectIdentityWrapper)
-                        this.objectLookupTable.get (oid)).object;
+                        this.objectLookupTable.get(oid)).object;
              break;
            }
 
          case TC_CLASS:
            {
-             dumpElementln ("CLASS");
-             ObjectStreamClass osc = (ObjectStreamClass)readObject ();
-             Class clazz = osc.forClass ();
-             assignNewHandle (clazz);
+             dumpElementln("CLASS");
+             ObjectStreamClass osc = (ObjectStreamClass)readObject();
+             Class clazz = osc.forClass();
+             assignNewHandle(clazz);
              ret_val = clazz;
              break;
            }
 
          case TC_PROXYCLASSDESC:
            {
-             dumpElementln ("PROXYCLASS");
+             dumpElementln("PROXYCLASS");
              int n_intf = this.realInputStream.readInt();
              String[] intfs = new String[n_intf];
              for (int i = 0; i < n_intf; i++)
@@ -200,41 +200,41 @@
                  System.out.println(intfs[i]);
                }
              
-             boolean oldmode = setBlockDataMode (true);
+             boolean oldmode = setBlockDataMode(true);
              Class cl = resolveProxyClass(intfs);
              setBlockDataMode(oldmode);
              
-             ObjectStreamClass osc = lookupClass (cl);
-             assignNewHandle (osc);
+             ObjectStreamClass osc = lookupClass(cl);
+             assignNewHandle(osc);
              
              if (!is_consumed)
                {
-                 byte b = this.realInputStream.readByte ();
+                 byte b = this.realInputStream.readByte();
                  if (b != TC_ENDBLOCKDATA)
-                   throw new IOException ("Data annotated to class was not 
consumed." + b);
+                   throw new IOException("Data annotated to class was not 
consumed." + b);
                }
              else
                is_consumed = false;
-             ObjectStreamClass superosc = (ObjectStreamClass)readObject ();
-             osc.setSuperclass (superosc);
+             ObjectStreamClass superosc = (ObjectStreamClass)readObject();
+             osc.setSuperclass(superosc);
              ret_val = osc;
              break;
            }
 
          case TC_CLASSDESC:
            {
-             ObjectStreamClass osc = readClassDescriptor ();
+             ObjectStreamClass osc = readClassDescriptor();
              
              if (!is_consumed)
                {
-                 byte b = this.realInputStream.readByte ();
+                 byte b = this.realInputStream.readByte();
                  if (b != TC_ENDBLOCKDATA)
-                   throw new IOException ("Data annotated to class was not 
consumed." + b);
+                   throw new IOException("Data annotated to class was not 
consumed." + b);
                }
              else
                is_consumed = false;
              
-             osc.setSuperclass ((ObjectStreamClass)readObject ());
+             osc.setSuperclass ((ObjectStreamClass)readObject());
              ret_val = osc;
              break;
            }
@@ -242,105 +242,107 @@
          case TC_STRING:
          case TC_LONGSTRING:
            {
-             dumpElement ("STRING=");
-             String s = this.realInputStream.readUTF ();
-             dumpElementln (s);
-             ret_val = processResolution (s, assignNewHandle (s));
+             dumpElement("STRING=");
+             String s = this.realInputStream.readUTF();
+             dumpElementln(s);
+             ret_val = processResolution(s, assignNewHandle(s));
              break;
            }
 
          case TC_ARRAY:
            {
-             dumpElementln ("ARRAY");
-             ObjectStreamClass osc = (ObjectStreamClass)readObject ();
-             Class componentType = osc.forClass ().getComponentType ();
-             dumpElement ("ARRAY LENGTH=");
-             int length = this.realInputStream.readInt ();
+             dumpElementln("ARRAY");
+             ObjectStreamClass osc = (ObjectStreamClass)readObject();
+             Class componentType = osc.forClass().getComponentType();
+             dumpElement("ARRAY LENGTH=");
+             int length = this.realInputStream.readInt();
              dumpElementln (length + "; COMPONENT TYPE=" + componentType);
-             Object array = Array.newInstance (componentType, length);
-             int handle = assignNewHandle (array);
-             readArrayElements (array, componentType);
-             for (int i=0, len=Array.getLength(array); i < len; i++)
-               dumpElementln ("  ELEMENT[" + i + "]=" + Array.get(array, i));
-             ret_val = processResolution (array, handle);
+             Object array = Array.newInstance(componentType, length);
+             int handle = assignNewHandle(array);
+             readArrayElements(array, componentType);
+             for (int i = 0, len = Array.getLength(array); i < len; i++)
+               dumpElementln("  ELEMENT[" + i + "]=" + Array.get(array, i));
+             ret_val = processResolution(array, handle);
              break;
            }
 
          case TC_OBJECT:
            {
-             dumpElementln ("OBJECT");
-             ObjectStreamClass osc = (ObjectStreamClass)readObject ();
-             Class clazz = osc.forClass ();
+             dumpElementln("OBJECT");
+             ObjectStreamClass osc = (ObjectStreamClass)readObject();
+             Class clazz = osc.forClass();
              
-             if (!Serializable.class.isAssignableFrom (clazz))
-               throw new NotSerializableException (clazz + " is not 
Serializable, and thus cannot be deserialized.");
+             if (!Serializable.class.isAssignableFrom(clazz))
+               throw new NotSerializableException
+                 (clazz + " is not Serializable, and thus cannot be 
deserialized.");
              
-             if (Externalizable.class.isAssignableFrom (clazz))
+             if (Externalizable.class.isAssignableFrom(clazz))
                {
                  Externalizable obj = null;
                  
                  try
                    {
-                     obj = (Externalizable)clazz.newInstance ();
+                     obj = (Externalizable)clazz.newInstance();
                    }
                  catch (InstantiationException e)
                    {
-                     throw new ClassNotFoundException ("Instance of " + clazz
-                                                       + " could not be 
created");
+                     throw new ClassNotFoundException
+                       ("Instance of " + clazz + " could not be created");
                    }
                  catch (IllegalAccessException e)
                    {
-                     throw new ClassNotFoundException ("Instance of " + clazz
-                                                       + " could not be 
created because class or zero-argument constructor is not accessible");
+                     throw new ClassNotFoundException
+                       ("Instance of " + clazz + " could not be created 
because class or "
+                        + "zero-argument constructor is not accessible");
                    }
                  catch (NoSuchMethodError e)
                    {
-                     throw new ClassNotFoundException ("Instance of " + clazz
-                                                       + " could not be 
created because zero-argument constructor is not defined");
+                     throw new ClassNotFoundException
+                       ("Instance of " + clazz
+                        + " could not be created because zero-argument 
constructor is not defined");
                    }
                  
-                 int handle = assignNewHandle (obj);
+                 int handle = assignNewHandle(obj);
                  
-                 boolean read_from_blocks = ((osc.getFlags () & SC_BLOCK_DATA) 
!= 0);
+                 boolean read_from_blocks = ((osc.getFlags() & SC_BLOCK_DATA) 
!= 0);
                  
                  boolean oldmode = this.readDataFromBlock;
                  if (read_from_blocks)
-                   setBlockDataMode (true);
+                   setBlockDataMode(true);
                  
-                 obj.readExternal (this);
+                 obj.readExternal(this);
                  
                  if (read_from_blocks)
-                   setBlockDataMode (oldmode);
+                   setBlockDataMode(oldmode);
                  
-                 ret_val = processResolution (obj, handle);
+                 ret_val = processResolution(obj, handle);
                  break;
                } // end if (Externalizable.class.isAssignableFrom (clazz))
              
              // find the first non-serializable, non-abstract
              // class in clazz's inheritance hierarchy
-             Class first_nonserial = clazz.getSuperclass ();
-             while (Serializable.class.isAssignableFrom (first_nonserial)
-                    || Modifier.isAbstract (first_nonserial.getModifiers ()))
-               first_nonserial = first_nonserial.getSuperclass ();
+             Class first_nonserial = clazz.getSuperclass();
+             while (Serializable.class.isAssignableFrom(first_nonserial)
+                    || Modifier.isAbstract(first_nonserial.getModifiers()))
+               first_nonserial = first_nonserial.getSuperclass();
              
              Object obj = null;
-             obj = newObject (clazz, first_nonserial);
+             obj = newObject(clazz, first_nonserial);
              
              if (obj == null)
-               throw new ClassNotFoundException ("Instance of " + clazz +
-                                                 " could not be created");
+               throw new ClassNotFoundException
+                 ("Instance of " + clazz + " could not be created");
              
-             int handle = assignNewHandle (obj);
+             int handle = assignNewHandle(obj);
              this.currentObject = obj;
              ObjectStreamClass[] hierarchy =
-               inputGetObjectStreamClasses (clazz);
+               inputGetObjectStreamClasses(clazz);
              
-             for (int i=0; i < hierarchy.length; i++)
+             for (int i = 0; i < hierarchy.length; i++)
                {
                  this.currentObjectStreamClass = hierarchy[i];
                  
-                 dumpElementln ("Reading fields of "
-                                + this.currentObjectStreamClass.getName ());
+                 dumpElementln("Reading fields of " + 
this.currentObjectStreamClass.getName ());
 
                  // XXX: should initialize fields in classes in the hierarchy
                  // that aren't in the stream
@@ -350,68 +352,69 @@
                  if (this.currentObjectStreamClass.hasReadMethod())
                    {
                      fieldsAlreadyRead = false;
-                     boolean oldmode = setBlockDataMode (true);
-                     callReadMethod (obj, this.currentObjectStreamClass);
-                     setBlockDataMode (oldmode);
-                     dumpElement ("ENDBLOCKDATA? ");
+                     boolean oldmode = setBlockDataMode(true);
+                     callReadMethod(obj, this.currentObjectStreamClass);
+                     setBlockDataMode(oldmode);
+                     dumpElement("ENDBLOCKDATA? ");
                      try
                        {
                          // FIXME: XXX: This try block is to catch EOF which is
                          // thrown for some objects.  That indicates a bug in 
the logic.
-                         if (this.realInputStream.readByte () != 
TC_ENDBLOCKDATA)
-                           throw new IOException ("No end of block data seen 
for class with readObject (ObjectInputStream) method.");
-                         dumpElementln ("yes");
+                         if (this.realInputStream.readByte() != 
TC_ENDBLOCKDATA)
+                           throw new IOException
+                             ("No end of block data seen for class with 
readObject (ObjectInputStream) method.");
+                         dumpElementln("yes");
                        }
                      catch (EOFException e)
                        {
-                         dumpElementln ("no, got EOFException");
+                         dumpElementln("no, got EOFException");
                        }
                      catch (IOException e)
                        {
-                         dumpElementln ("no, got IOException");
+                         dumpElementln("no, got IOException");
                        }
                    }
                  else
                    {
-                     readFields (obj, currentObjectStreamClass);
+                     readFields(obj, currentObjectStreamClass);
                    }
                }
 
              this.currentObject = null;
              this.currentObjectStreamClass = null;
-             ret_val = processResolution (obj, handle);
+             ret_val = processResolution(obj, handle);
              break;
            }
 
          case TC_RESET:
-           dumpElementln ("RESET");
-           clearHandles ();
-           ret_val = readObject ();
+           dumpElementln("RESET");
+           clearHandles();
+           ret_val = readObject();
            break;
 
          case TC_EXCEPTION:
            {
-             dumpElement ("EXCEPTION=");
-             Exception e = (Exception)readObject ();
-             dumpElementln (e.toString());
-             clearHandles ();
-             throw new WriteAbortedException ("Exception thrown during writing 
of stream", e);
+             dumpElement("EXCEPTION=");
+             Exception e = (Exception)readObject();
+             dumpElementln(e.toString());
+             clearHandles();
+             throw new WriteAbortedException("Exception thrown during writing 
of stream", e);
            }
 
          default:
-           throw new IOException ("Unknown marker on stream: " + marker);
+           throw new IOException("Unknown marker on stream: " + marker);
          }
       }
     finally
       {
-       setBlockDataMode (old_mode);
+       setBlockDataMode(old_mode);
        
        this.isDeserializing = was_deserializing;
        
        if (! was_deserializing)
          {
-           if (validators.size () > 0)
-             invokeValidators ();
+           if (validators.size() > 0)
+             invokeValidators();
          }
       }
     
@@ -434,30 +437,30 @@
    * @throws InvalidClassException If there was a compatibility problem
    * between the class present in the system and the serialized class.
    */
-  protected ObjectStreamClass readClassDescriptor ()
+  protected ObjectStreamClass readClassDescriptor()
     throws ClassNotFoundException, IOException
   {
-    dumpElement ("CLASSDESC NAME=");
-    String name = this.realInputStream.readUTF ();
-    dumpElement (name + "; UID=");
+    dumpElement("CLASSDESC NAME=");
+    String name = this.realInputStream.readUTF();
+    dumpElement(name + "; UID=");
     long uid = this.realInputStream.readLong ();
-    dumpElement (Long.toHexString(uid) + "; FLAGS=");
+    dumpElement(Long.toHexString(uid) + "; FLAGS=");
     byte flags = this.realInputStream.readByte ();
-    dumpElement (Integer.toHexString(flags) + "; FIELD COUNT=");
-    short field_count = this.realInputStream.readShort ();
-    dumpElementln (Short.toString(field_count));
+    dumpElement(Integer.toHexString(flags) + "; FIELD COUNT=");
+    short field_count = this.realInputStream.readShort();
+    dumpElementln(Short.toString(field_count));
     ObjectStreamField[] fields = new ObjectStreamField[field_count];
-    ObjectStreamClass osc = new ObjectStreamClass (name, uid,
-                                                   flags, fields);
-    assignNewHandle (osc);
+    ObjectStreamClass osc = new ObjectStreamClass(name, uid,
+                                                 flags, fields);
+    assignNewHandle(osc);
              
-    for (int i=0; i < field_count; i++)
+    for (int i = 0; i < field_count; i++)
       {
-       dumpElement ("  TYPE CODE=");
-       char type_code = (char)this.realInputStream.readByte ();
-       dumpElement (type_code + "; FIELD NAME=");
-       String field_name = this.realInputStream.readUTF ();
-       dumpElementln (field_name);
+       dumpElement("  TYPE CODE=");
+       char type_code = (char)this.realInputStream.readByte();
+       dumpElement(type_code + "; FIELD NAME=");
+       String field_name = this.realInputStream.readUTF();
+       dumpElementln(field_name);
        String class_name;
                  
        // If the type code is an array or an object we must
@@ -465,9 +468,9 @@
        // the type code and pass it to ObjectStreamField.
        // Type codes are decoded by gnu.java.lang.reflect.TypeSignature.
        if (type_code == 'L' || type_code == '[')
-         class_name = (String)readObject ();
+         class_name = (String)readObject();
        else
-         class_name = String.valueOf (type_code);
+         class_name = String.valueOf(type_code);
                  
        fields[i] =
          new ObjectStreamField(field_name, class_name, currentLoader());
@@ -495,11 +498,11 @@
          }
       }
 
-    boolean oldmode = setBlockDataMode (true);
-    osc.setClass (clazz, lookupClass(clazz.getSuperclass()));
+    boolean oldmode = setBlockDataMode(true);
+    osc.setClass(clazz, lookupClass(clazz.getSuperclass()));
     classLookupTable.put(clazz, osc);
-    setBlockDataMode (oldmode);
-             
+    setBlockDataMode(oldmode);
+
     return osc;
   }
 
@@ -522,7 +525,7 @@
    * @exception IOException Exception from underlying
    * <code>OutputStream</code>.
    */
-  public void defaultReadObject ()
+  public void defaultReadObject()
     throws ClassNotFoundException, IOException, NotActiveException
   {
     if (this.currentObject == null || this.currentObjectStreamClass == null)
@@ -535,7 +538,7 @@
                                   + "defaultReadObject or readFields)");
 
     boolean oldmode = setBlockDataMode(false);
-    readFields (this.currentObject, this.currentObjectStreamClass);
+    readFields(this.currentObject, this.currentObjectStreamClass);
     setBlockDataMode(oldmode);
 
     fieldsAlreadyRead = true;
@@ -560,20 +563,20 @@
    * validator outside of the <code>readObject</code> method of the
    * object currently being deserialized
    */
-  public void registerValidation (ObjectInputValidation validator,
-                                 int priority)
+  public void registerValidation(ObjectInputValidation validator,
+                                int priority)
     throws InvalidObjectException, NotActiveException
   {
     if (this.currentObject == null || this.currentObjectStreamClass == null)
-      throw new NotActiveException ("registerValidation called by non-active "
-                                   +"class and/or object");
+      throw new NotActiveException("registerValidation called by non-active "
+                                  + "class and/or object");
 
     if (validator == null)
-      throw new InvalidObjectException ("attempt to add a null "
-                                       +"ObjectInputValidation object");
+      throw new InvalidObjectException("attempt to add a null "
+                                      + "ObjectInputValidation object");
 
-    this.validators.addElement (new ValidatorAndPriority (validator,
-                                                         priority));
+    this.validators.addElement(new ValidatorAndPriority (validator,
+                                                        priority));
   }
 
 
@@ -593,7 +596,7 @@
    *
    * @see java.io.ObjectOutputStream#annotateClass (java.lang.Class)
    */
-  protected Class resolveClass (ObjectStreamClass osc)
+  protected Class resolveClass(ObjectStreamClass osc)
     throws ClassNotFoundException, IOException
   {
     return Class.forName(osc.getName(), true, currentLoader());
@@ -609,7 +612,7 @@
    */
   private ClassLoader currentLoader()
   {
-    SecurityManager sm = System.getSecurityManager ();
+    SecurityManager sm = System.getSecurityManager();
     if (sm == null)
       sm = new SecurityManager () {};
     
@@ -627,13 +630,13 @@
    * @return A valid instance of ObjectStreamClass corresponding
    * to the specified class.
    */
-  private ObjectStreamClass lookupClass (Class clazz)
+  private ObjectStreamClass lookupClass(Class clazz)
   {
     ObjectStreamClass oclazz;
 
-    oclazz = (ObjectStreamClass) classLookupTable.get(clazz);
+    oclazz = (ObjectStreamClass)classLookupTable.get(clazz);
     if (oclazz == null)
-      return ObjectStreamClass.lookup (clazz);
+      return ObjectStreamClass.lookup(clazz);
     else
       return oclazz;
   }
@@ -650,9 +653,9 @@
    * @return An array of valid address@hidden java.io.ObjectStreamClass} 
instances which
    * represent the class hierarchy for clazz.
    */
-  private ObjectStreamClass[] inputGetObjectStreamClasses (Class clazz)
+  private ObjectStreamClass[] inputGetObjectStreamClasses(Class clazz)
   {
-    ObjectStreamClass osc = lookupClass (clazz);
+    ObjectStreamClass osc = lookupClass(clazz);
 
     ObjectStreamClass[] ret_val;
 
@@ -691,36 +694,40 @@
    *
    * @see #enableResolveObject(boolean)
    */
-  protected Object resolveObject (Object obj) throws IOException
+  protected Object resolveObject(Object obj) throws IOException
   {
     return obj;
   }
 
 
-  protected Class resolveProxyClass (String[] intfs)
+  protected Class resolveProxyClass(String[] intfs)
     throws IOException, ClassNotFoundException
   {
-    SecurityManager sm = System.getSecurityManager ();
+    SecurityManager sm = System.getSecurityManager();
     
     if (sm == null)
-      sm = new SecurityManager () {};
+      sm = new SecurityManager() {};
     
-    ClassLoader cl = currentClassLoader (sm);
+    ClassLoader cl = currentClassLoader(sm);
     
     Class[] clss = new Class[intfs.length];
-    if(cl == null){
-      for (int i = 0; i < intfs.length; i++)
-       clss[i] = Class.forName(intfs[i]);
-      cl = ClassLoader.getSystemClassLoader();
-    }
+    if(cl == null)
+      {
+       for (int i = 0; i < intfs.length; i++)
+         clss[i] = Class.forName(intfs[i]);
+       cl = ClassLoader.getSystemClassLoader();
+      }
     else
       for (int i = 0; i < intfs.length; i++)
        clss[i] = cl.loadClass(intfs[i]);
-    try {
-      return Proxy.getProxyClass(cl, clss);
-    } catch (IllegalArgumentException e) {
-      throw new ClassNotFoundException(null, e);
-    }
+    try 
+      {
+       return Proxy.getProxyClass(cl, clss);
+      } 
+    catch (IllegalArgumentException e) 
+      {
+       throw new ClassNotFoundException(null, e);
+      }
   }
   
   /**
@@ -736,9 +743,9 @@
   {
     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 = this.resolveEnabled;
@@ -755,31 +762,31 @@
    * @exception StreamCorruptedException An invalid stream magic
    * number or stream version was read from the stream.
    */
-  protected void readStreamHeader ()
+  protected void readStreamHeader()
     throws IOException, StreamCorruptedException
   {
-    dumpElement ("STREAM MAGIC ");
-    if (this.realInputStream.readShort () != STREAM_MAGIC)
-      throw new StreamCorruptedException ("Invalid stream magic number");
+    dumpElement("STREAM MAGIC ");
+    if (this.realInputStream.readShort() != STREAM_MAGIC)
+      throw new StreamCorruptedException("Invalid stream magic number");
 
-    dumpElementln ("STREAM VERSION ");
-    if (this.realInputStream.readShort () != STREAM_VERSION)
-      throw new StreamCorruptedException ("Invalid stream version number");
+    dumpElementln("STREAM VERSION ");
+    if (this.realInputStream.readShort() != STREAM_VERSION)
+      throw new StreamCorruptedException("Invalid stream version number");
   }
 
-  public int read () throws IOException
+  public int read() throws IOException
   {
     if (this.readDataFromBlock)
       {
        if (this.blockDataPosition >= this.blockDataBytes)
-         readNextBlock ();
+         readNextBlock();
        return (this.blockData[this.blockDataPosition++] & 0xff);
       }
     else
-      return this.realInputStream.read ();
+      return this.realInputStream.read();
   }
 
-  public int read (byte[] data, int offset, int length) throws IOException
+  public int read(byte[] data, int offset, int length) throws IOException
   {
     if (this.readDataFromBlock)
       {
@@ -788,25 +795,25 @@
            int remain = this.blockDataBytes - this.blockDataPosition;
            if (remain != 0)
              {
-               System.arraycopy (this.blockData, this.blockDataPosition,
-                                 data, offset, remain);
+               System.arraycopy(this.blockData, this.blockDataPosition,
+                                data, offset, remain);
                offset += remain;
                length -= remain;
              }
            readNextBlock ();
          }
 
-       System.arraycopy (this.blockData, this.blockDataPosition,
-                         data, offset, length);
+       System.arraycopy(this.blockData, this.blockDataPosition,
+                        data, offset, length);
        this.blockDataPosition += length;
 
        return length;
       }
     else
-      return this.realInputStream.read (data, offset, length);
+      return this.realInputStream.read(data, offset, length);
   }
 
-  public int available () throws IOException
+  public int available() throws IOException
   {
     if (this.readDataFromBlock)
       {
@@ -816,15 +823,15 @@
        return this.blockDataBytes - this.blockDataPosition;
       }
     else
-      return this.realInputStream.available ();
+      return this.realInputStream.available();
   }
 
-  public void close () throws IOException
+  public void close() throws IOException
   {
-    this.realInputStream.close ();
+    this.realInputStream.close();
   }
 
-  public boolean readBoolean () throws IOException
+  public boolean readBoolean() throws IOException
   {
     boolean switchmode = true;
     boolean oldmode = this.readDataFromBlock;
@@ -838,160 +845,160 @@
     return value;
   }
 
-  public byte readByte () throws IOException
+  public byte readByte() throws IOException
   {
     boolean switchmode = true;
     boolean oldmode = this.readDataFromBlock;
     if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 1)
       switchmode = false;
     if (switchmode)
-      oldmode = setBlockDataMode (true);
-    byte value = this.dataInputStream.readByte ();
+      oldmode = setBlockDataMode(true);
+    byte value = this.dataInputStream.readByte();
     if (switchmode)
-      setBlockDataMode (oldmode);
+      setBlockDataMode(oldmode);
     return value;
   }
 
-  public int readUnsignedByte () throws IOException
+  public int readUnsignedByte() throws IOException
   {
     boolean switchmode = true;
     boolean oldmode = this.readDataFromBlock;
     if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 1)
       switchmode = false;
     if (switchmode)
-      oldmode = setBlockDataMode (true);
-    int value = this.dataInputStream.readUnsignedByte ();
+      oldmode = setBlockDataMode(true);
+    int value = this.dataInputStream.readUnsignedByte();
     if (switchmode)
-      setBlockDataMode (oldmode);
+      setBlockDataMode(oldmode);
     return value;
   }
 
-  public short readShort () throws IOException
+  public short readShort() throws IOException
   {
     boolean switchmode = true;
     boolean oldmode = this.readDataFromBlock;
     if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 2)
       switchmode = false;
     if (switchmode)
-      oldmode = setBlockDataMode (true);
-    short value = this.dataInputStream.readShort ();
+      oldmode = setBlockDataMode(true);
+    short value = this.dataInputStream.readShort();
     if (switchmode)
-      setBlockDataMode (oldmode);
+      setBlockDataMode(oldmode);
     return value;
   }
 
-  public int readUnsignedShort () throws IOException
+  public int readUnsignedShort() throws IOException
   {
     boolean switchmode = true;
     boolean oldmode = this.readDataFromBlock;
     if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 2)
       switchmode = false;
     if (switchmode)
-      oldmode = setBlockDataMode (true);
-    int value = this.dataInputStream.readUnsignedShort ();
+      oldmode = setBlockDataMode(true);
+    int value = this.dataInputStream.readUnsignedShort();
     if (switchmode)
-      setBlockDataMode (oldmode);
+      setBlockDataMode(oldmode);
     return value;
   }
 
-  public char readChar () throws IOException
+  public char readChar() throws IOException
   {
     boolean switchmode = true;
     boolean oldmode = this.readDataFromBlock;
     if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 2)
       switchmode = false;
     if (switchmode)
-      oldmode = setBlockDataMode (true);
-    char value = this.dataInputStream.readChar ();
+      oldmode = setBlockDataMode(true);
+    char value = this.dataInputStream.readChar();
     if (switchmode)
-      setBlockDataMode (oldmode);
+      setBlockDataMode(oldmode);
     return value;
   }
 
-  public int readInt () throws IOException
+  public int readInt() throws IOException
   {
     boolean switchmode = true;
     boolean oldmode = this.readDataFromBlock;
     if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 4)
       switchmode = false;
     if (switchmode)
-      oldmode = setBlockDataMode (true);
-    int value = this.dataInputStream.readInt ();
+      oldmode = setBlockDataMode(true);
+    int value = this.dataInputStream.readInt();
     if (switchmode)
-      setBlockDataMode (oldmode);
+      setBlockDataMode(oldmode);
     return value;
   }
 
-  public long readLong () throws IOException
+  public long readLong() throws IOException
   {
     boolean switchmode = true;
     boolean oldmode = this.readDataFromBlock;
     if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 8)
       switchmode = false;
     if (switchmode)
-      oldmode = setBlockDataMode (true);
-    long value = this.dataInputStream.readLong ();
+      oldmode = setBlockDataMode(true);
+    long value = this.dataInputStream.readLong();
     if (switchmode)
-      setBlockDataMode (oldmode);
+      setBlockDataMode(oldmode);
     return value;
   }
 
-  public float readFloat () throws IOException
+  public float readFloat() throws IOException
   {
     boolean switchmode = true;
     boolean oldmode = this.readDataFromBlock;
     if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 4)
       switchmode = false;
     if (switchmode)
-      oldmode = setBlockDataMode (true);
-    float value = this.dataInputStream.readFloat ();
+      oldmode = setBlockDataMode(true);
+    float value = this.dataInputStream.readFloat();
     if (switchmode)
-      setBlockDataMode (oldmode);
+      setBlockDataMode(oldmode);
     return value;
   }
 
-  public double readDouble () throws IOException
+  public double readDouble() throws IOException
   {
     boolean switchmode = true;
     boolean oldmode = this.readDataFromBlock;
     if (!oldmode || this.blockDataBytes - this.blockDataPosition >= 8)
       switchmode = false;
     if (switchmode)
-      oldmode = setBlockDataMode (true);
-    double value = this.dataInputStream.readDouble ();
+      oldmode = setBlockDataMode(true);
+    double value = this.dataInputStream.readDouble();
     if (switchmode)
-      setBlockDataMode (oldmode);
+      setBlockDataMode(oldmode);
     return value;
   }
 
-  public void readFully (byte data[]) throws IOException
+  public void readFully(byte data[]) throws IOException
   {
-    this.dataInputStream.readFully (data);
+    this.dataInputStream.readFully(data);
   }
 
-  public void readFully (byte data[], int offset, int size)
+  public void readFully(byte data[], int offset, int size)
     throws IOException
   {
-    this.dataInputStream.readFully (data, offset, size);
+    this.dataInputStream.readFully(data, offset, size);
   }
 
-  public int skipBytes (int len) throws IOException
+  public int skipBytes(int len) throws IOException
   {
-    return this.dataInputStream.skipBytes (len);
+    return this.dataInputStream.skipBytes(len);
   }
 
   /**
    * @deprecated
    * @see java.io.DataInputStream#readLine ()
    */
-  public String readLine () throws IOException
+  public String readLine() throws IOException
   {
-    return this.dataInputStream.readLine ();
+    return this.dataInputStream.readLine();
   }
 
-  public String readUTF () throws IOException
+  public String readUTF() throws IOException
   {
-    return this.dataInputStream.readUTF ();
+    return this.dataInputStream.readUTF();
   }
 
   /**
@@ -1002,36 +1009,36 @@
    */
   public static abstract class GetField
   {
-    public abstract ObjectStreamClass getObjectStreamClass ();
+    public abstract ObjectStreamClass getObjectStreamClass();
 
-    public abstract boolean defaulted (String name)
+    public abstract boolean defaulted(String name)
       throws IOException, IllegalArgumentException;
 
-    public abstract boolean get (String name, boolean defvalue)
+    public abstract boolean get(String name, boolean defvalue)
       throws IOException, IllegalArgumentException;
 
-    public abstract char get (String name, char defvalue)
+    public abstract char get(String name, char defvalue)
       throws IOException, IllegalArgumentException;
 
-    public abstract byte get (String name, byte defvalue)
+    public abstract byte get(String name, byte defvalue)
       throws IOException, IllegalArgumentException;
 
-    public abstract short get (String name, short defvalue)
+    public abstract short get(String name, short defvalue)
       throws IOException, IllegalArgumentException;
 
-    public abstract int get (String name, int defvalue)
+    public abstract int get(String name, int defvalue)
       throws IOException, IllegalArgumentException;
 
-    public abstract long get (String name, long defvalue)
+    public abstract long get(String name, long defvalue)
       throws IOException, IllegalArgumentException;
 
-    public abstract float get (String name, float defvalue)
+    public abstract float get(String name, float defvalue)
       throws IOException, IllegalArgumentException;
 
-    public abstract double get (String name, double defvalue)
+    public abstract double get(String name, double defvalue)
       throws IOException, IllegalArgumentException;
 
-    public abstract Object get (String name, Object defvalue)
+    public abstract Object get(String name, Object defvalue)
       throws IOException, IllegalArgumentException;
   }
 
@@ -1048,18 +1055,18 @@
    * @throws ClassNotFoundException 
    * @throws NotActiveException
    */
-  public GetField readFields ()
+  public GetField readFields()
     throws IOException, ClassNotFoundException, NotActiveException
   {
     if (this.currentObject == null || this.currentObjectStreamClass == null)
-      throw new NotActiveException ("readFields called by non-active class 
and/or object");
+      throw new NotActiveException("readFields called by non-active class 
and/or object");
 
     if (prereadFields != null)
       return prereadFields;
 
     if (fieldsAlreadyRead)
-      throw new NotActiveException ("readFields called but fields already read 
from"
-                                   + " stream (by defaultReadObject or 
readFields)");
+      throw new NotActiveException("readFields called but fields already read 
from"
+                                  + " stream (by defaultReadObject or 
readFields)");
 
     final ObjectStreamClass clazz = this.currentObjectStreamClass;
     final byte[] prim_field_data = new byte[clazz.primFieldSize];
@@ -1068,20 +1075,20 @@
     // Apparently Block data is not used with GetField as per
     // empirical evidence against JDK 1.2.  Also see Mauve test
     // java.io.ObjectInputOutput.Test.GetPutField.
-    boolean oldmode = setBlockDataMode (false);
-    readFully (prim_field_data);
+    boolean oldmode = setBlockDataMode(false);
+    readFully(prim_field_data);
     for (int i = 0; i < objs.length; ++ i)
-      objs[i] = readObject ();
-    setBlockDataMode (oldmode);
+      objs[i] = readObject();
+    setBlockDataMode(oldmode);
 
     prereadFields = new GetField()
       {
-       public ObjectStreamClass getObjectStreamClass ()
+       public ObjectStreamClass getObjectStreamClass()
        {
          return clazz;
        }
 
-       public boolean defaulted (String name)
+       public boolean defaulted(String name)
          throws IOException, IllegalArgumentException
        {
          ObjectStreamField f = clazz.getField(name);
@@ -1107,69 +1114,69 @@
            }
          catch (NoSuchFieldException e)
            {
-             throw new IllegalArgumentException (e.getMessage());
+             throw new IllegalArgumentException(e.getMessage());
            }
        }
 
-       public boolean get (String name, boolean defvalue)
+       public boolean get(String name, boolean defvalue)
          throws IOException, IllegalArgumentException
        {
-         ObjectStreamField field = getField (name, Boolean.TYPE);
+         ObjectStreamField field = getField(name, Boolean.TYPE);
 
          if (field == null)
            return defvalue;
 
-         return prim_field_data[field.getOffset ()] == 0 ? false : true;
+         return prim_field_data[field.getOffset()] == 0 ? false : true;
        }
 
-       public char get (String name, char defvalue)
+       public char get(String name, char defvalue)
          throws IOException, IllegalArgumentException
        {
-         ObjectStreamField field = getField (name, Character.TYPE);
+         ObjectStreamField field = getField(name, Character.TYPE);
 
          if (field == null)
            return defvalue;
 
-         int off = field.getOffset ();
+         int off = field.getOffset();
 
          return (char)(((prim_field_data[off++] & 0xFF) << 8)
                        | (prim_field_data[off] & 0xFF));
        }
 
-       public byte get (String name, byte defvalue)
+       public byte get(String name, byte defvalue)
          throws IOException, IllegalArgumentException
        {
-         ObjectStreamField field = getField (name, Byte.TYPE);
+         ObjectStreamField field = getField(name, Byte.TYPE);
 
          if (field == null)
            return defvalue;
 
-         return prim_field_data[field.getOffset ()];
+         return prim_field_data[field.getOffset()];
        }
 
-       public short get (String name, short defvalue)
+       public short get(String name, short defvalue)
          throws IOException, IllegalArgumentException
        {
-         ObjectStreamField field = getField (name, Short.TYPE);
+         ObjectStreamField field = getField(name, Short.TYPE);
 
          if (field == null)
            return defvalue;
 
-         int off = field.getOffset ();
+         int off = field.getOffset();
 
          return (short)(((prim_field_data[off++] & 0xFF) << 8)
                         | (prim_field_data[off] & 0xFF));
        }
 
-       public int get (String name, int defvalue)
+       public int get(String name, int defvalue)
          throws IOException, IllegalArgumentException
        {
-         ObjectStreamField field = getField (name, Integer.TYPE);
+         ObjectStreamField field = getField(name, Integer.TYPE);
 
          if (field == null)
            return defvalue;
 
-         int off = field.getOffset ();
+         int off = field.getOffset();
 
          return ((prim_field_data[off++] & 0xFF) << 24)
            | ((prim_field_data[off++] & 0xFF) << 16)
@@ -1177,15 +1184,15 @@
            | (prim_field_data[off] & 0xFF);
        }
 
-       public long get (String name, long defvalue)
+       public long get(String name, long defvalue)
          throws IOException, IllegalArgumentException
        {
-         ObjectStreamField field = getField (name, Long.TYPE);
+         ObjectStreamField field = getField(name, Long.TYPE);
 
          if (field == null)
            return defvalue;
 
-         int off = field.getOffset ();
+         int off = field.getOffset();
 
          return (long)(((prim_field_data[off++] & 0xFF) << 56)
                        | ((prim_field_data[off++] & 0xFF) << 48)
@@ -1197,31 +1204,31 @@
                        | (prim_field_data[off] & 0xFF));
        }
 
-       public float get (String name, float defvalue)
+       public float get(String name, float defvalue)
          throws IOException, IllegalArgumentException
        {
-         ObjectStreamField field = getField (name, Float.TYPE);
+         ObjectStreamField field = getField(name, Float.TYPE);
 
          if (field == null)
            return defvalue;
 
-         int off = field.getOffset ();
+         int off = field.getOffset();
 
-         return Float.intBitsToFloat (((prim_field_data[off++] & 0xFF) << 24)
-                                      | ((prim_field_data[off++] & 0xFF) << 16)
-                                      | ((prim_field_data[off++] & 0xFF) << 8)
-                                      | (prim_field_data[off] & 0xFF));
+         return Float.intBitsToFloat(((prim_field_data[off++] & 0xFF) << 24)
+                                     | ((prim_field_data[off++] & 0xFF) << 16)
+                                     | ((prim_field_data[off++] & 0xFF) << 8)
+                                     | (prim_field_data[off] & 0xFF));
        }
 
-       public double get (String name, double defvalue)
+       public double get(String name, double defvalue)
          throws IOException, IllegalArgumentException
        {
-         ObjectStreamField field = getField (name, Double.TYPE);
+         ObjectStreamField field = getField(name, Double.TYPE);
 
          if (field == null)
            return defvalue;
 
-         int off = field.getOffset ();
+         int off = field.getOffset();
 
          return Double.longBitsToDouble
            ( (long) (((prim_field_data[off++] & 0xFF) << 56)
@@ -1234,22 +1241,22 @@
                      | (prim_field_data[off] & 0xFF)));
        }
 
-       public Object get (String name, Object defvalue)
+       public Object get(String name, Object defvalue)
          throws IOException, IllegalArgumentException
        {
          ObjectStreamField field =
-           getField (name, defvalue == null ? null : defvalue.getClass ());
+           getField(name, defvalue == null ? null : defvalue.getClass ());
 
          if (field == null)
            return defvalue;
 
-         return objs[field.getOffset ()];
+         return objs[field.getOffset()];
        }
 
-       private ObjectStreamField getField (String name, Class type)
+       private ObjectStreamField getField(String name, Class type)
          throws IllegalArgumentException
        {
-         ObjectStreamField field = clazz.getField (name);
+         ObjectStreamField field = clazz.getField(name);
          boolean illegal = false;
 
          try
@@ -1300,7 +1307,7 @@
               */
              try
                {
-                 Field f = clazz.forClass().getDeclaredField (name);
+                 Field f = clazz.forClass().getDeclaredField(name);
                  if (Modifier.isTransient(f.getModifiers()))
                    throw new IllegalArgumentException
                      ("no such field (non transient) " + name);
@@ -1333,12 +1340,12 @@
    *
    * @see #readObjectOverride()
    */
-  protected ObjectInputStream ()
+  protected ObjectInputStream()
     throws IOException, SecurityException
   {
-    SecurityManager sec_man = System.getSecurityManager ();
+    SecurityManager sec_man = System.getSecurityManager();
     if (sec_man != null)
-      sec_man.checkPermission (SUBCLASS_IMPLEMENTATION_PERMISSION);
+      sec_man.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
     this.useSubclassMethod = true;
   }
 
@@ -1351,10 +1358,10 @@
    *
    * @see #ObjectInputStream()
    */
-  protected Object readObjectOverride ()
+  protected Object readObjectOverride()
     throws ClassNotFoundException, IOException, OptionalDataException
   {
-    throw new IOException ("Subclass of ObjectInputStream must implement 
readObjectOverride");
+    throw new IOException("Subclass of ObjectInputStream must implement 
readObjectOverride");
   }
 
   /**
@@ -1363,14 +1370,14 @@
    * @param obj The object for which we want a new handle.
    * @return A valid handle for the specified object.
    */
-  private int assignNewHandle (Object obj)
+  private int assignNewHandle(Object obj)
   {
-    this.objectLookupTable.put (new Integer (this.nextOID),
-                               new ObjectIdentityWrapper (obj));
+    this.objectLookupTable.put(new Integer(this.nextOID),
+                              new ObjectIdentityWrapper(obj));
     return this.nextOID++;
   }
 
-  private Object processResolution (Object obj, int handle)
+  private Object processResolution(Object obj, int handle)
     throws IOException
   {
     if (obj instanceof Serializable)
@@ -1380,7 +1387,7 @@
          {
            Class classArgs[] = {};
            m = getMethod(obj.getClass(), "readResolve", classArgs);
-           obj = m.invoke (obj, new Object[] {});      
+           obj = m.invoke(obj, new Object[] {});       
          }
        catch (NoSuchMethodException ignore)
          {
@@ -1394,42 +1401,42 @@
       }
 
     if (this.resolveEnabled)
-      obj = resolveObject (obj);
+      obj = resolveObject(obj);
 
-    this.objectLookupTable.put (new Integer (handle),
-                               new ObjectIdentityWrapper (obj));
+    this.objectLookupTable.put(new Integer(handle),
+                              new ObjectIdentityWrapper(obj));
 
     return obj;
   }
 
-  private void clearHandles ()
+  private void clearHandles()
   {
-    this.objectLookupTable.clear ();
+    this.objectLookupTable.clear();
     this.nextOID = baseWireHandle;
   }
 
-  private void readNextBlock () throws IOException
+  private void readNextBlock() throws IOException
   {
-    readNextBlock (this.realInputStream.readByte ());
+    readNextBlock(this.realInputStream.readByte());
   }
 
-  private void readNextBlock (byte marker) throws IOException
+  private void readNextBlock(byte marker) throws IOException
   {
     if (marker == TC_BLOCKDATA)
       {
-       dumpElement ("BLOCK DATA SIZE=");
-       this.blockDataBytes = this.realInputStream.readUnsignedByte ();
+       dumpElement("BLOCK DATA SIZE=");
+       this.blockDataBytes = this.realInputStream.readUnsignedByte();
        dumpElementln (Integer.toString(this.blockDataBytes));
       }
     else if (marker == TC_BLOCKDATALONG)
       {
-       dumpElement ("BLOCK DATA LONG SIZE=");
-       this.blockDataBytes = this.realInputStream.readInt ();
+       dumpElement("BLOCK DATA LONG SIZE=");
+       this.blockDataBytes = this.realInputStream.readInt();
        dumpElementln (Integer.toString(this.blockDataBytes));
       }
     else
       {
-       throw new EOFException ("Attempt to read primitive data, but no data 
block is active.");
+       throw new EOFException("Attempt to read primitive data, but no data 
block is active.");
       }
 
     if (this.blockData.length < this.blockDataBytes)
@@ -1442,62 +1449,62 @@
   private void readArrayElements (Object array, Class clazz)
     throws ClassNotFoundException, IOException
   {
-    if (clazz.isPrimitive ())
+    if (clazz.isPrimitive())
       {
        if (clazz == Boolean.TYPE)
          {
            boolean[] cast_array = (boolean[])array;
            for (int i=0; i < cast_array.length; i++)
-             cast_array[i] = this.realInputStream.readBoolean ();
+             cast_array[i] = this.realInputStream.readBoolean();
            return;
          }
        if (clazz == Byte.TYPE)
          {
            byte[] cast_array = (byte[])array;
            for (int i=0; i < cast_array.length; i++)
-             cast_array[i] = this.realInputStream.readByte ();
+             cast_array[i] = this.realInputStream.readByte();
            return;
          }
        if (clazz == Character.TYPE)
          {
            char[] cast_array = (char[])array;
            for (int i=0; i < cast_array.length; i++)
-             cast_array[i] = this.realInputStream.readChar ();
+             cast_array[i] = this.realInputStream.readChar();
            return;
          }
        if (clazz == Double.TYPE)
          {
            double[] cast_array = (double[])array;
            for (int i=0; i < cast_array.length; i++)
-             cast_array[i] = this.realInputStream.readDouble ();
+             cast_array[i] = this.realInputStream.readDouble();
            return;
          }
        if (clazz == Float.TYPE)
          {
            float[] cast_array = (float[])array;
            for (int i=0; i < cast_array.length; i++)
-             cast_array[i] = this.realInputStream.readFloat ();
+             cast_array[i] = this.realInputStream.readFloat();
            return;
          }
        if (clazz == Integer.TYPE)
          {
            int[] cast_array = (int[])array;
            for (int i=0; i < cast_array.length; i++)
-             cast_array[i] = this.realInputStream.readInt ();
+             cast_array[i] = this.realInputStream.readInt();
            return;
          }
        if (clazz == Long.TYPE)
          {
            long[] cast_array = (long[])array;
            for (int i=0; i < cast_array.length; i++)
-             cast_array[i] = this.realInputStream.readLong ();
+             cast_array[i] = this.realInputStream.readLong();
            return;
          }
        if (clazz == Short.TYPE)
          {
            short[] cast_array = (short[])array;
            for (int i=0; i < cast_array.length; i++)
-             cast_array[i] = this.realInputStream.readShort ();
+             cast_array[i] = this.realInputStream.readShort();
            return;
          }
       }
@@ -1505,7 +1512,7 @@
       {
        Object[] cast_array = (Object[])array;
        for (int i=0; i < cast_array.length; i++)
-         cast_array[i] = readObject ();
+         cast_array[i] = readObject();
       }
   }
 
@@ -1535,7 +1542,7 @@
        else
          {
            stream_field = stream_fields[stream_idx];
-           type = stream_field.getType ();
+           type = stream_field.getType();
          }
 
        if (real_idx == real_fields.length)
@@ -1543,8 +1550,8 @@
        else
          {
            real_field = real_fields[real_idx];
-           type = real_field.getType ();
-           field_name = real_field.getName ();
+           type = real_field.getType();
+           field_name = real_field.getName();
          }
 
        if (set_value && !default_initialize)
@@ -1583,82 +1590,82 @@
            if (type == Boolean.TYPE)
              {
                boolean value =
-                 default_initialize ? false : this.realInputStream.readBoolean 
();
+                 default_initialize ? false : 
this.realInputStream.readBoolean();
                if (!default_initialize && set_value)
-                 dumpElementln ("  " + field_name + ": " + value);
+                 dumpElementln("  " + field_name + ": " + value);
                if (set_value)
-                 setBooleanField (obj, stream_osc.forClass (), field_name, 
value);
+                 setBooleanField(obj, stream_osc.forClass(), field_name, 
value);
              }
            else if (type == Byte.TYPE)
              {
                byte value =
-                 default_initialize ? 0 : this.realInputStream.readByte ();
+                 default_initialize ? 0 : this.realInputStream.readByte();
                if (!default_initialize && set_value)
-                 dumpElementln ("  " + field_name + ": " + value);
+                 dumpElementln("  " + field_name + ": " + value);
                if (set_value)
-                 setByteField (obj, stream_osc.forClass (), field_name, value);
+                 setByteField(obj, stream_osc.forClass(), field_name, value);
              }
            else if (type == Character.TYPE)
              {
                char value =
-                 default_initialize ? (char)0 : this.realInputStream.readChar 
();
+                 default_initialize ? (char)0 : 
this.realInputStream.readChar();
                if (!default_initialize && set_value)
-                 dumpElementln ("  " + field_name + ": " + value);
+                 dumpElementln("  " + field_name + ": " + value);
                if (set_value)
-                 setCharField (obj, stream_osc.forClass (), field_name, value);
+                 setCharField(obj, stream_osc.forClass(), field_name, value);
              }
            else if (type == Double.TYPE)
              {
                double value =
-                 default_initialize ? 0 : this.realInputStream.readDouble ();
+                 default_initialize ? 0 : this.realInputStream.readDouble();
                if (!default_initialize && set_value)
-                 dumpElementln ("  " + field_name + ": " + value);
+                 dumpElementln("  " + field_name + ": " + value);
                if (set_value)
-                 setDoubleField (obj, stream_osc.forClass (), field_name, 
value);
+                 setDoubleField(obj, stream_osc.forClass(), field_name, value);
              }
            else if (type == Float.TYPE)
              {
                float value =
-                 default_initialize ? 0 : this.realInputStream.readFloat ();
+                 default_initialize ? 0 : this.realInputStream.readFloat();
                if (!default_initialize && set_value)
-                 dumpElementln ("  " + field_name + ": " + value);
+                 dumpElementln("  " + field_name + ": " + value);
                if (set_value)
-                 setFloatField (obj, stream_osc.forClass (), field_name, 
value);
+                 setFloatField(obj, stream_osc.forClass(), field_name, value);
              }
            else if (type == Integer.TYPE)
              {
                int value =
-                 default_initialize ? 0 : this.realInputStream.readInt ();
+                 default_initialize ? 0 : this.realInputStream.readInt();
                if (!default_initialize && set_value)
-                 dumpElementln ("  " + field_name + ": " + value);
+                 dumpElementln("  " + field_name + ": " + value);
                if (set_value)
-                 setIntField (obj, stream_osc.forClass (), field_name, value);
+                 setIntField(obj, stream_osc.forClass(), field_name, value);
              }
            else if (type == Long.TYPE)
              {
                long value =
-                 default_initialize ? 0 : this.realInputStream.readLong ();
+                 default_initialize ? 0 : this.realInputStream.readLong();
                if (!default_initialize && set_value)
-                 dumpElementln ("  " + field_name + ": " + value);
+                 dumpElementln("  " + field_name + ": " + value);
                if (set_value)
-                 setLongField (obj, stream_osc.forClass (), field_name, value);
+                 setLongField(obj, stream_osc.forClass(), field_name, value);
              }
            else if (type == Short.TYPE)
              {
                short value =
-                 default_initialize ? (short)0 : 
this.realInputStream.readShort ();
+                 default_initialize ? (short)0 : 
this.realInputStream.readShort();
                if (!default_initialize && set_value)
-                 dumpElementln ("  " + field_name + ": " + value);
+                 dumpElementln("  " + field_name + ": " + value);
                if (set_value)
-                 setShortField (obj, stream_osc.forClass (), field_name, 
value);
+                 setShortField(obj, stream_osc.forClass(), field_name, value);
              }
            else
              {
                Object value =
-                 default_initialize ? null : readObject ();
+                 default_initialize ? null : readObject();
                if (set_value)
-                 setObjectField (obj, stream_osc.forClass (), field_name,
-                                 real_field.getTypeString (), value);
+                 setObjectField(obj, stream_osc.forClass(), field_name,
+                                 real_field.getTypeString(), value);
              }
          }
        catch (NoSuchFieldError e)
@@ -1699,20 +1706,20 @@
 
   // runs all registered ObjectInputValidations in prioritized order
   // on OBJ
-  private void invokeValidators () throws InvalidObjectException
+  private void invokeValidators() throws InvalidObjectException
   {
-    Object[] validators = new Object[this.validators.size ()];
+    Object[] validators = new Object[this.validators.size()];
     this.validators.copyInto (validators);
     Arrays.sort (validators);
 
     try
       {
        for (int i=0; i < validators.length; i++)
-         ((ObjectInputValidation)validators[i]).validateObject ();
+         ((ObjectInputValidation)validators[i]).validateObject();
       }
     finally
       {
-       this.validators.removeAllElements ();
+       this.validators.removeAllElements();
       }
   }
 
@@ -1785,7 +1792,7 @@
        Class classArgs[] = {ObjectInputStream.class};
        Method m = getMethod (klass, "readObject", classArgs);
        Object args[] = {this};
-       m.invoke (obj, args);
+       m.invoke(obj, args);
       }
     catch (NoSuchMethodException nsme)
       {
@@ -1800,12 +1807,12 @@
        if (exception instanceof IOException)
          throw (IOException) exception;
 
-       throw new IOException ("Exception thrown from readObject() on " +
+       throw new IOException("Exception thrown from readObject() on " +
                               klass + ": " + exception.getClass().getName());
       }
     catch (Exception x)
       {
-       throw new IOException ("Failure invoking readObject() on " +
+       throw new IOException("Failure invoking readObject() on " +
                               klass + ": " + x.getClass().getName());
       }
 
@@ -1829,13 +1836,13 @@
    * @throws InvalidClassException if the specified field has not the required 
type.
    * @throws IOException if there is no field of that name in the specified 
class.
    */
-  private void setBooleanField (Object obj, Class klass, String field_name,
+  private void setBooleanField(Object obj, Class klass, String field_name,
                                boolean val) throws IOException, 
InvalidClassException
   {
     try
       {
-       Field f = getField (klass, field_name);
-       f.setBoolean (obj, val);
+       Field f = getField(klass, field_name);
+       f.setBoolean(obj, val);
       }
     catch (IllegalArgumentException _)
       {
@@ -1857,13 +1864,13 @@
    * @throws InvalidClassException if the specified field has not the required 
type.
    * @throws IOException if there is no field of that name in the specified 
class.
    */
-  private void setByteField (Object obj, Class klass, String field_name,
+  private void setByteField(Object obj, Class klass, String field_name,
                             byte val) throws IOException, InvalidClassException
   {
     try
       {
-       Field f = getField (klass, field_name);
-       f.setByte (obj, val);
+       Field f = getField(klass, field_name);
+       f.setByte(obj, val);
       }
     catch (IllegalArgumentException _)
       {
@@ -1885,13 +1892,13 @@
    * @throws InvalidClassException if the specified field has not the required 
type.
    * @throws IOException if there is no field of that name in the specified 
class.
    */
-  private void setCharField (Object obj, Class klass, String field_name,
+  private void setCharField(Object obj, Class klass, String field_name,
                             char val) throws IOException, InvalidClassException
   {
     try
       {
-       Field f = getField (klass, field_name);
-       f.setChar (obj, val);
+       Field f = getField(klass, field_name);
+       f.setChar(obj, val);
       }
     catch (IllegalArgumentException _)
       {
@@ -1913,13 +1920,13 @@
    * @throws InvalidClassException if the specified field has not the required 
type.
    * @throws IOException if there is no field of that name in the specified 
class.
    */
-  private void setDoubleField (Object obj, Class klass, String field_name,
+  private void setDoubleField(Object obj, Class klass, String field_name,
                               double val) throws IOException, 
InvalidClassException
   {
     try
       {
-       Field f = getField (klass, field_name);
-       f.setDouble (obj, val);
+       Field f = getField(klass, field_name);
+       f.setDouble(obj, val);
       }
     catch (IllegalArgumentException _)
       {
@@ -1941,13 +1948,13 @@
    * @throws InvalidClassException if the specified field has not the required 
type.
    * @throws IOException if there is no field of that name in the specified 
class.
    */
-  private void setFloatField (Object obj, Class klass, String field_name,
+  private void setFloatField(Object obj, Class klass, String field_name,
                              float val) throws IOException, 
InvalidClassException
   {
     try
       {
-       Field f = getField (klass, field_name);
-       f.setFloat (obj, val);
+       Field f = getField(klass, field_name);
+       f.setFloat(obj, val);
       }
     catch (IllegalArgumentException _)
       {
@@ -1969,13 +1976,13 @@
    * @throws InvalidClassException if the specified field has not the required 
type.
    * @throws IOException if there is no field of that name in the specified 
class.
    */
-  private void setIntField (Object obj, Class klass, String field_name,
+  private void setIntField(Object obj, Class klass, String field_name,
                            int val) throws IOException, InvalidClassException
   {
     try
       {
-       Field f = getField (klass, field_name);
-       f.setInt (obj, val);
+       Field f = getField(klass, field_name);
+       f.setInt(obj, val);
       }
     catch (IllegalArgumentException _)
       {
@@ -1997,13 +2004,13 @@
    * @throws InvalidClassException if the specified field has not the required 
type.
    * @throws IOException if there is no field of that name in the specified 
class.
    */
-  private void setLongField (Object obj, Class klass, String field_name,
+  private void setLongField(Object obj, Class klass, String field_name,
                             long val) throws IOException, InvalidClassException
   {
     try
       {
-       Field f = getField (klass, field_name);
-       f.setLong (obj, val);
+       Field f = getField(klass, field_name);
+       f.setLong(obj, val);
       }
     catch (IllegalArgumentException _)
       {
@@ -2025,13 +2032,13 @@
    * @throws InvalidClassException if the specified field has not the required 
type.
    * @throws IOException if there is no field of that name in the specified 
class.
    */
-  private void setShortField (Object obj, Class klass, String field_name,
+  private void setShortField(Object obj, Class klass, String field_name,
                              short val) throws IOException, 
InvalidClassException
   {
     try
       {
-       Field f = getField (klass, field_name);
-       f.setShort (obj, val);
+       Field f = getField(klass, field_name);
+       f.setShort(obj, val);
       }
     catch (IllegalArgumentException _)
       {
@@ -2053,25 +2060,26 @@
    * @throws InvalidClassException if the specified field has not the required 
type.
    * @throws IOException if there is no field of that name in the specified 
class.
    */
-  private void setObjectField (Object obj, Class klass, String field_name,
+  private void setObjectField(Object obj, Class klass, String field_name,
                               String type_code, Object val) throws 
IOException, InvalidClassException
   {
     try
       {
-       Field f = getField (klass, field_name);
+       Field f = getField(klass, field_name);
        ObjectStreamField of = new ObjectStreamField(field_name, f.getType());
        
        if (of.getTypeString() == null ||
            !of.getTypeString().equals(type_code))
           throw new InvalidClassException("incompatible field type for " + 
klass.getName() + "." + field_name);
-       f.set (obj, val);
+       f.set(obj, val);
       }
     catch (InvalidClassException e)
       {
        throw e;
       }
     catch (Exception _)
-      {}
+      {
+      }
   }
 
   private static final int BUFFER_SIZE = 1024;
Index: java/io/ObjectOutputStream.java
===================================================================
RCS file: /cvsroot/classpath/classpath/java/io/ObjectOutputStream.java,v
retrieving revision 1.41
retrieving revision 1.42
diff -u -r1.41 -r1.42
--- java/io/ObjectOutputStream.java     28 Dec 2003 17:18:24 -0000      1.41
+++ java/io/ObjectOutputStream.java     28 Dec 2003 18:12:43 -0000      1.42
@@ -132,18 +132,18 @@
    */
   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();
   }
 
   /**
@@ -168,16 +168,16 @@
    * @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;
@@ -188,49 +188,49 @@
          {
            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;
              }
 
@@ -238,7 +238,7 @@
                && ! replaceDone)
              {
                replacedObject = obj;
-
+               
                if (obj instanceof Serializable)
                  {
                    Method m = null;
@@ -250,7 +250,7 @@
                        // 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)
                      {
@@ -262,55 +262,55 @@
                      {
                      }
                  }
-
+               
                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);
+                 setBlockDataMode(true);
                
-               ((Externalizable)obj).writeExternal (this);
+               ((Externalizable)obj).writeExternal(this);
                
                if (protocolVersion == PROTOCOL_VERSION_2)
                  {
-                   setBlockDataMode (false);
-                   realOutput.writeByte (TC_ENDBLOCKDATA);
+                   setBlockDataMode(false);
+                   realOutput.writeByte(TC_ENDBLOCKDATA);
                  }
 
                break;
@@ -320,22 +320,22 @@
              {
                currentObject = obj;
                ObjectStreamClass[] hierarchy =
-                 ObjectStreamClass.getObjectStreamClasses (clazz);
+                 ObjectStreamClass.getObjectStreamClasses(clazz);
                
-               for (int i=0; i < hierarchy.length; i++)
+               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;
@@ -344,7 +344,7 @@
                break;
              }
 
-           throw new NotSerializableException (clazz.getName ());
+           throw new NotSerializableException(clazz.getName ());
          } // end pseudo-loop
       }
     catch (ObjectStreamException ose)
@@ -354,17 +354,18 @@
       }
     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 was being written to stream.");
+           throw new StreamCorruptedException
+             ("Exception " + ioe + " thrown while exception was being written 
to stream.");
          }
 
        reset (true);
@@ -373,224 +374,227 @@
     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 putFields 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;
@@ -600,20 +604,18 @@
 
 
   /**
-     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
@@ -625,11 +627,11 @@
    *
    * @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;
   }
 
@@ -646,10 +648,11 @@
    * @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");
   }
 
 
@@ -661,48 +664,48 @@
     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);
   }
 
 
@@ -711,8 +714,8 @@
    */
   public void flush () throws IOException
   {
-    drain ();
-    realOutput.flush ();
+    drain();
+    realOutput.flush();
   }
 
 
@@ -723,14 +726,14 @@
    * @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;
   }
 
@@ -738,28 +741,28 @@
   /**
    * @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);
   }
 
 
@@ -768,79 +771,79 @@
    */
   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);
   }
 
 
@@ -868,14 +871,14 @@
     public abstract void write (ObjectOutput out) throws IOException;
   }
 
-  public PutField putFields () throws IOException
+  public PutField putFields() throws IOException
   {
     if (currentPutField != null)
       return currentPutField;
 
-    markFieldsWritten ();
+    markFieldsWritten();
 
-    currentPutField = new PutField ()
+    currentPutField = new PutField()
       {
        private byte[] prim_field_data
          = new byte[currentObjectStreamClass.primFieldSize];
@@ -885,46 +888,46 @@
        private ObjectStreamField getField (String name)
        {
          ObjectStreamField field
-           = currentObjectStreamClass.getField (name);
+           = currentObjectStreamClass.getField(name);
          
          if (field == null)
            throw new IllegalArgumentException("no such serializable field " + 
name);
          
          return field;
        }
-
-       public void put (String name, boolean value)
+       
+       public void put(String name, boolean value)
        {
-         ObjectStreamField field = getField (name);
+         ObjectStreamField field = getField(name);
 
-         checkType (field, 'Z');
+         checkType(field, 'Z');
          prim_field_data[field.getOffset ()] = (byte)(value ? 1 : 0);
        }
 
-       public void put (String name, byte value)
+       public void put(String name, byte value)
        {
-         ObjectStreamField field = getField (name);
+         ObjectStreamField field = getField(name);
 
-         checkType (field, 'B');
-         prim_field_data[field.getOffset ()] = value;
+         checkType(field, 'B');
+         prim_field_data[field.getOffset()] = value;
        }
 
-       public void put (String name, char value)
+       public void put(String name, char value)
        {
-         ObjectStreamField field = getField (name);
+         ObjectStreamField field = getField(name);
 
-         checkType (field, 'C');
-         int off = field.getOffset ();
+         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)
+       public void put(String name, double value)
        {
          ObjectStreamField field = getField (name);
 
-         checkType (field, 'D');
-         int off = field.getOffset ();
+         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);
@@ -936,35 +939,35 @@
          prim_field_data[off] = (byte)l_value;
        }
 
-       public void put (String name, float value)
+       public void put(String name, float value)
        {
-         ObjectStreamField field = getField (name);
+         ObjectStreamField field = getField(name);
 
-         checkType (field, 'F');
-         int off = field.getOffset ();
-         int i_value = Float.floatToIntBits (value);
+         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)
+       public void put(String name, int value)
        {
-         ObjectStreamField field = getField (name);
-         checkType (field, 'I');
-         int off = field.getOffset ();
+         ObjectStreamField field = 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)
+       public void put(String name, long value)
        {
-         ObjectStreamField field = getField (name);
-         checkType (field, 'J');
-         int off = field.getOffset ();
+         ObjectStreamField field = 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);
@@ -975,44 +978,44 @@
          prim_field_data[off] = (byte)value;
        }
 
-       public void put (String name, short value)
+       public void put(String name, short value)
        {
-         ObjectStreamField field = getField (name);
-         checkType (field, 'S');
-         int off = field.getOffset ();
+         ObjectStreamField field = 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)
+       public void put(String name, Object value)
        {
-         ObjectStreamField field = getField (name);
+         ObjectStreamField field = getField(name);
 
          if (value != null &&
-             ! field.getType ().isAssignableFrom (value.getClass ()))      
-           throw new IllegalArgumentException ("Class " + value.getClass() +
-                                               " cannot be cast to " + 
field.getType());
-         objs[field.getOffset ()] = value;
+             ! field.getType().isAssignableFrom(value.getClass ()))        
+           throw new IllegalArgumentException("Class " + value.getClass() +
+                                              " cannot be cast to " + 
field.getType());
+         objs[field.getOffset()] = value;
        }
 
-       public void write (ObjectOutput out) throws IOException
+       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);
+         boolean oldmode = setBlockDataMode(false);
+         out.write(prim_field_data);
          for (int i = 0; i < objs.length; ++ i)
-           out.writeObject (objs[i]);
-         setBlockDataMode (oldmode);
+           out.writeObject(objs[i]);
+         setBlockDataMode(oldmode);
        }
 
-       private void checkType (ObjectStreamField field, char type)
+       private void checkType(ObjectStreamField field, char type)
          throws IllegalArgumentException
        {
-         if (TypeSignature.getEncodingOfClass (field.getType ()).charAt (0)
+         if (TypeSignature.getEncodingOfClass(field.getType()).charAt(0)
              != type)
-           throw new IllegalArgumentException ();
+           throw new IllegalArgumentException();
        }
       };
     // end PutFieldImpl
@@ -1021,179 +1024,180 @@
   }
 
 
-  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");
 
-    currentPutField.write (this);
+    currentPutField.write(this);
   }
 
 
   // 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;
@@ -1211,7 +1215,7 @@
   }
 
 
-  private void callWriteMethod (Object obj, ObjectStreamClass osc)
+  private void callWriteMethod(Object obj, ObjectStreamClass osc)
     throws IOException
   {
     Class klass = osc.forClass();
@@ -1219,9 +1223,9 @@
     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)
       {
@@ -1237,33 +1241,34 @@
          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 (IllegalArgumentException _)
       {
-       throw new InvalidClassException("invalid requested type for field " + 
field_name + " in class " + klass.getName());
+       throw new InvalidClassException
+         ("invalid requested type for field " + field_name + " in class " + 
klass.getName());
       }
     catch (IOException e)
       {
@@ -1271,7 +1276,7 @@
       }
     catch (Exception _)
       {
-       throw new IOException ();
+       throw new IOException("Unexpected exception " + _);
       }
   }
 
@@ -1286,7 +1291,8 @@
       }
     catch (IllegalArgumentException _)
       {
-       throw new InvalidClassException("invalid requested type for field " + 
field_name + " in class " + klass.getName());
+       throw new InvalidClassException
+         ("invalid requested type for field " + field_name + " in class " + 
klass.getName());
       }
     catch (IOException e)
       {
@@ -1294,7 +1300,7 @@
       }
     catch (Exception _)
       {
-       throw new IOException ();
+       throw new IOException("Unexpected exception " + _);
       }    
   }
 
@@ -1309,7 +1315,8 @@
       }
     catch (IllegalArgumentException _)
       {
-       throw new InvalidClassException("invalid requested type for field " + 
field_name + " in class " + klass.getName());
+       throw new InvalidClassException
+         ("invalid requested type for field " + field_name + " in class " + 
klass.getName());
       }
     catch (IOException e)
       {
@@ -1317,7 +1324,7 @@
       }
     catch (Exception _)
       {
-       throw new IOException ();
+       throw new IOException("Unexpected exception " + _);
       }    
   }
 
@@ -1332,7 +1339,8 @@
       }
     catch (IllegalArgumentException _)
       {
-       throw new InvalidClassException("invalid requested type for field " + 
field_name + " in class " + klass.getName());
+       throw new InvalidClassException
+         ("invalid requested type for field " + field_name + " in class " + 
klass.getName());
       }
     catch (IOException e)
       {
@@ -1340,7 +1348,7 @@
       }
     catch (Exception _)
       {
-       throw new IOException ();
+       throw new IOException("Unexpected exception " + _);
       }    
   }
 
@@ -1355,7 +1363,8 @@
       }
     catch (IllegalArgumentException _)
       {
-       throw new InvalidClassException("invalid requested type for field " + 
field_name + " in class " + klass.getName());
+       throw new InvalidClassException
+         ("invalid requested type for field " + field_name + " in class " + 
klass.getName());
       }
     catch (IOException e)
       {
@@ -1363,8 +1372,8 @@
       }
     catch (Exception _)
       {
-       throw new IOException ();
-      }    
+       throw new IOException("Unexpected exception " + _);
+      }
   }
 
   private int getIntField (Object obj, Class klass, String field_name)
@@ -1378,7 +1387,8 @@
       }
     catch (IllegalArgumentException _)
       {
-       throw new InvalidClassException("invalid requested type for field " + 
field_name + " in class " + klass.getName());
+       throw new InvalidClassException
+         ("invalid requested type for field " + field_name + " in class " + 
klass.getName());
       }
     catch (IOException e)
       {
@@ -1386,8 +1396,8 @@
       }
     catch (Exception _)
       {
-       throw new IOException ();
-      }    
+       throw new IOException("Unexpected exception " + _);
+      }
   }
 
   private long getLongField (Object obj, Class klass, String field_name)
@@ -1401,7 +1411,8 @@
       }
     catch (IllegalArgumentException _)
       {
-       throw new InvalidClassException("invalid requested type for field " + 
field_name + " in class " + klass.getName());
+       throw new InvalidClassException
+         ("invalid requested type for field " + field_name + " in class " + 
klass.getName());
       }
     catch (IOException e)
       {
@@ -1409,7 +1420,7 @@
       }
     catch (Exception _)
       {
-       throw new IOException ();
+       throw new IOException("Unexpected exception " + _);
       }    
   }
 
@@ -1424,7 +1435,8 @@
       }
     catch (IllegalArgumentException _)
       {
-       throw new InvalidClassException("invalid requested type for field " + 
field_name + " in class " + klass.getName());
+       throw new InvalidClassException
+         ("invalid requested type for field " + field_name + " in class " + 
klass.getName());
       }
     catch (IOException e)
       {
@@ -1432,8 +1444,8 @@
       }
     catch (Exception _)
       {
-       throw new IOException ();
-      }    
+       throw new IOException("Unexpected exception " + _);
+      }
   }
 
   private Object getObjectField (Object obj, Class klass, String field_name,
@@ -1446,7 +1458,8 @@
 
        if (of.getTypeString() == null ||
            !of.getTypeString().equals(type_code))
-         throw new InvalidClassException("invalid type code for " + field_name 
+ " in class " + klass.getName());
+         throw new InvalidClassException
+           ("invalid type code for " + field_name + " in class " + 
klass.getName());
 
        Object o = f.get (obj);
        // FIXME: We should check the type_code here
@@ -1480,7 +1493,8 @@
       }
     catch (java.lang.NoSuchFieldException e)
       {
-       throw new InvalidClassException ("no field called " + name + " in class 
" + klass.getName());
+       throw new InvalidClassException
+         ("no field called " + name + " in class " + klass.getName());
       }
   }
 
@@ -1525,7 +1539,7 @@
   {
     if (Configuration.INIT_LOAD_LIBRARY)
       {
-        System.loadLibrary ("javaio");
+        System.loadLibrary("javaio");
       }
   }
 }
Index: java/io/ObjectStreamClass.java
===================================================================
RCS file: /cvsroot/classpath/classpath/java/io/ObjectStreamClass.java,v
retrieving revision 1.26
retrieving revision 1.27
diff -u -r1.26 -r1.27
--- java/io/ObjectStreamClass.java      28 Dec 2003 17:18:24 -0000      1.26
+++ java/io/ObjectStreamClass.java      28 Dec 2003 18:12:43 -0000      1.27
@@ -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 @@
 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 @@
    * 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 @@
   // 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 @@
   // 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 @@
    * @see #getSerialVersionUID()
    * @see #getName()
    */
-  public String toString ()
+  public String toString()
   {
     return "java.io.ObjectStreamClass< " + name + ", " + uid + " >";
   }
@@ -187,7 +187,7 @@
   //
   // 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 @@
   //
   // 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 @@
 
   // 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 @@
   // 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 @@
   // 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();
+
+       while (osc != null)
+         {
+           oscs.addElement (osc);
+           osc = osc.getSuper();
+         }
 
-      int count = oscs.size ();
-      ObjectStreamClass[] sorted_oscs = new ObjectStreamClass[ count ];
+       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 @@
   // 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 @@
    * @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,9 +322,9 @@
          }
       }
 
-    isProxyClass = clazz != null && Proxy.isProxyClass (clazz);
+    isProxyClass = clazz != null && Proxy.isProxyClass(clazz);
     this.superClass = superClass;
-    calculateOffsets ();
+    calculateOffsets();
     
     try
       {
@@ -345,47 +345,47 @@
 
        i = 0; j = 0; k = 0;
        while (i < fields.length && j < exportedFields.length)
-       {
-         int comp = fields[i].getName().compareTo 
(exportedFields[j].getName());
+         {
+           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 (comp < 0)
+       if (i < fields.length)
+         for (;i<fields.length;i++,k++)
            {
-             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++)
@@ -396,7 +396,7 @@
              }
        
        fields = new ObjectStreamField[k];
-       System.arraycopy (newFieldList, 0, fields, 0, k);
+       System.arraycopy(newFieldList, 0, fields, 0, k);
       }
     catch (NoSuchFieldException ignore)
       {
@@ -414,294 +414,300 @@
   }
 
 
-  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");
-       }
-
-      DigestOutputStream digest_out =
-       new DigestOutputStream (nullOutputStream, md);
-      DataOutputStream data_out = new DataOutputStream (digest_out);
-
-      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);
-
-      // 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 ()));
       }
-
-      // write class initializer method if present
-      if (VMObjectStreamClass.hasClassInitializer (cl))
+    catch (IllegalAccessException ignore)
       {
-       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++)
+    // cl didn't define serialVersionUID, so we have to compute it
+    try
       {
-       constructor = constructors[i];
-       modifiers = constructor.getModifiers ();
-       if (Modifier.isPrivate (modifiers))
-         continue;
+       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");
+         }
 
-       data_out.writeUTF ("<init>");
-       data_out.writeInt (modifiers);
+       DigestOutputStream digest_out =
+         new DigestOutputStream(nullOutputStream, md);
+       DataOutputStream data_out = new DataOutputStream(digest_out);
+
+       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);
+
+       // 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());
+         }
 
-       // the replacement of '/' with '.' was needed to make computed
-       // SUID's agree with those computed by JDK
-       data_out.writeUTF (
-         TypeSignature.getEncodingOfConstructor (constructor).replace 
('/','.'));
-      }
+       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()));
+         }
 
-      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;
+       // write class initializer method if present
+       if (VMObjectStreamClass.hasClassInitializer(cl))
+         {
+           data_out.writeUTF("<clinit>");
+           data_out.writeInt(Modifier.STATIC);
+           data_out.writeUTF("()V");
+         }
 
-       data_out.writeUTF (method.getName ());
-       data_out.writeInt (modifiers);
+       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('/','.'));
+         }
 
-       // 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);
+      }
   }
 
   /**
@@ -713,7 +719,7 @@
    * @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;
@@ -721,16 +727,16 @@
 
     // Use getDeclaredField rather than getField for the same reason
     // as above in getDefinedSUID.
-    Field f = clazz.getDeclaredField ("serialPersistentFields");
+    Field f = clazz.getDeclaredField("serialPersistentFields");
     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);
+    o = (ObjectStreamField[])f.get(null);
     
     if (o == null)
       return null;
@@ -743,10 +749,10 @@
 
   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 };
 
@@ -776,9 +782,9 @@
 // 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());
   }
 }
 
@@ -787,16 +793,16 @@
 // 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;
 
-    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;
   }

reply via email to

[Prev in Thread] Current Thread [Next in Thread]