riscv-gnu-toolchain/gcc.git - Unnamed repository; edit this file 'description' to name the repository.

diff options

author	Andreas Krebbel <krebbel1@de.ibm.com>	2008-01-10 16:46:26 +0000
committer	Andreas Krebbel <krebbel@gcc.gnu.org>	2008-01-10 16:46:26 +0000
commit	90d12f1f04dc8a9e11716c79d2411eb922c13b49 (patch)
tree	c912dd79c520074e69014d7ec858c8c2b20c84cf /libjava/java/net/ContentHandler.h
parent	71ae85578b806e93eb8fbd58bfe618c5901b52aa (diff)
download	gcc-90d12f1f04dc8a9e11716c79d2411eb922c13b49.zip gcc-90d12f1f04dc8a9e11716c79d2411eb922c13b49.tar.gz gcc-90d12f1f04dc8a9e11716c79d2411eb922c13b49.tar.bz2

re PR target/34641 (ICE in reload_cse_simplify_operands, at postreload.c:395)

2008-01-10 Andreas Krebbel <krebbel1@de.ibm.com> PR middle-end/34641 * reload.c (push_reload): Add assertions. All constants from reg_equiv_constant should have been used for replacing the respective pseudo earlier. (find_reloads_address): Invoke find_reloads_address_part for constant taken from the reg_equiv_constant array. 2008-01-10 Andreas Krebbel <krebbel1@de.ibm.com> PR middle-end/34641 * g++.dg/torture/pr34641.C: New testcase. From-SVN: r131445

Diffstat (limited to 'libjava/java/net/ContentHandler.h')

0 files changed, 0 insertions, 0 deletions

/* ObjectOutputStream.java -- Class used to write 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 java.lang.reflect.Array; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.lang.reflect.InvocationTargetException; import java.util.Hashtable; import gnu.java.io.ObjectIdentityWrapper; import gnu.java.lang.reflect.TypeSignature; /** An <code>ObjectOutputStream</code> can be used to write objects as well as primitive data in a platform-independent manner to an <code>OutputStream</code>. The data produced by an <code>ObjectOutputStream</code> can be read and reconstituted by an <code>ObjectInputStream</code>. <code>writeObject (Object)</code> is used to write Objects, the <code>write<type></code> methods are used to write primitive data (as in <code>DataOutputStream</code>). Strings can be written as objects or as primitive data. Not all objects can be written out using an <code>ObjectOutputStream</code>. Only those objects that are an instance of <code>java.io.Serializable</code> can be written. Using default serialization, information about the class of an object is written, all of the non-transient, non-static fields of the object are written, if any of these fields are objects, they are written out in the same manner. An object is only written out the first time it is encountered. If the object is encountered later, a reference to it is written to the underlying stream. Thus writing circular object graphs does not present a problem, nor are relationships between objects in a graph lost. Example usage: <pre> Hashtable map = new Hashtable (); map.put ("one", new Integer (1)); map.put ("two", new Integer (2)); ObjectOutputStream oos = new ObjectOutputStream (new FileOutputStream ("numbers")); oos.writeObject (map); oos.close (); ObjectInputStream ois = new ObjectInputStream (new FileInputStream ("numbers")); Hashtable newmap = (Hashtable)ois.readObject (); System.out.println (newmap); </pre> The default serialization can be overriden in two ways. By defining a method <code>private void writeObject (ObjectOutputStream)</code>, a class can dictate exactly how information about itself is written. <code>defaultWriteObject ()</code> may be called from this method to carry out default serialization. This method is not responsible for dealing with fields of super-classes or subclasses. By implementing <code>java.io.Externalizable</code>. This gives the class complete control over the way it is written to the stream. If this approach is used the burden of writing superclass and subclass data is transfered to the class implementing <code>java.io.Externalizable</code>. @see java.io.DataOutputStream @see java.io.Externalizable @see java.io.ObjectInputStream @see java.io.Serializable @see XXX: java serialization spec */ public class ObjectOutputStream extends OutputStream implements ObjectOutput, ObjectStreamConstants { /** Creates a new <code>ObjectOutputStream</code> that will do all of its writing onto <code>out</code>. This method also initializes the stream by writing the header information (stream magic number and stream version). @exception IOException Writing stream header to underlying stream cannot be completed. @see writeStreamHeader () */ public ObjectOutputStream (OutputStream out) throws IOException { realOutput = new DataOutputStream (out); blockData = new byte[ BUFFER_SIZE ]; blockDataCount = 0; blockDataOutput = new DataOutputStream (this); setBlockDataMode (true); replacementEnabled = false; isSerializing = false; nextOID = baseWireHandle; OIDLookupTable = new Hashtable (); protocolVersion = defaultProtocolVersion; useSubclassMethod = false; writeStreamHeader (); } /** Writes a representation of <code>obj</code> to the underlying output stream by writing out information about its class, then writing out each of the objects non-transient, non-static fields. If any of these fields are other objects, they are written out in the same manner. This method can be overriden by a class by implementing <code>private void writeObject (ObjectOutputStream)</code>. If an exception is thrown from this method, the stream is left in an undefined state. @exception NotSerializableException An attempt was made to serialize an <code>Object</code> that is not serializable. @exception IOException Exception from underlying <code>OutputStream</code>. */ public final void writeObject (Object obj) throws IOException { if (useSubclassMethod) { writeObjectOverride (obj); return; } boolean was_serializing = isSerializing; if (! was_serializing) setBlockDataMode (false); try { isSerializing = true; boolean replaceDone = false; drain (); while (true) { if (obj == null) { realOutput.writeByte (TC_NULL); break; } Integer handle = findHandle (obj); if (handle != null) { realOutput.writeByte (TC_REFERENCE); realOutput.writeInt (handle.intValue ()); break; } if (obj instanceof Class) { realOutput.writeByte (TC_CLASS); writeObject (ObjectStreamClass.lookup ((Class)obj)); assignNewHandle (obj); break; } if (obj instanceof ObjectStreamClass) { ObjectStreamClass osc = (ObjectStreamClass)obj; realOutput.writeByte (TC_CLASSDESC); realOutput.writeUTF (osc.getName ()); realOutput.writeLong (osc.getSerialVersionUID ()); assignNewHandle (obj); int flags = osc.getFlags (); if (protocolVersion == PROTOCOL_VERSION_2 && osc.isExternalizable ()) flags |= SC_BLOCK_DATA; realOutput.writeByte (flags); ObjectStreamField[] fields = osc.fields; realOutput.writeShort (fields.length); ObjectStreamField field; for (int i=0; i < fields.length; i++) { field = fields[i]; realOutput.writeByte (field.getTypeCode ()); realOutput.writeUTF (field.getName ()); if (! field.isPrimitive ()) writeObject (field.getTypeString ()); } setBlockDataMode (true); annotateClass (osc.forClass ()); setBlockDataMode (false); realOutput.writeByte (TC_ENDBLOCKDATA); if (osc.isSerializable ()) writeObject (osc.getSuper ()); else writeObject (null); break; } Object replacedObject = null; if ((replacementEnabled || obj instanceof Serializable) && ! replaceDone) { replacedObject = obj; if (obj instanceof Serializable) { Method m = null; try { Class classArgs[] = {}; m = obj.getClass ().getDeclaredMethod ("writeReplace", 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 (replacementEnabled) obj = replaceObject (obj); replaceDone = true; continue; } if (obj instanceof String) { realOutput.writeByte (TC_STRING); assignNewHandle (obj); realOutput.writeUTF ((String)obj); break; } Class clazz = obj.getClass (); ObjectStreamClass osc = ObjectStreamClass.lookup (clazz); if (osc == null) throw new NotSerializableException (clazz.getName ()); if (clazz.isArray ()) { realOutput.writeByte (TC_ARRAY); writeObject (osc); assignNewHandle (obj); writeArraySizeAndElements (obj, clazz.getComponentType ()); break; } realOutput.writeByte (TC_OBJECT); writeObject (osc); if (replaceDone) assignNewHandle (replacedObject); else assignNewHandle (obj); if (obj instanceof Externalizable) { if (protocolVersion == PROTOCOL_VERSION_2) setBlockDataMode (true); ((Externalizable)obj).writeExternal (this); if (protocolVersion == PROTOCOL_VERSION_2) { setBlockDataMode (false); drain (); } break; } if (obj instanceof Serializable) { currentObject = obj; ObjectStreamClass[] hierarchy = ObjectStreamClass.getObjectStreamClasses (clazz); boolean has_write; for (int i=0; i < hierarchy.length; i++) { currentObjectStreamClass = hierarchy[i]; fieldsAlreadyWritten = false; has_write = currentObjectStreamClass.hasWriteMethod (); writeFields (obj, currentObjectStreamClass.fields, has_write); if (has_write) { drain (); realOutput.writeByte (TC_ENDBLOCKDATA); } } currentObject = null; currentObjectStreamClass = null; currentPutField = null; break; } throw new NotSerializableException (clazz.getName ()); } // end pseudo-loop } catch (IOException e) { realOutput.writeByte (TC_EXCEPTION); reset (true); try { writeObject (e); } catch (IOException ioe) { throw new StreamCorruptedException ("Exception " + ioe + " thrown while exception was being written to stream."); } reset (true); } finally { isSerializing = was_serializing; if (! was_serializing) setBlockDataMode (true); } } /** Writes the current objects non-transient, non-static fields from the current class to the underlying output stream. This method is intended to be called from within a object's <code>private void writeObject (ObjectOutputStream)</code> method. @exception NotActiveException This method was called from a context other than from the current object's and current class's <code>private void writeObject (ObjectOutputStream)</code> method. @exception IOException Exception from underlying <code>OutputStream</code>. */ public void defaultWriteObject () throws IOException, NotActiveException { markFieldsWritten (); writeFields (currentObject, currentObjectStreamClass.fields, false); } private void markFieldsWritten () throws IOException { if (currentObject == null || currentObjectStreamClass == null) throw new NotActiveException ("defaultWriteObject called by non-active class and/or object"); if (fieldsAlreadyWritten) throw new IOException ("Only one of putFields and defaultWriteObject may be called, and it may only be called once"); fieldsAlreadyWritten = true; } /** Resets stream to state equivalent to the state just after it was constructed. Causes all objects previously written to the stream to be forgotten. A notification of this reset is also written to the underlying stream. @exception IOException Exception from underlying <code>OutputStream</code> or reset called while serialization is in progress. */ public void reset () throws IOException { reset (false); } private void reset (boolean internal) throws IOException { if (!internal) { if (isSerializing) throw new IOException ("Reset called while serialization in progress"); realOutput.writeByte (TC_RESET); } clearHandles (); } /** Informs this <code>ObjectOutputStream</code> to write data according to the specified protocol. There are currently two different protocols, specified by <code>PROTOCOL_VERSION_1</code> and <code>PROTOCOL_VERSION_2</code>. This implementation writes data using <code>PROTOCOL_VERSION_1</code> by default, as is done by the JDK 1.1. A non-portable method, <code>setDefaultProtocolVersion (int version)</code> is provided to change the default protocol version. For an explination of the differences beween the two protocols see XXX: the Java ObjectSerialization Specification. @exception IOException if <code>version</code> is not a valid protocol @see setDefaultProtocolVersion (int) */ public void useProtocolVersion (int version) throws IOException { if (version != PROTOCOL_VERSION_1 && version != PROTOCOL_VERSION_2) throw new IOException ("Invalid protocol version requested."); protocolVersion = version; } /** <em>GNU $classpath specific</em> Changes the default stream protocol used by all <code>ObjectOutputStream</code>s. There are currently two different protocols, specified by <code>PROTOCOL_VERSION_1</code> and <code>PROTOCOL_VERSION_2</code>. The default default is <code>PROTOCOL_VERSION_1</code>. @exception IOException if <code>version</code> is not a valid protocol @see useProtocolVersion (int) */ public static void setDefaultProtocolVersion (int version) throws IOException { if (version != PROTOCOL_VERSION_1 && version != PROTOCOL_VERSION_2) throw new IOException ("Invalid protocol version requested."); defaultProtocolVersion = version; } /** An empty hook that allows subclasses to write extra information about classes to the stream. This method is called the first time each class is seen, and after all of the standard information about the class has been written. @exception IOException Exception from underlying <code>OutputStream</code>. @see java.io.ObjectInputStream#resolveClass (java.io.ObjectStreamClass) */ protected void annotateClass (Class cl) throws IOException {} /** Allows subclasses to replace objects that are written to the stream with other objects to be written in their place. This method is called the first time each object is encountered (modulo reseting of the stream). This method must be enabled before it will be called in the serialization process. @exception IOException Exception from underlying <code>OutputStream</code>. @see enableReplaceObject (boolean) */ protected Object replaceObject (Object obj) throws IOException { return obj; } /** If <code>enable</code> is <code>true</code> and this object is trusted, then <code>replaceObject (Object)</code> will be called in subsequent calls to <code>writeObject (Object)</code>. Otherwise, <code>replaceObject (Object)</code> will not be called. @exception SecurityException This class is not trusted. */ protected boolean enableReplaceObject (boolean enable) throws SecurityException { if (enable) { SecurityManager sm = System.getSecurityManager (); if (sm != null) sm.checkPermission (new SerializablePermission ("enableSubstitution")); } boolean old_val = replacementEnabled; replacementEnabled = enable; return old_val; } /** Writes stream magic and stream version information to the underlying stream. @exception IOException Exception from underlying <code>OutputStream</code>. */ protected void writeStreamHeader () throws IOException { realOutput.writeShort (STREAM_MAGIC); realOutput.writeShort (STREAM_VERSION); } /** Protected constructor that allows subclasses to override serialization. This constructor should be called by subclasses that wish to override <code>writeObject (Object)</code>. This method does a security check <i>NOTE: currently not implemented</i>, then sets a flag that informs <code>writeObject (Object)</code> to call the subclasses <code>writeObjectOverride (Object)</code> method. @see writeObjectOverride (Object) */ protected ObjectOutputStream () throws IOException, SecurityException { SecurityManager sec_man = System.getSecurityManager (); if (sec_man != null) sec_man.checkPermission (SUBCLASS_IMPLEMENTATION_PERMISSION); useSubclassMethod = true; } /** This method allows subclasses to override the default serialization mechanism provided by <code>ObjectOutputStream</code>. To make this method be used for writing objects, subclasses must invoke the 0-argument constructor on this class from there constructor. @see ObjectOutputStream () @exception NotActiveException Subclass has arranged for this method to be called, but did not implement this method. */ protected void writeObjectOverride (Object obj) throws NotActiveException, IOException { throw new NotActiveException ("Subclass of ObjectOutputStream must implement writeObjectOverride"); } /** @see java.io.DataOutputStream#write (int) */ public void write (int data) throws IOException { if (writeDataAsBlocks) { if (blockDataCount == BUFFER_SIZE) drain (); blockData[ blockDataCount++ ] = (byte)data; } else realOutput.write (data); } /** @see java.io.DataOutputStream#write (byte[]) */ public void write (byte[] b) throws IOException { write (b, 0, b.length); } /** @see java.io.DataOutputStream#write (byte[],int,int) */ public void write (byte[] b, int off, int len) throws IOException { if (writeDataAsBlocks) { if (len < 0) throw new IndexOutOfBoundsException (); if (blockDataCount + len < BUFFER_SIZE) { System.arraycopy (b, off, blockData, blockDataCount, len); blockDataCount += len; } else { drain (); writeBlockDataHeader (len); realOutput.write (b, off, len); } } else realOutput.write (b, off, len); } /** @see java.io.DataOutputStream#flush () */ public void flush () throws IOException { drain (); realOutput.flush (); } /** Causes the block-data buffer to be written to the underlying stream, but does not flush underlying stream. @exception IOException Exception from underlying <code>OutputStream</code>. */ protected void drain () throws IOException { if (blockDataCount == 0) return; writeBlockDataHeader (blockDataCount); realOutput.write (blockData, 0, blockDataCount); blockDataCount = 0; } /** @see java.io.DataOutputStream#close () */ public void close () throws IOException { drain (); realOutput.close (); } /** @see java.io.DataOutputStream#writeBoolean (boolean) */ public void writeBoolean (boolean data) throws IOException { dataOutput.writeBoolean (data); } /** @see java.io.DataOutputStream#writeByte (int) */ public void writeByte (int data) throws IOException { dataOutput.writeByte (data); } /** @see java.io.DataOutputStream#writeShort (int) */ public void writeShort (int data) throws IOException { dataOutput.writeShort (data); } /** @see java.io.DataOutputStream#writeChar (int) */ public void writeChar (int data) throws IOException { dataOutput.writeChar (data); } /** @see java.io.DataOutputStream#writeInt (int) */ public void writeInt (int data) throws IOException { dataOutput.writeInt (data); } /** @see java.io.DataOutputStream#writeLong (long) */ public void writeLong (long data) throws IOException { dataOutput.writeLong (data); } /** @see java.io.DataOutputStream#writeFloat (float) */ public void writeFloat (float data) throws IOException { dataOutput.writeFloat (data); } /** @see java.io.DataOutputStream#writeDouble (double) */ public void writeDouble (double data) throws IOException { dataOutput.writeDouble (data); } /** @see java.io.DataOutputStream#writeBytes (java.lang.String) */ public void writeBytes (String data) throws IOException { dataOutput.writeBytes (data); } /** @see java.io.DataOutputStream#writeChars (java.lang.String) */ public void writeChars (String data) throws IOException { dataOutput.writeChars (data); } /** @see java.io.DataOutputStream#writeUTF (java.lang.String) */ public void writeUTF (String data) throws IOException { dataOutput.writeUTF (data); } /** This class allows a class to specify exactly which fields should be written, and what values should be written for these fields. XXX: finish up comments */ public static abstract class PutField { public abstract void put (String name, boolean value) throws IOException, IllegalArgumentException; public abstract void put (String name, byte value) throws IOException, IllegalArgumentException; public abstract void put (String name, char value) throws IOException, IllegalArgumentException; public abstract void put (String name, double value) throws IOException, IllegalArgumentException; public abstract void put (String name, float value) throws IOException, IllegalArgumentException; public abstract void put (String name, int value) throws IOException, IllegalArgumentException; public abstract void put (String name, long value) throws IOException, IllegalArgumentException; public abstract void put (String name, short value) throws IOException, IllegalArgumentException; public abstract void put (String name, Object value) throws IOException, IllegalArgumentException; public abstract void write (ObjectOutput out) throws IOException; } public PutField putFields () throws IOException { markFieldsWritten (); currentPutField = new PutField () { private byte[] prim_field_data = new byte[currentObjectStreamClass.primFieldSize]; private Object[] objs = new Object[currentObjectStreamClass.objectFieldCount]; public void put (String name, boolean value) throws IOException, IllegalArgumentException { ObjectStreamField field = currentObjectStreamClass.getField (name); checkType (field, 'Z'); prim_field_data[field.getOffset ()] = (byte)(value ? 1 : 0); } public void put (String name, byte value) throws IOException, IllegalArgumentException { ObjectStreamField field = currentObjectStreamClass.getField (name); checkType (field, 'B'); prim_field_data[field.getOffset ()] = value; } public void put (String name, char value) throws IOException, IllegalArgumentException { ObjectStreamField field = currentObjectStreamClass.getField (name); checkType (field, 'C'); int off = field.getOffset (); prim_field_data[off++] = (byte)(value >>> 8); prim_field_data[off] = (byte)value; } public void put (String name, double value) throws IOException, IllegalArgumentException { ObjectStreamField field = currentObjectStreamClass.getField (name); checkType (field, 'D'); int off = field.getOffset (); long l_value = Double.doubleToLongBits (value); prim_field_data[off++] = (byte)(l_value >>> 52); prim_field_data[off++] = (byte)(l_value >>> 48); prim_field_data[off++] = (byte)(l_value >>> 40); prim_field_data[off++] = (byte)(l_value >>> 32); prim_field_data[off++] = (byte)(l_value >>> 24); prim_field_data[off++] = (byte)(l_value >>> 16); prim_field_data[off++] = (byte)(l_value >>> 8); prim_field_data[off] = (byte)l_value; } public void put (String name, float value) throws IOException, IllegalArgumentException { ObjectStreamField field = currentObjectStreamClass.getField (name); checkType (field, 'F'); int off = field.getOffset (); int i_value = Float.floatToIntBits (value); prim_field_data[off++] = (byte)(i_value >>> 24); prim_field_data[off++] = (byte)(i_value >>> 16); prim_field_data[off++] = (byte)(i_value >>> 8); prim_field_data[off] = (byte)i_value; } public void put (String name, int value) throws IOException, IllegalArgumentException { ObjectStreamField field = currentObjectStreamClass.getField (name); checkType (field, 'I'); int off = field.getOffset (); prim_field_data[off++] = (byte)(value >>> 24); prim_field_data[off++] = (byte)(value >>> 16); prim_field_data[off++] = (byte)(value >>> 8); prim_field_data[off] = (byte)value; } public void put (String name, long value) throws IOException, IllegalArgumentException { ObjectStreamField field = currentObjectStreamClass.getField (name); checkType (field, 'J'); int off = field.getOffset (); prim_field_data[off++] = (byte)(value >>> 52); prim_field_data[off++] = (byte)(value >>> 48); prim_field_data[off++] = (byte)(value >>> 40); prim_field_data[off++] = (byte)(value >>> 32); prim_field_data[off++] = (byte)(value >>> 24); prim_field_data[off++] = (byte)(value >>> 16); prim_field_data[off++] = (byte)(value >>> 8); prim_field_data[off] = (byte)value; } public void put (String name, short value) throws IOException, IllegalArgumentException { ObjectStreamField field = currentObjectStreamClass.getField (name); checkType (field, 'S'); int off = field.getOffset (); prim_field_data[off++] = (byte)(value >>> 8); prim_field_data[off] = (byte)value; } public void put (String name, Object value) throws IOException, IllegalArgumentException { ObjectStreamField field = currentObjectStreamClass.getField (name); if (value != null && ! field.getType ().isAssignableFrom (value.getClass ())) throw new IllegalArgumentException (); objs[field.getOffset ()] = value; } public void write (ObjectOutput out) throws IOException { // Apparently Block data is not used with PutField as per // empirical evidence against JDK 1.2. Also see Mauve test // java.io.ObjectInputOutput.Test.GetPutField. setBlockDataMode (false); out.write (prim_field_data); for (int i = 0; i < objs.length; ++ i) out.writeObject (objs[i]); setBlockDataMode (true); } private void checkType (ObjectStreamField field, char type) throws IllegalArgumentException { if (TypeSignature.getEncodingOfClass (field.getType ()).charAt (0) != type) throw new IllegalArgumentException (); } }; // end PutFieldImpl return currentPutField; } public void writeFields () throws IOException { if (currentPutField == null) throw new NotActiveException ("writeFields can only be called after putFields has been called"); currentPutField.write (this); } // write out the block-data buffer, picking the correct header // depending on the size of the buffer private void writeBlockDataHeader (int size) throws IOException { if (size < 256) { realOutput.writeByte (TC_BLOCKDATA); realOutput.write (size); } else { realOutput.writeByte (TC_BLOCKDATALONG); realOutput.writeInt (size); } } // lookup the handle for OBJ, return null if OBJ doesn't have a // handle yet private Integer findHandle (Object obj) { return (Integer)OIDLookupTable.get (new ObjectIdentityWrapper (obj)); } // assigns the next availible handle to OBJ private int assignNewHandle (Object obj) { OIDLookupTable.put (new ObjectIdentityWrapper (obj), new Integer (nextOID)); return nextOID++; } // resets mapping from objects to handles private void clearHandles () { nextOID = baseWireHandle; OIDLookupTable.clear (); } // write out array size followed by each element of the array private void writeArraySizeAndElements (Object array, Class clazz) throws IOException { int length = Array.getLength (array); if (clazz.isPrimitive ()) { if (clazz == Boolean.TYPE) { boolean[] cast_array = (boolean[])array; realOutput.writeInt (length); for (int i=0; i < length; i++) realOutput.writeBoolean (cast_array[i]); return; } if (clazz == Byte.TYPE) { byte[] cast_array = (byte[])array; realOutput.writeInt (length); for (int i=0; i < length; i++) realOutput.writeByte (cast_array[i]); return; } if (clazz == Character.TYPE) { char[] cast_array = (char[])array; realOutput.writeInt (length); for (int i=0; i < length; i++) realOutput.writeChar (cast_array[i]); return; } if (clazz == Double.TYPE) { double[] cast_array = (double[])array; realOutput.writeInt (length); for (int i=0; i < length; i++) realOutput.writeDouble (cast_array[i]); return; } if (clazz == Float.TYPE) { float[] cast_array = (float[])array; realOutput.writeInt (length); for (int i=0; i < length; i++) realOutput.writeFloat (cast_array[i]); return; } if (clazz == Integer.TYPE) { int[] cast_array = (int[])array; realOutput.writeInt (length); for (int i=0; i < length; i++) realOutput.writeInt (cast_array[i]); return; } if (clazz == Long.TYPE) { long[] cast_array = (long[])array; realOutput.writeInt (length); for (int i=0; i < length; i++) realOutput.writeLong (cast_array[i]); return; } if (clazz == Short.TYPE) { short[] cast_array = (short[])array; realOutput.writeInt (length); for (int i=0; i < length; i++) realOutput.writeShort (cast_array[i]); return; } } else { Object[] cast_array = (Object[])array; realOutput.writeInt (length); for (int i=0; i < length; i++) writeObject (cast_array[i]); } } // writes out FIELDS of OBJECT. If CALL_WRITE_METHOD is true, use // object's writeObject (ObjectOutputStream), otherwise use default // serialization. FIELDS are already in canonical order. private void writeFields (Object obj, ObjectStreamField[] fields, boolean call_write_method) throws IOException { if (call_write_method) { setBlockDataMode (true); callWriteMethod (obj); setBlockDataMode (false); return; } String field_name; Class type; for (int i=0; i < fields.length; i++) { field_name = fields[i].getName (); type = fields[i].getType (); if (type == Boolean.TYPE) realOutput.writeBoolean (getBooleanField (obj, field_name)); else if (type == Byte.TYPE) realOutput.writeByte (getByteField (obj, field_name)); else if (type == Character.TYPE) realOutput.writeChar (getCharField (obj, field_name)); else if (type == Double.TYPE) realOutput.writeDouble (getDoubleField (obj, field_name)); else if (type == Float.TYPE) realOutput.writeFloat (getFloatField (obj, field_name)); else if (type == Integer.TYPE) realOutput.writeInt (getIntField (obj, field_name)); else if (type == Long.TYPE) realOutput.writeLong (getLongField (obj, field_name)); else if (type == Short.TYPE) realOutput.writeShort (getShortField (obj, field_name)); else writeObject (getObjectField (obj, field_name, TypeSignature.getEncodingOfClass (type))); } } // Toggles writing primitive data to block-data buffer. private void setBlockDataMode (boolean on) { writeDataAsBlocks = on; if (on) dataOutput = blockDataOutput; else dataOutput = realOutput; } private void callWriteMethod (Object obj) throws IOException { Class klass = obj.getClass (); try { Class classArgs[] = {ObjectOutputStream.class}; Method m = getMethod (klass, "writeObject", 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 writeObject() on " + klass + ": " + exception.getClass().getName()); } catch (Exception x) { throw new IOException ("Failure invoking writeObject() on " + klass + ": " + x.getClass().getName()); } } private boolean getBooleanField (Object obj, String field_name) throws IOException { try { Class klass = obj.getClass (); Field f = getField (klass, field_name); boolean b = f.getBoolean (obj); return b; } catch (Exception _) { throw new IOException (); } } private byte getByteField (Object obj, String field_name) throws IOException { try { Class klass = obj.getClass (); Field f = getField (klass, field_name); byte b = f.getByte (obj); return b; } catch (Exception _) { throw new IOException (); } } private char getCharField (Object obj, String field_name) throws IOException { try { Class klass = obj.getClass (); Field f = getField (klass, field_name); char b = f.getChar (obj); return b; } catch (Exception _) { throw new IOException (); } } private double getDoubleField (Object obj, String field_name) throws IOException { try { Class klass = obj.getClass (); Field f = getField (klass, field_name); double b = f.getDouble (obj); return b; } catch (Exception _) { throw new IOException (); } } private float getFloatField (Object obj, String field_name) throws IOException { try { Class klass = obj.getClass (); Field f = getField (klass, field_name); float b = f.getFloat (obj); return b; } catch (Exception _) { throw new IOException (); } } private int getIntField (Object obj, String field_name) throws IOException { try { Class klass = obj.getClass (); Field f = getField (klass, field_name); int b = f.getInt (obj); return b; } catch (Exception _) { throw new IOException (); } } private long getLongField (Object obj, String field_name) throws IOException { try { Class klass = obj.getClass (); Field f = getField (klass, field_name); long b = f.getLong (obj); return b; } catch (Exception _) { throw new IOException (); } } private short getShortField (Object obj, String field_name) throws IOException { try { Class klass = obj.getClass (); Field f = getField (klass, field_name); short b = f.getShort (obj); return b; } catch (Exception _) { throw new IOException (); } } private Object getObjectField (Object obj, String field_name, String type_code) throws IOException { try { Class klass = obj.getClass (); Field f = getField (klass, field_name); Object o = f.get (obj); // FIXME: We should check the type_code here return o; } catch (Exception _) { throw new IOException (); } } 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; // this value comes from 1.2 spec, but is used in 1.1 as well private final static int BUFFER_SIZE = 1024; private static int defaultProtocolVersion = PROTOCOL_VERSION_1; private DataOutputStream dataOutput; private boolean writeDataAsBlocks; private DataOutputStream realOutput; private DataOutputStream blockDataOutput; private byte[] blockData; private int blockDataCount; private Object currentObject; private ObjectStreamClass currentObjectStreamClass; private PutField currentPutField; private boolean fieldsAlreadyWritten; private boolean replacementEnabled; private boolean isSerializing; private int nextOID; private Hashtable OIDLookupTable; private int protocolVersion; private boolean useSubclassMethod; }


context:
space:
mode: