gt: 		  if (b != TC_ENDBLOCKDATA)
context: /* ObjectInputStream.java -- Class used to read serialized objects
     Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 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 java.lang.reflect.Array;
  import java.lang.reflect.Modifier;
  import java.lang.reflect.Proxy;
  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;
  
  import gnu.classpath.Configuration;
  
  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;
  
      boolean is_consumed = false;
      boolean old_mode = setBlockDataMode (false);
  
      this.isDeserializing = true;
  
      byte marker = this.realInputStream.readByte ();
      dumpElement ("MARKER: 0x" + Integer.toHexString(marker) + " ");
  
      try
        {
  	switch (marker)
  	  {
  	  case TC_ENDBLOCKDATA:
  	    {
  	      ret_val = null;
  	      is_consumed = true;
  	      break;
  	    }
  
  	  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_PROXYCLASSDESC:
  	    {
  	      dumpElementln ("PROXYCLASS");
  	      int n_intf = this.realInputStream.readInt();
  	      String[] intfs = new String[n_intf];
  	      for (int i = 0; i < n_intf; i++)
  		{
  		  intfs[i] = this.realInputStream.readUTF();
  		  System.out.println(intfs[i]);
  		}
  	      
  	      boolean oldmode = setBlockDataMode (true);
  	      Class cl = resolveProxyClass(intfs);
  	      setBlockDataMode(oldmode);
  	      
  	      ObjectStreamClass osc = ObjectStreamClass.lookup(cl);
  	      assignNewHandle (osc);
  	      
  	      if (!is_consumed)
  		{
  		  byte b = this.realInputStream.readByte ();
  