objectinputstream.java

this gcc-g++-3.3.1.tar.gz is a source file of gcc, you can learn more about gcc through this codes f

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

    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 their 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));
    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
  {
    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, ObjectStreamClass stream_osc)
    throws ClassNotFoundException, IOException
  {
    ObjectStreamField[] stream_fields = stream_osc.fields;
    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 ();