ObjectInputStream.java 45.8 KB
Newer Older
Tom Tromey committed
1
/* ObjectInputStream.java -- Class used to read serialized objects
2
   Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
Tom Tromey committed
3 4 5 6 7 8 9

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.
10

Tom Tromey committed
11 12 13 14 15 16 17 18 19 20
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.

21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
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. */
Tom Tromey committed
37 38 39 40 41 42


package java.io;

import java.lang.reflect.Array;
import java.lang.reflect.Modifier;
43
import java.lang.reflect.Proxy;
Tom Tromey committed
44 45 46 47 48 49 50 51
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;
52
import java.lang.reflect.InvocationTargetException;
Tom Tromey committed
53

54
import gnu.classpath.Configuration;
Tom Tromey committed
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

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
  {
76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
    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");
	  }
      }

Tom Tromey committed
91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130
    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;

131 132
    boolean is_consumed = false;
    boolean old_mode = setBlockDataMode (false);
Tom Tromey committed
133 134 135 136

    this.isDeserializing = true;

    byte marker = this.realInputStream.readByte ();
137
    dumpElement ("MARKER: 0x" + Integer.toHexString(marker) + " ");
Tom Tromey committed
138

139
    try
Tom Tromey committed
140
      {
141
	switch (marker)
Tom Tromey committed
142
	  {
143 144 145 146 147 148
	  case TC_ENDBLOCKDATA:
	    {
	      ret_val = null;
	      is_consumed = true;
	      break;
	    }
149

150 151 152
	  case TC_BLOCKDATA:
	  case TC_BLOCKDATALONG:
	    {
153
	      if (marker == TC_BLOCKDATALONG)
154 155 156 157 158 159 160 161 162 163 164 165 166
		dumpElementln ("BLOCKDATALONG");
	      else
		dumpElementln ("BLOCKDATA");
	      readNextBlock (marker);
	      throw new StreamCorruptedException ("Unexpected blockData");
	    }

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

168 169 170 171 172 173 174 175 176
	  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;
	    }
177

178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273
	  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 ();
		  if (b != TC_ENDBLOCKDATA)
		    throw new IOException ("Data annotated to class was not consumed." + b);
		}
	      else
		is_consumed = false;
	      ObjectStreamClass superosc = (ObjectStreamClass)readObject ();
	      osc.setSuperclass (superosc);
	      ret_val = osc;
	      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);
		  
		  // There're many cases you can't get java.lang.Class from
		  // typename if your context class loader can't load it,
		  // then use typename to construct the field
		  fields[i] =
		    new ObjectStreamField (field_name, class_name);
		}
	      
	      boolean oldmode = setBlockDataMode (true);
	      osc.setClass (resolveClass (osc));
	      setBlockDataMode (oldmode);
	      
	      if (!is_consumed)
		{
		  byte b = this.realInputStream.readByte ();
		  if (b != TC_ENDBLOCKDATA)
		    throw new IOException ("Data annotated to class was not consumed." + b);
		}
	      else
		is_consumed = false;
	      
	      osc.setSuperclass ((ObjectStreamClass)readObject ());
	      ret_val = osc;
	      break;
	    }
274

275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424
	  case TC_STRING:
	  case TC_LONGSTRING:
	    {
	      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++)
		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 ();
	      
	      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);
		  
		  boolean oldmode = this.readDataFromBlock;
		  if (read_from_blocks)
		    setBlockDataMode (true);
		  
		  obj.readExternal (this);
		  
		  if (read_from_blocks)
		    setBlockDataMode (oldmode);
		  
		  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 ();
	      
	      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);
	      
	      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;
	    }
425

426 427 428 429 430
	  case TC_RESET:
	    dumpElementln ("RESET");
	    clearHandles ();
	    ret_val = readObject ();
	    break;
431

432 433 434 435 436 437 438 439
	  case TC_EXCEPTION:
	    {
	      dumpElement ("EXCEPTION=");
	      Exception e = (Exception)readObject ();
	      dumpElementln (e.toString());
	      clearHandles ();
	      throw new WriteAbortedException ("Exception thrown during writing of stream", e);
	    }
440

441 442
	  default:
	    throw new IOException ("Unknown marker on stream: " + marker);
Tom Tromey committed
443 444
	  }
      }
445
    finally
Tom Tromey committed
446
      {
447 448 449 450 451 452 453 454 455
	setBlockDataMode (old_mode);
	
	this.isDeserializing = was_deserializing;
	
	if (! was_deserializing)
	  {
	    if (validators.size () > 0)
	      invokeValidators ();
	  }
Tom Tromey committed
456
      }
457
    
Tom Tromey committed
458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488
    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)");

489
    boolean oldmode = setBlockDataMode(false);
Tom Tromey committed
490 491 492
    readFields (this.currentObject,
		this.currentObjectStreamClass.fields,
		false, this.currentObjectStreamClass);
493
    setBlockDataMode(oldmode);
Tom Tromey committed
494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551

    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 ();
552 553
    if (sm == null)
      sm = new SecurityManager () {};
Tom Tromey committed
554

555 556 557
    // 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().
Tom Tromey committed
558 559
    ClassLoader cl = currentClassLoader (sm);

560 561 562 563
    if (cl == null)
      return Class.forName (osc.getName ());
    else
      return cl.loadClass (osc.getName ());
Tom Tromey committed
564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584
  }

  /**
     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;
  }


585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610
  protected Class resolveProxyClass (String[] intfs)
    throws IOException, ClassNotFoundException
  {
    SecurityManager sm = System.getSecurityManager ();
    
    if (sm == null)
      sm = new SecurityManager () {};
    
    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();
    }
    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);
    }
  }
  
Tom Tromey committed
611 612 613 614 615 616 617 618 619 620 621 622
  /**
     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)
623 624 625 626 627
      {
	SecurityManager sm = System.getSecurityManager ();
	if (sm != null)
	  sm.checkPermission (new SerializablePermission ("enableSubtitution"));
      }
Tom Tromey committed
628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646

    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
  {
647
    dumpElement ("STREAM MAGIC ");
Tom Tromey committed
648 649 650
    if (this.realInputStream.readShort () != STREAM_MAGIC)
      throw new StreamCorruptedException ("Invalid stream magic number");

651
    dumpElementln ("STREAM VERSION ");
Tom Tromey committed
652 653 654 655 656 657 658 659
    if (this.realInputStream.readShort () != STREAM_VERSION)
      throw new StreamCorruptedException ("Invalid stream version number");
  }


  public int read () throws IOException
  {
    if (this.readDataFromBlock)
660 661 662 663 664
      {
	if (this.blockDataPosition >= this.blockDataBytes)
	  readNextBlock ();
	return (this.blockData[this.blockDataPosition++] & 0xff);
      }
Tom Tromey committed
665 666 667 668
    else
      return this.realInputStream.read ();
  }

669
  public int read (byte[] data, int offset, int length) throws IOException
Tom Tromey committed
670 671
  {
    if (this.readDataFromBlock)
672 673 674 675 676 677 678 679 680 681 682 683 684
      {
	if (this.blockDataPosition + length > this.blockDataBytes)
	  {
	    int remain = this.blockDataBytes - this.blockDataPosition;
	    if (remain != 0)
	      {
		System.arraycopy (this.blockData, this.blockDataPosition,
				  data, offset, remain);
		offset += remain;
		length -= remain;
	      }
	    readNextBlock ();
	  }
Tom Tromey committed
685

686 687 688
	System.arraycopy (this.blockData, this.blockDataPosition,
			  data, offset, length);
	this.blockDataPosition += length;
689

690 691
	return length;
      }
Tom Tromey committed
692 693 694 695 696 697 698
    else
      return this.realInputStream.read (data, offset, length);
  }

  public int available () throws IOException
  {
    if (this.readDataFromBlock)
699 700 701
      {
	if (this.blockDataPosition >= this.blockDataBytes)
	  readNextBlock ();
Tom Tromey committed
702

703 704
	return this.blockDataBytes - this.blockDataPosition;
      }
Tom Tromey committed
705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847
    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];
848 849 850 851

    // 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.
852
    boolean oldmode = setBlockDataMode (false);
Tom Tromey committed
853 854 855
    readFully (prim_field_data);
    for (int i = 0; i < objs.length; ++ i)
      objs[i] = readObject ();
856
    setBlockDataMode (oldmode);
Tom Tromey committed
857 858 859

    return new GetField ()
      {
860 861 862 863
	public ObjectStreamClass getObjectStreamClass ()
	{
	  return clazz;
	}
Tom Tromey committed
864

865 866 867 868 869
	public boolean defaulted (String name)
	  throws IOException, IllegalArgumentException
	{
	  return clazz.getField (name) == null;
	}
Tom Tromey committed
870

871 872 873 874
	public boolean get (String name, boolean defvalue)
	  throws IOException, IllegalArgumentException
	{
	  ObjectStreamField field = getField (name, Boolean.TYPE);
Tom Tromey committed
875

876 877
	  if (field == null)
	    return defvalue;
Tom Tromey committed
878

879 880
	  return prim_field_data[field.getOffset ()] == 0 ? false : true;
	}
Tom Tromey committed
881

882 883 884 885
	public char get (String name, char defvalue)
	  throws IOException, IllegalArgumentException
	{
	  ObjectStreamField field = getField (name, Character.TYPE);
Tom Tromey committed
886

887 888
	  if (field == null)
	    return defvalue;
Tom Tromey committed
889

890
	  int off = field.getOffset ();
Tom Tromey committed
891

892 893 894
	  return (char)(((prim_field_data[off++] & 0xFF) << 8)
			| (prim_field_data[off] & 0xFF));
	}
Tom Tromey committed
895

896 897 898 899
	public byte get (String name, byte defvalue)
	  throws IOException, IllegalArgumentException
	{
	  ObjectStreamField field = getField (name, Byte.TYPE);
Tom Tromey committed
900

901 902
	  if (field == null)
	    return defvalue;
Tom Tromey committed
903

904 905
	  return prim_field_data[field.getOffset ()];
	}
Tom Tromey committed
906

907 908 909 910
	public short get (String name, short defvalue)
	  throws IOException, IllegalArgumentException
	{
	  ObjectStreamField field = getField (name, Short.TYPE);
Tom Tromey committed
911

912 913
	  if (field == null)
	    return defvalue;
Tom Tromey committed
914

915
	  int off = field.getOffset ();
Tom Tromey committed
916

917 918 919
	  return (short)(((prim_field_data[off++] & 0xFF) << 8)
			 | (prim_field_data[off] & 0xFF));
	}
Tom Tromey committed
920

921 922 923 924
	public int get (String name, int defvalue)
	  throws IOException, IllegalArgumentException
	{
	  ObjectStreamField field = getField (name, Integer.TYPE);
Tom Tromey committed
925

926 927
	  if (field == null)
	    return defvalue;
Tom Tromey committed
928

929
	  int off = field.getOffset ();
Tom Tromey committed
930

931 932 933 934 935
	  return ((prim_field_data[off++] & 0xFF) << 24)
	    | ((prim_field_data[off++] & 0xFF) << 16)
	    | ((prim_field_data[off++] & 0xFF) << 8)
	    | (prim_field_data[off] & 0xFF);
	}
Tom Tromey committed
936

937 938 939 940 941 942 943
	public long get (String name, long defvalue)
	  throws IOException, IllegalArgumentException
	{
	  ObjectStreamField field = getField (name, Long.TYPE);

	  if (field == null)
	    return defvalue;
Tom Tromey committed
944

945
	  int off = field.getOffset ();
Tom Tromey committed
946

947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979
	  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;
Tom Tromey committed
980

981 982 983 984
	  int off = field.getOffset ();

	  return Double.longBitsToDouble
	    ( (long) (((prim_field_data[off++] & 0xFF) << 56)
Tom Tromey committed
985 986 987 988 989 990
		      | ((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)
991 992
		      | (prim_field_data[off] & 0xFF)));
	}
Tom Tromey committed
993

994 995 996 997 998
	public Object get (String name, Object defvalue)
	  throws IOException, IllegalArgumentException
	{
	  ObjectStreamField field =
	    getField (name, defvalue == null ? null : defvalue.getClass ());
Tom Tromey committed
999

1000 1001
	  if (field == null)
	    return defvalue;
Tom Tromey committed
1002

1003 1004
	  return objs[field.getOffset ()];
	}
Tom Tromey committed
1005

1006 1007 1008 1009
	private ObjectStreamField getField (String name, Class type)
	  throws IllegalArgumentException
	{
	  ObjectStreamField field = clazz.getField (name);
Tom Tromey committed
1010

1011 1012
	  if (field == null)
	    return null;
Tom Tromey committed
1013

1014
	  Class field_type = field.getType ();
Tom Tromey committed
1015

1016 1017 1018
	  if (type == field_type ||
	      (type == null && ! field_type.isPrimitive ()))
	    return field;
Tom Tromey committed
1019

1020 1021 1022 1023 1024 1025 1026
	  throw new IllegalArgumentException ("Field requested is of type "
					      + field_type.getName ()
					      + ", but requested type was "
					      + (type == null ?
						 "Object" : type.getName ()));
	}
      };
Tom Tromey committed
1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056

  }


  /**
     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
1057
     constructor on this class from their constructor.
Tom Tromey committed
1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071

     @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),
1072
				new ObjectIdentityWrapper (obj));
Tom Tromey committed
1073 1074 1075 1076
    return this.nextOID++;
  }


1077
  private Object processResolution (Object obj, int handle)
Tom Tromey committed
1078 1079
    throws IOException
  {
1080 1081 1082 1083
    if (obj instanceof Serializable)
      {
        Method m = null; 
	try
1084 1085 1086 1087 1088 1089 1090
	  {
	    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[] {});	
	  }
1091
	catch (NoSuchMethodException ignore)
1092 1093
	  {
	  }
1094
	catch (IllegalAccessException ignore)
1095 1096
	  {
	  }
1097
	catch (InvocationTargetException ignore)
1098 1099
	  {
	  }
1100
      }
Tom Tromey committed
1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127

    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)
1128 1129 1130 1131 1132
      {
	dumpElement ("BLOCK DATA SIZE=");
	this.blockDataBytes = this.realInputStream.readUnsignedByte ();
	dumpElementln (Integer.toString(this.blockDataBytes));
      }
Tom Tromey committed
1133
    else if (marker == TC_BLOCKDATALONG)
1134 1135 1136 1137 1138
      {
	dumpElement ("BLOCK DATA LONG SIZE=");
	this.blockDataBytes = this.realInputStream.readInt ();
	dumpElementln (Integer.toString(this.blockDataBytes));
      }
Tom Tromey committed
1139
    else
1140 1141 1142
      {
	throw new EOFException ("Attempt to read primitive data, but no data block is active.");
      }
Tom Tromey committed
1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156

    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 ())
      {
1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212
	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;
	  }
Tom Tromey committed
1213
      }
1214
    else
Tom Tromey committed
1215
      {
1216
	Object[] cast_array = (Object[])array;
Tom Tromey committed
1217 1218
	for (int i=0; i < cast_array.length; i++)
 	  cast_array[i] = readObject ();
1219
      }
Tom Tromey committed
1220 1221 1222 1223 1224 1225 1226 1227 1228
  }


  private void readFields (Object obj, ObjectStreamField[] stream_fields,
			   boolean call_read_method,
			   ObjectStreamClass stream_osc)
    throws ClassNotFoundException, IOException
  {
    if (call_read_method)
1229 1230 1231 1232 1233 1234 1235
      {
	fieldsAlreadyRead = false;
	boolean oldmode = setBlockDataMode (true);
	callReadMethod (obj, stream_osc.forClass ());
	setBlockDataMode (oldmode);
	return;
      }
Tom Tromey committed
1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250

    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)
      {
1251 1252
	default_initialize = false;
	set_value = true;
Tom Tromey committed
1253

1254
	if (stream_idx == stream_fields.length)
Tom Tromey committed
1255
	  default_initialize = true;
1256 1257 1258 1259 1260 1261 1262
	else
	  {
	    stream_field = stream_fields[stream_idx];
	    type = stream_field.getType ();
	  }

	if (real_idx == real_fields.length)
Tom Tromey committed
1263 1264
	  set_value = false;
	else
1265 1266 1267 1268 1269
	  {
	    real_field = real_fields[real_idx];
	    type = real_field.getType ();
	    field_name = real_field.getName ();
	  }
Tom Tromey committed
1270

1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291
	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++;
	      }
	  }
Tom Tromey committed
1292

1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381
	try
	  {
	    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);
	      }
	  }
	catch (NoSuchFieldError e)
	  {
	    dumpElementln("XXXX " + field_name + " does not exist.");
	  }
      }
  }
Tom Tromey committed
1382 1383

  // Toggles writing primitive data to block-data buffer.
1384
  private boolean setBlockDataMode (boolean on)
Tom Tromey committed
1385
  {
1386
    boolean oldmode = this.readDataFromBlock;
Tom Tromey committed
1387 1388 1389 1390 1391 1392
    this.readDataFromBlock = on;

    if (on)
      this.dataInputStream = this.blockDataInput;
    else
      this.dataInputStream = this.realInputStream;
1393
    return oldmode;
Tom Tromey committed
1394 1395 1396 1397
  }


  // returns a new instance of REAL_CLASS that has been constructed
Tom Tromey committed
1398
  // only to the level of CONSTRUCTOR_CLASS (a super class of REAL_CLASS)
Tom Tromey committed
1399 1400 1401
  private Object newObject (Class real_class, Class constructor_class)
  {
    try
1402 1403 1404 1405 1406
      {
	Object obj = allocateObject (real_class);
	callConstructor (constructor_class, obj);
	return obj;
      }
Tom Tromey committed
1407
    catch (InstantiationException e)
1408 1409 1410
      {
	return null;
      }
Tom Tromey committed
1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422
  }


  // 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
1423 1424 1425 1426
      {
	for (int i=0; i < validators.length; i++)
	  ((ObjectInputValidation)validators[i]).validateObject ();
      }
Tom Tromey committed
1427
    finally
1428 1429 1430
      {
	this.validators.removeAllElements ();
      }
Tom Tromey committed
1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441
  }


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

1442 1443 1444 1445 1446
  private static Field getField (Class klass, String name)
    throws java.lang.NoSuchFieldException
  {
    return klass.getDeclaredField(name);
  }
1447

1448 1449 1450 1451 1452
  private static Method getMethod (Class klass, String name, Class args[])
    throws java.lang.NoSuchMethodException
  {
    return klass.getDeclaredMethod(name, args);
  }
1453

Tom Tromey committed
1454 1455 1456 1457
  private void callReadMethod (Object obj, Class klass) throws IOException
  {
    try
      {
1458
	Class classArgs[] = {ObjectInputStream.class};
Tom Tromey committed
1459 1460 1461 1462
	Method m = getMethod (klass, "readObject", classArgs);
	if (m == null)
	  return;
	Object args[] = {this};
1463
	m.invoke (obj, args);
Tom Tromey committed
1464
      }
1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477
    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)
Tom Tromey committed
1478
      {
1479 1480
	throw new IOException ("Failure invoking readObject() on " +
			       klass + ": " + x.getClass().getName());
Tom Tromey committed
1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495
      }
  }
    
  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);
Mark Wielaard committed
1496
	f.setAccessible(true);
Tom Tromey committed
1497 1498 1499 1500 1501 1502 1503 1504
	f.setBoolean (obj, val);
      }
    catch (Exception _)
      {
      }    
  }

  private void setByteField (Object obj, String field_name,
1505
			     byte val)
Tom Tromey committed
1506 1507 1508 1509 1510
  {
    try
      {
	Class klass = obj.getClass ();
	Field f = getField (klass, field_name);
Mark Wielaard committed
1511
	f.setAccessible(true);
Tom Tromey committed
1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525
	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);
Mark Wielaard committed
1526
	f.setAccessible(true);
Tom Tromey committed
1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540
	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);
Mark Wielaard committed
1541
	f.setAccessible(true);
Tom Tromey committed
1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555
	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);
Mark Wielaard committed
1556
	f.setAccessible(true);
Tom Tromey committed
1557 1558 1559 1560 1561 1562 1563 1564
	f.setFloat (obj, val);
      }
    catch (Exception _)
      {
      }    
  }

  private void setIntField (Object obj, String field_name,
1565
			    int val)
Tom Tromey committed
1566 1567 1568 1569 1570
  {
    try
      {
	Class klass = obj.getClass ();
	Field f = getField (klass, field_name);
Mark Wielaard committed
1571
	f.setAccessible(true);
Tom Tromey committed
1572 1573 1574 1575 1576 1577 1578 1579 1580
	f.setInt (obj, val);
      }
    catch (Exception _)
      {
      }    
  }


  private void setLongField (Object obj, String field_name,
1581
			     long val)
Tom Tromey committed
1582 1583 1584 1585 1586
  {
    try
      {
	Class klass = obj.getClass ();
	Field f = getField (klass, field_name);
Mark Wielaard committed
1587
	f.setAccessible(true);
Tom Tromey committed
1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602
	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);
Mark Wielaard committed
1603
	f.setAccessible(true);
Tom Tromey committed
1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618
	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);
Mark Wielaard committed
1619
	f.setAccessible(true);
Tom Tromey committed
1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647
	// 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;

1648
  private static boolean dump;
Tom Tromey committed
1649

1650
  private void dumpElement (String msg)
Tom Tromey committed
1651
  {
1652 1653
    if (Configuration.DEBUG && dump)  
      System.out.print(msg);
Tom Tromey committed
1654
  }
1655 1656
  
  private void dumpElementln (String msg)
Tom Tromey committed
1657
  {
1658 1659
    if (Configuration.DEBUG && dump)
      System.out.println(msg);
Tom Tromey committed
1660
  }
1661 1662

  static
1663 1664 1665 1666 1667 1668
  {
    if (Configuration.INIT_LOAD_LIBRARY)
      {
	System.loadLibrary ("javaio");
      }
  }
Tom Tromey committed
1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689
}


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