public inbox for rhug-rhats@sourceware.org
 help / color / mirror / Atom feed
* gcj minor bug
@ 2002-12-13 13:26 Christophe Roux
  2002-12-13 13:48 ` Tom Tromey
  0 siblings, 1 reply; 2+ messages in thread
From: Christophe Roux @ 2002-12-13 13:26 UTC (permalink / raw)
  To: rhug-rhats

[-- Attachment #1: Type: text/plain, Size: 1093 bytes --]

I use Rhug as a java user, so I am not very aware of usage for submitting 
bugs for GCJ.
When trying to connect ot posgresql with pgsql-jdbc, I had a problem of 
database recognition with the Driver.
In fact, I discovered a bug in gcj by the way :
The class StringTokenizer, when returning all tokens ( also separators ), 
gives empty tokens for separators;
in fact, the code "substring( pos, ++pos )" return an empty string;
one's should have writen "substring( pos - 1, ++pos )" which return a single 
caracter for the separator.
I corrected the class for me, and I thought it would be great to give it to 
the community.
But I read the steps needed to contribute to gcj, and my reaction is :
It is very complicated to contribute.
So I ask, can someone tell me how to contribute with a small patch to GCJ 
whithout a lot of stuff.
More over, may be some of you are used to do so and can relay my patch to GCJ.
I join the class StringTokenizer after correction.
More over, I give two other classes, patches to gcj for sockets and 
deserialisation of vectors.
Thanks in advance
Christophe Roux

[-- Attachment #2: StringTokenizer.java --]
[-- Type: text/x-c, Size: 8629 bytes --]

/* java.util.StringTokenizer
   Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.

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 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.util;

/**
 * This class splits a string into tokens.  The caller can set on which 
 * delimiters the string should be split and if the delimiters should be
 * returned.
 *
 * You may change the delimiter set on the fly by calling
 * nextToken(String).  But the semantic is quite difficult; it even
 * depends on calling <code>hasMoreTokens()</code>.  You should call
 * <code>hasMoreTokens()</code> before, otherwise the old delimiters
 * after the last token are returned.
 *
 * If you want to get the delimiters, you have to use the three argument
 * constructor.  The delimiters are returned as token consisting of a
 * single character.  
 *
 * @author Jochen Hoenicke
 * @author Warren Levy <warrenl@cygnus.com>
 */
public class StringTokenizer implements Enumeration
{
  /**
   * The position in the str, where we currently are.
   */
  private int pos;
  /**
   * The string that should be split into tokens.
   */
  private String str;
  /**
   * The string containing the delimiter characters.
   */
  private String delim;
  /**
   * Tells, if we should return the delimiters.
   */
  private boolean retDelims;

  /*{ 
     invariant {
     pos >= 0 :: "position is negative";
     pos <= str.length() :: "position is out of string";
     str != null :: "String is null";
     delim != null :: "Delimiters are null";
     }
     } */

  /**
   * Creates a new StringTokenizer for the string <code>str</code>,
   * that should split on the default delimiter set (space, tap,
   * newline, return and formfeed), and which doesn't return the
   * delimiters.
   * @param str The string to split.
   */
  public StringTokenizer(String str)
    /*{ require { str != null :: "str must not be null"; } } */
  {
    this(str, " \t\n\r\f", false);
  }

  /**
   * Create a new StringTokenizer, that splits the given string on 
   * the given delimiter characters.  It doesn't return the delimiter
   * characters.
   *
   * @param str The string to split.
   * @param delim A string containing all delimiter characters.
   */
  public StringTokenizer(String str, String delim)
    /*{ require { str != null :: "str must not be null";
       delim != null :: "delim must not be null"; } } */
  {
    this(str, delim, false);
  }

  /**
   * Create a new StringTokenizer, that splits the given string on
   * the given delimiter characters.  If you set
   * <code>returnDelims</code> to <code>true</code>, the delimiter
   * characters are returned as tokens of their own.  The delimiter
   * tokens always consist of a single character.
   *
   * @param str The string to split.
   * @param delim A string containing all delimiter characters.
   * @param returnDelims Tells, if you want to get the delimiters.
   */
  public StringTokenizer(String str, String delim, boolean returnDelims)
    /*{ require { str != null :: "str must not be null";
       delim != null :: "delim must not be null"; } } */
  {
    this.str = str;
    this.delim = delim;
    this.retDelims = returnDelims;
    this.pos = 0;
  }

  /**
   * Tells if there are more tokens.
   * @return True, if the next call of nextToken() succeeds, false otherwise.
   */
  public boolean hasMoreTokens()
  {
    if (!retDelims)
      {
	while (pos < str.length() && delim.indexOf(str.charAt(pos)) > -1)
	  {
	    pos++;
	  }
      }
    return pos < str.length();
  }

  /**
   * Returns the nextToken, changing the delimiter set to the given
   * <code>delim</code>.  The change of the delimiter set is
   * permanent, ie. the next call of nextToken(), uses the same
   * delimiter set.
   * @param delim a string containing the new delimiter characters.
   * @return the next token with respect to the new delimiter characters.
   * @exception NoSuchElementException if there are no more tokens.
   */
  public String nextToken(String delim) throws NoSuchElementException
    /*{ require { hasMoreTokens() :: "no more Tokens available";
       ensure { $return != null && $return.length() > 0; } } */
  {
    this.delim = delim;
    return nextToken();
  }

  /**
   * Returns the nextToken of the string.
   * @param delim a string containing the new delimiter characters.
   * @return the next token with respect to the new delimiter characters.
   * @exception NoSuchElementException if there are no more tokens.
   */
  public String nextToken() throws NoSuchElementException
    /*{ require { hasMoreTokens() :: "no more Tokens available";
       ensure { $return != null && $return.length() > 0; } } */
  {
    if (pos < str.length() && delim.indexOf(str.charAt(pos)) > -1)
      {
	if (retDelims)
	  return str.substring(pos-1, ++pos);

	while (++pos < str.length() && delim.indexOf(str.charAt(pos)) > -1)
	  {
	    /* empty */
	  }
      }
    if (pos < str.length())
      {
	int start = pos;
	while (++pos < str.length() && delim.indexOf(str.charAt(pos)) == -1)
	  {
	    /* empty */
	  }
	return str.substring(start, pos);
      }
    throw new NoSuchElementException();
  }

  /**
   * This does the same as hasMoreTokens. This is the
   * <code>Enumeration</code interface method.
   * @return True, if the next call of nextElement() succeeds, false
   * otherwise.  
   * @see #hasMoreTokens
   */
  public boolean hasMoreElements()
  {
    return hasMoreTokens();
  }

  /**
   * This does the same as nextTokens. This is the
   * <code>Enumeration</code interface method.
   * @return the next token with respect to the new delimiter characters.
   * @exception NoSuchElementException if there are no more tokens.
   * @see #nextToken
   */
  public Object nextElement() throws NoSuchElementException
  {
    return nextToken();
  }

  /**
   * This counts the number of remaining tokens in the string, with
   * respect to the current delimiter set.
   * @return the number of times <code>nextTokens()</code> will
   * succeed.  
   * @see #nextToken
   */
  public int countTokens()
  {
    int count = 0;
    int delimiterCount = 0;
    boolean tokenFound = false;		// Set when a non-delimiter is found
    int tmpPos = pos;

    // Note for efficiency, we count up the delimiters rather than check
    // retDelims every time we encounter one.  That way, we can
    // just do the conditional once at the end of the method
    while (tmpPos < str.length())
      {
	if (delim.indexOf(str.charAt(tmpPos++)) > -1)
	  {
	    if (tokenFound)
	      {
		// Got to the end of a token
	        count++;
	        tokenFound = false;
	      }

	    delimiterCount++;		// Increment for this delimiter
	  }
	else
	  {
	    tokenFound = true;

	    // Get to the end of the token
	    while (tmpPos < str.length()
		   && delim.indexOf(str.charAt(tmpPos)) == -1)
	      ++tmpPos;
	  }
      }

    // Make sure to count the last token 
    if (tokenFound)
      count++;

    // if counting delmiters add them into the token count
    return retDelims ? count + delimiterCount : count;
  }
}

[-- Attachment #3: Connection.java --]
[-- Type: text/x-java, Size: 7728 bytes --]

// Connection.java - Implementation of HttpURLConnection for http protocol.

/* Copyright (C) 1999, 2000  Free Software Foundation

   This file is part of libgcj.

This software is copyrighted work licensed under the terms of the
Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
details.  */

package gnu.gcj.protocol.http;

import java.net.*;
import java.io.*;
import java.util.Vector;
import java.util.Hashtable;
import java.util.Enumeration;

/**
 * @author Warren Levy <warrenl@cygnus.com>
 * @date March 29, 1999.
 */

/**
 * Written using on-line Java Platform 1.2 API Specification, as well
 * as "The Java Class Libraries", 2nd edition (Addison-Wesley, 1998).
 * Status:  Minimal subset of functionality.  Proxies and Redirects
 *      not yet handled.  FileNameMap handling needs to be considered.
 *      useCaches, ifModifiedSince, and allowUserInteraction need
 *      consideration as well as doInput and doOutput.
 */

class Connection extends HttpURLConnection
{
  protected Socket sock = null;
  private static Hashtable defRequestProperties = new Hashtable();
  private Hashtable requestProperties;
  private Hashtable hdrHash = new Hashtable();
  private Vector hdrVec = new Vector();
  private BufferedInputStream bufferedIn;
  private boolean headers = false;

  public Connection(URL url)
  {
    super(url);
    requestProperties = (Hashtable) defRequestProperties.clone();
  }

  // Override method in URLConnection.
  public static void setDefaultRequestProperty(String key, String value)
  {
    defRequestProperties.put(key, value);
  }

  // Override method in URLConnection.
  public static String getDefaultRequestProperty(String key)
  {
    return (String) defRequestProperties.get(key);
  }

  // Override method in URLConnection.
  public void setRequestProperty(String key, String value)
  {
    if (connected)
      throw new IllegalAccessError("Connection already established.");

    requestProperties.put(key, value);
  }

  // Override method in URLConnection.
  public String getRequestProperty(String key)
  {
    if (connected)
      throw new IllegalAccessError("Connection already established.");

    return (String) requestProperties.get(key);
  }

  // Implementation of abstract method.
  public void connect() throws IOException
  {
    // Call is ignored if already connected.
    if (connected)
      return;

    // Get address and port number.
    int port;
    InetAddress destAddr = InetAddress.getByName(url.getHost());
    if ((port = url.getPort()) == -1)
      port = 80;

    // Open socket and output stream.
    sock = new Socket(destAddr, port);

    PrintWriter out = new PrintWriter(sock.getOutputStream());

    // Send request including any request properties that were set.
    out.print(getRequestMethod() + " " + url.getFile() + " HTTP/1.0\r\n");
    out.print("Host: " + url.getHost() + ":" + port + "\r\n");
    Enumeration reqKeys = requestProperties.keys();
    Enumeration reqVals = requestProperties.elements();
    while (reqKeys.hasMoreElements())
      out.print(reqKeys.nextElement() + ": " + reqVals.nextElement() + "\r\n");
    out.print("\r\n");
    out.flush();    
    connected = true;
    headers = false;
  }

  // Implementation of abstract method.
  public void disconnect()
  {
    if (sock != null)
      {
        try
          {
            sock.close();
          }
        catch (IOException ex)
          {
            ; // Ignore errors in closing socket.
          }
        sock = null;
      }
  }

  // TODO: public boolean usingProxy()
  public boolean usingProxy()
  {
    throw new InternalError("HttpURLConnection.usingProxy not implemented");
  }

  // Override default method in URLConnection.
  public InputStream getInputStream() throws IOException
  {
    if (!connected)
      connect();

    if ( !headers )
    	getHttpHeaders();
    
    if (!doInput)
      throw new ProtocolException("Can't open InputStream if doInput is false");
    return bufferedIn;
  }

  // Override default method in URLConnection.
  public OutputStream getOutputStream() throws IOException
  {
    if (!connected)
      connect();

    if (! doOutput)
      throw new
        ProtocolException("Can't open OutputStream if doOutput is false");
    return sock.getOutputStream();
  }

  // Override default method in URLConnection.
  public String getHeaderField(String name)
  {
    if (!connected)
      try
        {
          connect();
        }
      catch (IOException x)
        {
          return null;
        }

    return (String) hdrHash.get(name.toLowerCase());
  }

  // Override default method in URLConnection.
  public String getHeaderField(int n)
  {
    if (!connected)
      try
        {
          connect();
        }
      catch (IOException x)
        {
          return null;
        }

    if (n < hdrVec.size())
      return getField((String) hdrVec.elementAt(n));
    return null;
  }

  // Override default method in URLConnection.
  public String getHeaderFieldKey(int n)
  {
    if (!connected)
      try
        {
          connect();
        }
      catch (IOException x)
        {
          return null;
        }

    if (n < hdrVec.size())
      return getKey((String) hdrVec.elementAt(n));
    return null;
  }

  private String getKey(String str)
  {
    if (str == null)
      return null;
    int index = str.indexOf(':');
    if (index >= 0)
      return str.substring(0, index);
    else
      return null;
  }

  private String getField(String str)
  {
    if (str == null)
      return null;
    int index = str.indexOf(':');
    if (index >= 0)
      return str.substring(index + 1).trim();
    else
      return str;
  }

  private void getHttpHeaders() throws IOException
  {
    // Originally tried using a BufferedReader here to take advantage of
    // the readLine method and avoid the following, but the buffer read
    // past the end of the headers so the first part of the content was lost.
    // It is probably more robust than it needs to be, e.g. the byte[]
    // is unlikely to overflow and a '\r' should always be followed by a '\n',
    // but it is better to be safe just in case.
    bufferedIn = new BufferedInputStream(sock.getInputStream());

    int buflen = 100;
    byte[] buf = new byte[buflen];
    String line = "";
    boolean gotnl = false;
    byte[] ch = new byte[1];
    ch[0] = (byte) '\n';

    while (true)
      {
        // Check for leftover byte from non-'\n' after a '\r'.
        if (ch[0] != '\n')
          line = line + '\r' + new String(ch, 0, 1);

        int i;
        // FIXME: This is rather inefficient.
        for (i = 0; i < buflen; i++)
          {
            buf[i] = (byte) bufferedIn.read();
            if (buf[i] == -1)
              throw new IOException("Malformed HTTP header");
            if (buf[i] == '\r')
              {
                bufferedIn.read(ch, 0, 1);
                if (ch[0] == '\n')
                  gotnl = true;
                break;
              }
          }
        line = line + new String(buf, 0, i);

        // A '\r' '\n' combo indicates the end of the header entry.
        // If it wasn't found, cycle back through the loop and append
        // to 'line' until one is found.
        if (gotnl)
          {
            // A zero length entry signals the end of the headers.
            if (line.length() == 0)
              break;

            // Store the header and reinitialize for next cycle.
            hdrVec.addElement(line);
            String key = getKey(line);
            if (key != null)
              hdrHash.put(key.toLowerCase(), getField(line));
            line = "";
            ch[0] = (byte) '\n';
            gotnl = false;
          }
      }
  }
}



[-- Attachment #4: ObjectInputStream.java --]
[-- Type: text/x-c, Size: 43539 bytes --]

/* ObjectInputStream.java -- Class used to read serialized objects
   Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.

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 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;

import gnu.classpath.Configuration;

import java.lang.reflect.Array;
import java.lang.reflect.Modifier;
import java.util.Arrays;
import java.util.Hashtable;
import java.util.Vector;

import gnu.java.io.ObjectIdentityWrapper;
import gnu.java.lang.reflect.TypeSignature;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.InvocationTargetException;



public class ObjectInputStream extends InputStream
  implements ObjectInput, ObjectStreamConstants
{
  /**
     Creates a new <code>ObjectInputStream</code> that will do all of
     its reading from <code>in</code>.  This method also checks
     the stream by reading the header information (stream magic number
     and stream version).

     @exception IOException Reading stream header from underlying
     stream cannot be completed.

     @exception StreamCorruptedException An invalid stream magic
     number or stream version was read from the stream.

     @see readStreamHeader ()
  */
  public ObjectInputStream (InputStream in)
    throws IOException, StreamCorruptedException
  {
    if (Configuration.DEBUG)
      {
	String val = System.getProperty("gcj.dumpobjects");
	if (dump == false && val != null && !val.equals(""))
	  {
	    dump = true;
	    System.out.println ("Serialization debugging enabled");
	  }
	else if (dump == true && (val == null || val.equals("")))
	  {
	    dump = false;
	    System.out.println ("Serialization debugging disabled");
	  }
      }

    this.resolveEnabled = false;
    this.isDeserializing = false;
    this.blockDataPosition = 0;
    this.blockDataBytes = 0;
    this.blockData = new byte[BUFFER_SIZE];
    this.blockDataInput = new DataInputStream (this);
    this.realInputStream = new DataInputStream (in);
    this.nextOID = baseWireHandle;
    this.objectLookupTable = new Hashtable ();
    this.validators = new Vector ();
    setBlockDataMode (true);
    readStreamHeader ();
  }


  /**
     Returns the next deserialized object read from the underlying stream.

     This method can be overriden by a class by implementing
     <code>private void readObject (ObjectInputStream)</code>.

     If an exception is thrown from this method, the stream is left in
     an undefined state.

     @exception ClassNotFoundException The class that an object being
     read in belongs to cannot be found.

     @exception IOException Exception from underlying
     <code>InputStream</code>.
  */
  public final Object readObject () throws ClassNotFoundException, IOException
  {
    if (this.useSubclassMethod)
      return readObjectOverride ();

    boolean was_deserializing;

    Object ret_val;
    was_deserializing = this.isDeserializing;

    if (! was_deserializing)
      setBlockDataMode (false);

    this.isDeserializing = true;

    byte marker = this.realInputStream.readByte ();
    dumpElement ("MARKER: 0x" + Integer.toHexString(marker) + " ");

    switch (marker)
    {
      case TC_BLOCKDATA:
      case TC_BLOCKDATALONG:
	if (marker == TC_BLOCKDATALONG) 
	  dumpElementln ("BLOCKDATALONG");
	else
	  dumpElementln ("BLOCKDATA");
	readNextBlock (marker);
	throw new StreamCorruptedException ("Unexpected blockData");

      case TC_NULL:
	dumpElementln ("NULL");
	ret_val = null;
	break;

      case TC_REFERENCE:
      {
	dumpElement ("REFERENCE ");
	Integer oid = new Integer (this.realInputStream.readInt ());
	dumpElementln (Integer.toHexString(oid.intValue()));
	ret_val = ((ObjectIdentityWrapper)
		   this.objectLookupTable.get (oid)).object;
	break;
      }

      case TC_CLASS:
      {
	dumpElementln ("CLASS");
	ObjectStreamClass osc = (ObjectStreamClass)readObject ();
	Class clazz = osc.forClass ();
	assignNewHandle (clazz);
	ret_val = clazz;
	break;
      }

      case TC_CLASSDESC:
      {
	dumpElement ("CLASSDESC NAME=");
	String name = this.realInputStream.readUTF ();
	dumpElement (name + "; UID=");
	long uid = this.realInputStream.readLong ();
	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));
	ObjectStreamField[] fields = new ObjectStreamField[field_count];

	ObjectStreamClass osc = new ObjectStreamClass (name, uid,
						       flags, fields);
	assignNewHandle (osc);

	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);
	  String class_name;

	  if (type_code == 'L' || type_code == '[')
	    class_name = (String)readObject ();
	  else
	    class_name = String.valueOf (type_code);

	  fields[i] =
	    new ObjectStreamField (field_name,
				   TypeSignature.getClassForEncoding
				   (class_name));
	}

	Class cl = resolveClass (osc);
	osc.setClass (cl);
	setBlockDataMode (false);

	if (this.realInputStream.readByte () != TC_ENDBLOCKDATA)
	  throw new IOException ("Data annotated to class was not consumed.");
	dumpElementln ("ENDBLOCKDATA ");

	osc.setSuperclass ((ObjectStreamClass)readObject ());
	ret_val = osc;
	break;
      }

      case TC_STRING:
      {
	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 (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++)
	  if ( Array.get(array,i) == null )
	    dumpElementln ("  ELEMENT[" + i + "]=<null>");
	  else
	    dumpElementln ("  ELEMENT[" + i + "]=" + Array.get(array, i).toString());
	ret_val = processResolution (array, handle);
	break;
      }

      case TC_OBJECT:
      {
	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 (Externalizable.class.isAssignableFrom (clazz))
	{
	  Externalizable obj = null;

	  try
	  {
	    obj = (Externalizable)clazz.newInstance ();
	  }
	  catch (InstantiationException e)
	  {
	    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");
	  }
	  catch (NoSuchMethodError e)
	  {
	    throw new ClassNotFoundException ("Instance of " + clazz
					      + " could not be created because zero-argument constructor is not defined");
	  }

	  int handle = assignNewHandle (obj);

	  boolean read_from_blocks = ((osc.getFlags () & SC_BLOCK_DATA) != 0);

	  if (read_from_blocks)
	    setBlockDataMode (true);

	  obj.readExternal (this);

	  if (read_from_blocks)
	    setBlockDataMode (false);

	  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 ();

//	DEBUGln ("Using " + first_nonserial
//		 + " as starting point for constructing " + clazz);

	Object obj = null;
	obj = newObject (clazz, first_nonserial);

	if (obj == null)
	  throw new ClassNotFoundException ("Instance of " + clazz +
					    " could not be created");

	int handle = assignNewHandle (obj);
	this.currentObject = obj;
	ObjectStreamClass[] hierarchy =
	  ObjectStreamClass.getObjectStreamClasses (clazz);

//	DEBUGln ("Got class hierarchy of depth " + hierarchy.length);

	boolean has_read;
	for (int i=0; i < hierarchy.length; i++)
	{
	  this.currentObjectStreamClass = hierarchy[i];

	  dumpElementln ("Reading fields of "
		   + this.currentObjectStreamClass.getName ());

	  has_read = true;

	  try
	  {
	    this.currentObjectStreamClass.forClass ().
	      getDeclaredMethod ("readObject", readObjectParams);
	  }
	  catch (NoSuchMethodException e)
	  {
	    has_read = false;
	  }

	  // XXX: should initialize fields in classes in the hierarchy
	  // that aren't in the stream
	  // should skip over classes in the stream that aren't in the
	  // real classes hierarchy
	  readFields (obj, this.currentObjectStreamClass.fields,
		      has_read, this.currentObjectStreamClass);

	  if (has_read)
	  {
	    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");
	      }
	    catch (EOFException e)
	      {
	        dumpElementln ("no, got EOFException");
	      }
	    catch (IOException e)
	      {
	        dumpElementln ("no, got IOException");
	      }
	  }
	}

	this.currentObject = null;
	this.currentObjectStreamClass = null;
	ret_val = processResolution (obj, handle);
	break;
      }

      case TC_RESET:
	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);
      }

      default:
	throw new IOException ("Unknown marker on stream");
    }

    this.isDeserializing = was_deserializing;

    if (! was_deserializing)
    {
      setBlockDataMode (true);

      if (validators.size () > 0)
	invokeValidators ();
    }

    return ret_val;
  }


  /**
     Reads the current objects non-transient, non-static fields from
     the current class from the underlying output stream.

     This method is intended to be called from within a object's
     <code>private void readObject (ObjectInputStream)</code>
     method.

     @exception ClassNotFoundException The class that an object being
     read in belongs to cannot be found.

     @exception NotActiveException This method was called from a
     context other than from the current object's and current class's
     <code>private void readObject (ObjectInputStream)</code>
     method.

     @exception IOException Exception from underlying
     <code>OutputStream</code>.
  */
  public void defaultReadObject ()
    throws ClassNotFoundException, IOException, NotActiveException
  {
    if (this.currentObject == null || this.currentObjectStreamClass == null)
      throw new NotActiveException ("defaultReadObject called by non-active class and/or object");

    if (fieldsAlreadyRead)
      throw new NotActiveException ("defaultReadObject called but fields already read from stream (by defaultReadObject or readFields)");

    readFields (this.currentObject,
		this.currentObjectStreamClass.fields,
		false, this.currentObjectStreamClass);

    fieldsAlreadyRead = true;
  }


  /**
     Registers a <code>ObjectInputValidation</code> to be carried out
     on the object graph currently being deserialized before it is
     returned to the original caller of <code>readObject ()</code>.
     The order of validation for multiple
     <code>ObjectInputValidation</code>s can be controled using
     <code>priority</code>.  Validators with higher priorities are
     called first.

     @see java.io.ObjectInputValidation

     @exception InvalidObjectException <code>validator</code> is
     <code>null</code>

     @exception NotActiveException an attempt was made to add a
     validator outside of the <code>readObject</code> method of the
     object currently being deserialized
  */
  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");

    if (validator == null)
      throw new InvalidObjectException ("attempt to add a null ObjectInputValidation object");

    this.validators.addElement (new ValidatorAndPriority (validator,
							  priority));
  }


  /**
     Called when a class is being deserialized.  This is a hook to
     allow subclasses to read in information written by the
     <code>annotateClass (Class)</code> method of an
     <code>ObjectOutputStream</code>.

     This implementation looks up the active call stack for a
     <code>ClassLoader</code>; if a <code>ClassLoader</code> is found,
     it is used to load the class associated with <code>osc</code>,
     otherwise, the default system <code>ClassLoader</code> is used.

     @exception IOException Exception from underlying
     <code>OutputStream</code>.

     @see java.io.ObjectOutputStream#annotateClass (java.lang.Class)
  */
  protected Class resolveClass (ObjectStreamClass osc)
    throws ClassNotFoundException, IOException
  {
    SecurityManager sm = System.getSecurityManager ();

    // FIXME: currentClassLoader doesn't yet do anything useful. We need
    // to call forName() with the classloader of the class which called 
    // readObject(). See SecurityManager.getClassContext().
    ClassLoader cl = currentClassLoader (sm);

    return Class.forName (osc.getName (), true, cl);
  }

  /**
     Allows subclasses to resolve objects that are read from the
     stream with other objects to be returned in their place.  This
     method is called the first time each object is encountered.

     This method must be enabled before it will be called in the
     serialization process.

     @exception IOException Exception from underlying
     <code>OutputStream</code>.

     @see enableResolveObject (boolean)
  */
  protected Object resolveObject (Object obj) throws IOException
  {
    return obj;
  }


  /**
     If <code>enable</code> is <code>true</code> and this object is
     trusted, then <code>resolveObject (Object)</code> will be called
     in subsequent calls to <code>readObject (Object)</code>.
     Otherwise, <code>resolveObject (Object)</code> will not be called.

     @exception SecurityException This class is not trusted.
  */
  protected boolean enableResolveObject (boolean enable)
    throws SecurityException
  {
    if (enable)
      {
	SecurityManager sm = System.getSecurityManager ();
	if (sm != null)
	  sm.checkPermission (new SerializablePermission ("enableSubtitution"));
      }

    boolean old_val = this.resolveEnabled;
    this.resolveEnabled = enable;
    return old_val;
  }


  /**
     Reads stream magic and stream version information from the
     underlying stream.

     @exception IOException Exception from underlying stream.

     @exception StreamCorruptedException An invalid stream magic
     number or stream version was read from the stream.
  */
  protected void readStreamHeader ()
    throws IOException, StreamCorruptedException
  {
    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");
  }


  public int read () throws IOException
  {
    if (this.readDataFromBlock)
    {
      if (this.blockDataPosition >= this.blockDataBytes)
	readNextBlock ();
      return (this.blockData[this.blockDataPosition++] & 0xff);
    }
    else
      return this.realInputStream.read ();
  }

  public int read (byte[] data, int offset, int length) throws IOException
  {
    if (this.readDataFromBlock)
    {
      if (this.blockDataPosition + length > this.blockDataBytes)
	readNextBlock ();

      System.arraycopy (this.blockData, this.blockDataPosition,
			data, offset, length);
      blockDataPosition += length;	

      return length;
    }
    else
      return this.realInputStream.read (data, offset, length);
  }

  public int available () throws IOException
  {
    if (this.readDataFromBlock)
    {
      if (this.blockDataPosition >= this.blockDataBytes)
	readNextBlock ();

      return this.blockDataBytes - this.blockDataPosition;
    }
    else
      return this.realInputStream.available ();
  }

  public void close () throws IOException
  {
    this.realInputStream.close ();
  }

  public boolean readBoolean () throws IOException
  {
    return this.dataInputStream.readBoolean ();
  }

  public byte readByte () throws IOException
  {
    return this.dataInputStream.readByte ();
  }

  public int readUnsignedByte () throws IOException
  {
    return this.dataInputStream.readUnsignedByte ();
  }

  public short readShort () throws IOException
  {
    return this.dataInputStream.readShort ();
  }

  public int readUnsignedShort () throws IOException
  {
    return this.dataInputStream.readUnsignedShort ();
  }

  public char readChar () throws IOException
  {
    return this.dataInputStream.readChar ();
  }

  public int readInt () throws IOException
  {
    return this.dataInputStream.readInt ();
  }

  public long readLong () throws IOException
  {
    return this.dataInputStream.readLong ();
  }

  public float readFloat () throws IOException
  {
    return this.dataInputStream.readFloat ();
  }

  public double readDouble () throws IOException
  {
    return this.dataInputStream.readDouble ();
  }

  public void readFully (byte data[]) throws IOException
  {
    this.dataInputStream.readFully (data);
  }

  public void readFully (byte data[], int offset, int size)
    throws IOException
  {
    this.dataInputStream.readFully (data, offset, size);
  }

  public int skipBytes (int len) throws IOException
  {
    return this.dataInputStream.skipBytes (len);
  }

  /**
     @deprecated
     @see java.io.DataInputStream#readLine ()
  */
  public String readLine () throws IOException
  {
    return this.dataInputStream.readLine ();
  }

  public String readUTF () throws IOException
  {
    return this.dataInputStream.readUTF ();
  }


  /**
     This class allows a class to specify exactly which fields should
     be read, and what values should be read for these fields.

     XXX: finish up comments
  */
  public static abstract class GetField
  {
    public abstract ObjectStreamClass getObjectStreamClass ();

    public abstract boolean defaulted (String name)
      throws IOException, IllegalArgumentException;

    public abstract boolean get (String name, boolean defvalue)
      throws IOException, IllegalArgumentException;

    public abstract char get (String name, char defvalue)
      throws IOException, IllegalArgumentException;

    public abstract byte get (String name, byte defvalue)
      throws IOException, IllegalArgumentException;

    public abstract short get (String name, short defvalue)
      throws IOException, IllegalArgumentException;

    public abstract int get (String name, int defvalue)
      throws IOException, IllegalArgumentException;

    public abstract long get (String name, long defvalue)
      throws IOException, IllegalArgumentException;

    public abstract float get (String name, float defvalue)
      throws IOException, IllegalArgumentException;

    public abstract double get (String name, double defvalue)
      throws IOException, IllegalArgumentException;

    public abstract Object get (String name, Object defvalue)
      throws IOException, IllegalArgumentException;
  }

  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");

    if (fieldsAlreadyRead)
      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];
    final Object[] objs = new Object[clazz.objectFieldCount];

    // 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.
    setBlockDataMode (false);
    readFully (prim_field_data);
    for (int i = 0; i < objs.length; ++ i)
      objs[i] = readObject ();
    setBlockDataMode (true);

    return new GetField ()
    {
      public ObjectStreamClass getObjectStreamClass ()
      {
	return clazz;
      }

      public boolean defaulted (String name)
	throws IOException, IllegalArgumentException
      {
	return clazz.getField (name) == null;
      }

      public boolean get (String name, boolean defvalue)
	throws IOException, IllegalArgumentException
      {
	ObjectStreamField field = getField (name, Boolean.TYPE);

	if (field == null)
	  return defvalue;

	return prim_field_data[field.getOffset ()] == 0 ? false : true;
      }

      public char get (String name, char defvalue)
	throws IOException, IllegalArgumentException
      {
	ObjectStreamField field = getField (name, Character.TYPE);

	if (field == null)
	  return defvalue;

	int off = field.getOffset ();

	return (char)(((prim_field_data[off++] & 0xFF) << 8)
		      | (prim_field_data[off] & 0xFF));
      }

      public byte get (String name, byte defvalue)
	throws IOException, IllegalArgumentException
      {
	ObjectStreamField field = getField (name, Byte.TYPE);

	if (field == null)
	  return defvalue;

	return prim_field_data[field.getOffset ()];
      }

      public short get (String name, short defvalue)
	throws IOException, IllegalArgumentException
      {
	ObjectStreamField field = getField (name, Short.TYPE);

	if (field == null)
	  return defvalue;

	int off = field.getOffset ();

	return (short)(((prim_field_data[off++] & 0xFF) << 8)
		       | (prim_field_data[off] & 0xFF));
      }

      public int get (String name, int defvalue)
	throws IOException, IllegalArgumentException
      {
	ObjectStreamField field = getField (name, Integer.TYPE);

	if (field == null)
	  return defvalue;

	int off = field.getOffset ();

	return ((prim_field_data[off++] & 0xFF) << 24)
	  | ((prim_field_data[off++] & 0xFF) << 16)
	  | ((prim_field_data[off++] & 0xFF) << 8)
	  | (prim_field_data[off] & 0xFF);
      }

      public long get (String name, long defvalue)
	throws IOException, IllegalArgumentException
      {
	ObjectStreamField field = getField (name, Long.TYPE);

	if (field == null)
	  return defvalue;

	int off = field.getOffset ();

	return (long)(((prim_field_data[off++] & 0xFF) << 56)
		      | ((prim_field_data[off++] & 0xFF) << 48)
		      | ((prim_field_data[off++] & 0xFF) << 40)
		      | ((prim_field_data[off++] & 0xFF) << 32)
		      | ((prim_field_data[off++] & 0xFF) << 24)
		      | ((prim_field_data[off++] & 0xFF) << 16)
		      | ((prim_field_data[off++] & 0xFF) << 8)
		      | (prim_field_data[off] & 0xFF));
      }

      public float get (String name, float defvalue)
	throws IOException, IllegalArgumentException
      {
	ObjectStreamField field = getField (name, Float.TYPE);

	if (field == null)
	  return defvalue;

	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));
      }

      public double get (String name, double defvalue)
	throws IOException, IllegalArgumentException
      {
	ObjectStreamField field = getField (name, Double.TYPE);

	if (field == null)
	  return defvalue;

	int off = field.getOffset ();

	return Double.longBitsToDouble (
	  (long)(((prim_field_data[off++] & 0xFF) << 56)
		 | ((prim_field_data[off++] & 0xFF) << 48)
		 | ((prim_field_data[off++] & 0xFF) << 40)
		 | ((prim_field_data[off++] & 0xFF) << 32)
		 | ((prim_field_data[off++] & 0xFF) << 24)
		 | ((prim_field_data[off++] & 0xFF) << 16)
		 | ((prim_field_data[off++] & 0xFF) << 8)
		 | (prim_field_data[off] & 0xFF)));
      }

      public Object get (String name, Object defvalue)
	throws IOException, IllegalArgumentException
      {
	ObjectStreamField field =
	  getField (name, defvalue == null ? null : defvalue.getClass ());

	if (field == null)
	  return defvalue;

	return objs[field.getOffset ()];
      }

      private ObjectStreamField getField (String name, Class type)
	throws IllegalArgumentException
      {
	ObjectStreamField field = clazz.getField (name);

	if (field == null)
	  return null;

	Class field_type = field.getType ();

	if (type == field_type ||
	    (type == null && ! field_type.isPrimitive ()))
	  return field;

	throw new IllegalArgumentException ("Field requested is of type "
					    + field_type.getName ()
					    + ", but requested type was "
					    + (type == null ?
					       "Object" : type.getName ()));
      }
    };

  }


  /**
     Protected constructor that allows subclasses to override
     deserialization.  This constructor should be called by subclasses
     that wish to override <code>readObject (Object)</code>.  This
     method does a security check <i>NOTE: currently not
     implemented</i>, then sets a flag that informs
     <code>readObject (Object)</code> to call the subclasses
     <code>readObjectOverride (Object)</code> method.

     @see readObjectOverride (Object)
  */
  protected ObjectInputStream ()
    throws IOException, SecurityException
  {
    SecurityManager sec_man = System.getSecurityManager ();
    if (sec_man != null)
      sec_man.checkPermission (SUBCLASS_IMPLEMENTATION_PERMISSION);
    this.useSubclassMethod = true;
  }


  /**
     This method allows subclasses to override the default
     de serialization mechanism provided by
     <code>ObjectInputStream</code>.  To make this method be used for
     writing objects, subclasses must invoke the 0-argument
     constructor on this class from there constructor.

     @see ObjectInputStream ()
  */
  protected Object readObjectOverride ()
    throws ClassNotFoundException, IOException, OptionalDataException
  {
    throw new IOException ("Subclass of ObjectInputStream must implement readObjectOverride");
  }


  // assigns the next availible handle to OBJ
  private int assignNewHandle (Object obj)
  {
    this.objectLookupTable.put (new Integer (this.nextOID),
			     new ObjectIdentityWrapper (obj));

//    try
//    {
//      DEBUG ("Assigning handle " + this.nextOID);
//      DEBUGln (" to " + obj);
//    }
//    catch (Throwable t) {}

    return this.nextOID++;
  }


  private Object processResolution (Object obj, int handle)
    throws IOException
  {
    if (obj instanceof Serializable)
      {
        Method m = null; 
	try
	{
	  Class classArgs[] = {};
	  m = obj.getClass ().getDeclaredMethod ("readResolve", classArgs);
	  // m can't be null by definition since an exception would
	  // have been thrown so a check for null is not needed.
	  obj = m.invoke (obj, new Object[] {});	
	}
	catch (NoSuchMethodException ignore)
	{
	}
	catch (IllegalAccessException ignore)
	{
	}
	catch (InvocationTargetException ignore)
	{
	}
      }

    if (this.resolveEnabled)
      obj = resolveObject (obj);

    this.objectLookupTable.put (new Integer (handle),
				new ObjectIdentityWrapper (obj));

    return obj;
  }


  private void clearHandles ()
  {
    this.objectLookupTable.clear ();
    this.nextOID = baseWireHandle;
  }


  private void readNextBlock () throws IOException
  {
//  DEBUGln ("In readNextBlock ");
    readNextBlock (this.realInputStream.readByte ());
  }


  private void readNextBlock (byte marker) throws IOException
  {
    if (marker == TC_BLOCKDATA)
    {
      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 ();
      dumpElementln (Integer.toString(this.blockDataBytes));
    }
    else
    {
      throw new EOFException ("Attempt to read primitive data, but no data block is active.");
    }

    if (this.blockData.length < this.blockDataBytes)
      this.blockData = new byte[this.blockDataBytes];

    this.realInputStream.readFully (this.blockData, 0, this.blockDataBytes);
    this.blockDataPosition = 0;
  }


  private void readArrayElements (Object array, Class clazz)
    throws ClassNotFoundException, IOException
  {
    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 ();
	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 ();
	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 ();
	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 ();
	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 ();
	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 ();
	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 ();
	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 ();
	return;
      }
    }
    else
    {
      Object[] cast_array = (Object[])array;
      for (int i=0; i < cast_array.length; i++)
 	  cast_array[i] = readObject ();
    }
  }


  private void readFields (Object obj, ObjectStreamField[] stream_fields,
			   boolean call_read_method,
			   ObjectStreamClass stream_osc)
    throws ClassNotFoundException, IOException
  {
//  DEBUGln ("In readFields");
    if (call_read_method)
    {
//    DEBUGln ("  call_read_method is true");
      fieldsAlreadyRead = false;
      setBlockDataMode (true);
      callReadMethod (obj, stream_osc.forClass ());
      setBlockDataMode (false);
      return;
    }

    ObjectStreamField[] real_fields =
      ObjectStreamClass.lookup (stream_osc.forClass ()).fields;

    boolean default_initialize, set_value;
    String field_name = null;
    Class type = null;
    ObjectStreamField stream_field = null;
    ObjectStreamField real_field = null;
    int stream_idx = 0;
    int real_idx = 0;

    while (stream_idx < stream_fields.length
	   && real_idx < real_fields.length)
    {
      default_initialize = false;
      set_value = true;

      if (stream_idx == stream_fields.length)
	default_initialize = true;
      else
      {
	stream_field = stream_fields[stream_idx];
	type = stream_field.getType ();
      }

      if (real_idx == real_fields.length)
	set_value = false;
      else
      {
	real_field = real_fields[real_idx];
	type = real_field.getType ();
	field_name = real_field.getName ();
      }

      if (set_value && !default_initialize)
      {
	int comp_val =
	  real_field.compareTo (stream_field);

	if (comp_val < 0)
	{
	  default_initialize = true;
	  real_idx++;
	}
	else if (comp_val > 0)
	{
	  set_value = false;
	  stream_idx++;
	}
	else
	{
	  real_idx++;
	  stream_idx++;
	}
      }

      if (type == Boolean.TYPE)
      {
	boolean value =
	  default_initialize ? false : this.realInputStream.readBoolean ();
	if (!default_initialize && set_value)
	  dumpElementln ("  " + field_name + ": " + value);
	if (set_value)
	  setBooleanField (obj, field_name, value);
      }
      else if (type == Byte.TYPE)
      {
	byte value =
	  default_initialize ? 0 : this.realInputStream.readByte ();
	if (!default_initialize && set_value)
	  dumpElementln ("  " + field_name + ": " + value);
	if (set_value)
	  setByteField (obj, field_name, value);
      }
      else if (type == Character.TYPE)
      {
	char value =
	  default_initialize ? (char)0 : this.realInputStream.readChar ();
	if (!default_initialize && set_value)
	  dumpElementln ("  " + field_name + ": " + value);
	if (set_value)
	  setCharField (obj, field_name, value);
      }
      else if (type == Double.TYPE)
      {
	double value =
	  default_initialize ? 0 : this.realInputStream.readDouble ();
	if (!default_initialize && set_value)
	  dumpElementln ("  " + field_name + ": " + value);
	if (set_value)
	  setDoubleField (obj, field_name, value);
      }
      else if (type == Float.TYPE)
      {
	float value =
	  default_initialize ? 0 : this.realInputStream.readFloat ();
	if (!default_initialize && set_value)
	  dumpElementln ("  " + field_name + ": " + value);
	if (set_value)
	  setFloatField (obj, field_name, value);
      }
      else if (type == Integer.TYPE)
      {
	int value =
	  default_initialize ? 0 : this.realInputStream.readInt ();
	if (!default_initialize && set_value)
	  dumpElementln ("  " + field_name + ": " + value);
	if (set_value)
	  setIntField (obj, field_name, value);
      }
      else if (type == Long.TYPE)
      {
	long value =
	  default_initialize ? 0 : this.realInputStream.readLong ();
	if (!default_initialize && set_value)
	  dumpElementln ("  " + field_name + ": " + value);
	if (set_value)
	  setLongField (obj, field_name, value);
      }
      else if (type == Short.TYPE)
      {
	short value =
	  default_initialize ? (short)0 : this.realInputStream.readShort ();
	if (!default_initialize && set_value)
	  dumpElementln ("  " + field_name + ": " + value);
	if (set_value)
	  setShortField (obj, field_name, value);
      }
      else
      {
	Object value =
	  default_initialize ? null : readObject ();
	if (set_value)
	  setObjectField (obj, field_name,
			  real_field.getTypeString (), value);
      }
    }
  }


  // Toggles writing primitive data to block-data buffer.
  private void setBlockDataMode (boolean on)
  {
//    DEBUGln ("Setting block data mode to " + on);

    this.readDataFromBlock = on;

    if (on)
      this.dataInputStream = this.blockDataInput;
    else
      this.dataInputStream = this.realInputStream;
  }


  // returns a new instance of REAL_CLASS that has been constructed
  // only to the level of CONSTRUCTOR_CLASS (a super class of REAL_CLASS)
  private Object newObject (Class real_class, Class constructor_class)
  {
    try
    {
      Object obj = allocateObject (real_class);
      callConstructor (constructor_class, obj);
      return obj;
    }
    catch (InstantiationException e)
    {
      return null;
    }
  }


  // runs all registered ObjectInputValidations in prioritized order
  // on OBJ
  private void invokeValidators () throws InvalidObjectException
  {
    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 ();
    }
    finally
    {
      this.validators.removeAllElements ();
    }
  }


  // this native method is used to get access to the protected method
  // of the same name in SecurityManger
  private static ClassLoader currentClassLoader (SecurityManager sm)
  {
    // FIXME: This is too simple.
    return ClassLoader.getSystemClassLoader ();
  }

  private static native Field getField (Class klass, String name)
    throws java.lang.NoSuchFieldException;

  private static native Method getMethod (Class klass, String name, Class args[])
    throws java.lang.NoSuchMethodException;

  private void callReadMethod (Object obj, Class klass) throws IOException
  {
    try
      {
	Class classArgs[] = {ObjectInputStream.class};
	Method m = getMethod (klass, "readObject", classArgs);
	if (m == null)
	  return;
	Object args[] = {this};
	m.invoke (obj, args);
      }
    catch (InvocationTargetException x)
      {
        /* Rethrow if possible. */
	Throwable exception = x.getTargetException();
	if (exception instanceof RuntimeException)
	  throw (RuntimeException) exception;
	if (exception instanceof IOException)
	  throw (IOException) exception;

	throw new IOException ("Exception thrown from readObject() on " +
			       klass + ": " + exception.getClass().getName());
      }
    catch (Exception x)
      {
	throw new IOException ("Failure invoking readObject() on " +
			       klass + ": " + x.getClass().getName());
      }
  }
    
  private native Object allocateObject (Class clazz)
    throws InstantiationException;

  private native void callConstructor (Class clazz, Object obj);

  private void setBooleanField (Object obj, String field_name,
				boolean val)
  {
    try
      {
	Class klass = obj.getClass ();
	Field f = getField (klass, field_name);
	f.setBoolean (obj, val);
      }
    catch (Exception _)
      {
      }    
  }

  private void setByteField (Object obj, String field_name,
				byte val)
  {
    try
      {
	Class klass = obj.getClass ();
	Field f = getField (klass, field_name);
	f.setByte (obj, val);
      }
    catch (Exception _)
      {
      }    
  }

  private void setCharField (Object obj, String field_name,
			     char val)
  {
    try
      {
	Class klass = obj.getClass ();
	Field f = getField (klass, field_name);
	f.setChar (obj, val);
      }
    catch (Exception _)
      {
      }    
  }

  private void setDoubleField (Object obj, String field_name,
			       double val)
  {
    try
      {
	Class klass = obj.getClass ();
	Field f = getField (klass, field_name);
	f.setDouble (obj, val);
      }
    catch (Exception _)
      {
      }    
  }

  private void setFloatField (Object obj, String field_name,
			      float val)
  {
    try
      {
	Class klass = obj.getClass ();
	Field f = getField (klass, field_name);
	f.setFloat (obj, val);
      }
    catch (Exception _)
      {
      }    
  }

  private void setIntField (Object obj, String field_name,
			      int val)
  {
    try
      {
	Class klass = obj.getClass ();
	Field f = getField (klass, field_name);
	f.setInt (obj, val);
      }
    catch (Exception _)
      {
      }    
  }


  private void setLongField (Object obj, String field_name,
			      long val)
  {
    try
      {
	Class klass = obj.getClass ();
	Field f = getField (klass, field_name);
	f.setLong (obj, val);
      }
    catch (Exception _)
      {
      }    
  }


  private void setShortField (Object obj, String field_name,
			      short val)
  {
    try
      {
	Class klass = obj.getClass ();
	Field f = getField (klass, field_name);
	f.setShort (obj, val);
      }
    catch (Exception _)
      {
      }    
  }


  private void setObjectField (Object obj, String field_name, String type_code,
			       Object val)
  {
    try
      {
	Class klass = obj.getClass ();
	Field f = getField (klass, field_name);
	// FIXME: We should check the type_code here
	f.set (obj, val);
      }
    catch (Exception _)
      {
      }    
  }

  private static final int BUFFER_SIZE = 1024;
  private static final Class[] readObjectParams = { ObjectInputStream.class };

  private DataInputStream realInputStream;
  private DataInputStream dataInputStream;
  private DataInputStream blockDataInput;
  private int blockDataPosition;
  private int blockDataBytes;
  private byte[] blockData;
  private boolean useSubclassMethod;
  private int nextOID;
  private boolean resolveEnabled;
  private Hashtable objectLookupTable;
  private Object currentObject;
  private ObjectStreamClass currentObjectStreamClass;
  private boolean readDataFromBlock;
  private boolean isDeserializing;
  private boolean fieldsAlreadyRead;
  private Vector validators;

  private static boolean dump;  

  private void dumpElement (String msg)
  {
    if (Configuration.DEBUG && dump)  
      System.out.print(msg);
  }
  
  private void dumpElementln (String msg)
  {
    if (Configuration.DEBUG && dump)
      System.out.println(msg);
  }
}


// used to keep a prioritized list of object validators
class ValidatorAndPriority implements Comparable
{
  int priority;
  ObjectInputValidation validator;

  ValidatorAndPriority (ObjectInputValidation validator, int priority)
  {
    this.priority = priority;
    this.validator = validator;
  }

  public int compareTo (Object o)
  {
    ValidatorAndPriority vap = (ValidatorAndPriority)o;
    return this.priority - vap.priority;
  }
}

^ permalink raw reply	[flat|nested] 2+ messages in thread

* Re: gcj minor bug
  2002-12-13 13:26 gcj minor bug Christophe Roux
@ 2002-12-13 13:48 ` Tom Tromey
  0 siblings, 0 replies; 2+ messages in thread
From: Tom Tromey @ 2002-12-13 13:48 UTC (permalink / raw)
  To: Christophe Roux; +Cc: rhug-rhats

>>>>> "Christophe" == Christophe Roux <ch_roux@club-internet.fr> writes:

Christophe> In fact, I discovered a bug in gcj by the way : The class
Christophe> StringTokenizer, when returning all tokens ( also
Christophe> separators ), gives empty tokens for separators;

This is a well known gcj bug.  The code in StringTokenizer is actually
fine, it is the compiler that has the problem.  I believe this bug is
fixed in cvs.

Christophe> But I read the steps needed to contribute to gcj, and my
Christophe> reaction is : It is very complicated to contribute.

We try to make it easy.  For simple patches, just send the patch, a
ChangeLog entry, and an explanation to <java-patches@gcc.gnu.org>.

If you submit several small patches, or one large one, you'll have to
go through the whole paperwork thing.

Tom

^ permalink raw reply	[flat|nested] 2+ messages in thread

end of thread, other threads:[~2002-12-13 21:48 UTC | newest]

Thread overview: 2+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2002-12-13 13:26 gcj minor bug Christophe Roux
2002-12-13 13:48 ` Tom Tromey

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).