obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

1 files changed, 1474 insertions, 0 deletions

diff --git a/libjava/classpath/gnu/CORBA/CDR/Vio.java b/libjava/classpath/gnu/CORBA/CDR/Vio.java
new file mode 100644
index 000000000..1eecb651b
--- /dev/null
+++ b/libjava/classpath/gnu/CORBA/CDR/Vio.java
@@ -0,0 +1,1474 @@
+/* Vio.java -- Value type IO operations.
+   Copyright (C) 2005 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., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 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 gnu.CORBA.CDR;
+
+import gnu.CORBA.Minor;
+import gnu.CORBA.ObjectCreator;
+
+import gnu.java.lang.CPStringBuilder;
+
+import org.omg.CORBA.CustomMarshal;
+import org.omg.CORBA.DataInputStream;
+import org.omg.CORBA.DataOutputStream;
+import org.omg.CORBA.MARSHAL;
+import org.omg.CORBA.NO_IMPLEMENT;
+import org.omg.CORBA.StringSeqHelper;
+import org.omg.CORBA.StringValueHelper;
+import org.omg.CORBA.SystemException;
+import org.omg.CORBA.WStringValueHelper;
+import org.omg.CORBA.portable.BoxedValueHelper;
+import org.omg.CORBA.portable.InputStream;
+import org.omg.CORBA.portable.OutputStream;
+import org.omg.CORBA.portable.Streamable;
+import org.omg.CORBA.portable.ValueFactory;
+
+import java.io.IOException;
+import java.io.Serializable;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Modifier;
+import java.util.StringTokenizer;
+
+import javax.rmi.CORBA.Util;
+import javax.rmi.CORBA.ValueHandler;
+
+/**
+ * A specialised class for reading and writing the value types.
+ *
+ * @author Audrius Meskauskas (AudriusA@Bioinformatics.org)
+ */
+public abstract class Vio
+{
+  /**
+   * If true, wrap value type data into chunks. This decrease the performance,
+   * and is not required for interoperability with jdk 1.5, but is left in the
+   * implementation as the optional mode for solving possible interoperability
+   * problems with non-Sun CORBA implementations.
+   *
+   * The current implementation would accept both single chunk or multiple
+   * chunks, but will always send a single chunk (if true) or unchunked data (if
+   * false).
+   */
+  public static boolean USE_CHUNKING = false;
+
+  /**
+   * The first field in the value record. The last octet may contain additional
+   * flags (vf_CODEBASE, vf_ID and vf_MULTIPLE_IDS). The tag value is different
+   * for the indirections (vt_INDIRECTION) and nulls (vt_NULL).
+   */
+  public static final int vt_VALUE_TAG = 0x7fffff00;
+
+  /**
+   * The value tag flag, indicating that the codebase URL is present in the
+   * value tag record.
+   */
+  public static final int vf_CODEBASE = 0x1;
+
+  /**
+   * The value tag flag, indicating that a single repository id is present in
+   * the value tag record.
+   */
+  public static final int vf_ID = 0x2;
+
+  /**
+   * The value tag flag, indicating, that there are multiple repository ids
+   * present in the record. If this flag is set, the flag vf_ID must also be
+   * set, resulting the value of the least significant byte 0x6.
+   */
+  public static final int vf_MULTIPLE_IDS = 0x4;
+
+  /**
+   * The value tag flag, indicating the presence of chunking. Each chunk is
+   * preceeded by a positive int, indicating the number of bytes in the chunk. A
+   * sequence of chunks is terminated by a non positive int.
+   */
+  public static final int vf_CHUNKING = 0x8;
+
+  /**
+   * The indirection tag value. Such tag must be followed by the CORBA long,
+   * indicating the offset in the CORBA message, where the indirected
+   * information is present. This offset is assumed zero at the position where
+   * the mentioned CORBA long starts and can refer both forward (positive
+   * values) and backward (negative values).
+   */
+  public static final int vt_INDIRECTION = 0xffffffff;
+
+  /**
+   * This tag value means that the value object being transferred is equal to
+   * null.
+   */
+  public static final int vt_NULL = 0x0;
+
+  /**
+   * The size of CORBA long (java int).
+   */
+  static final int INT_SIZE = 4;
+
+  /**
+   * The String value helper (one instance is sufficient).
+   */
+  public static final WStringValueHelper m_StringValueHelper = new WStringValueHelper();
+
+  /**
+   * An instance of the value handler.
+   */
+  static ValueHandler handler = Util.createValueHandler();
+
+  /**
+   * Read the value base from the given input stream. Determines the required
+   * class from the repository id. This includes operations that are not
+   * required when an unitialised instance or at least class of the value type
+   * is known. Hence it may be faster to use the alternative methods,
+   * read(InputStream, Class) or read(InputStream, Serializable).
+   *
+   * @param input a stream to read from.
+   *
+   * @return the loaded value.
+   *
+   * @throws MARSHAL if the reading has failed due any reason.
+   */
+  public static Serializable read(InputStream input)
+  {
+    return read(input, (String) null);
+  }
+
+  /**
+   * Read the value base from the given input stream. Determines the required
+   * class from the repository id. This includes operations that are not
+   * required when an unitialised instance or at least class of the value type
+   * is known. Hence it may be faster to use the alternative methods,
+   * read(InputStream, Class) or read(InputStream, Serializable).
+   *
+   * @param input a stream to read from.
+   * @param repository_id a repository id of the object being read, may be null.
+   *
+   * @return the loaded value.
+   *
+   * @throws MARSHAL if the reading has failed due any reason.
+   */
+  public static Serializable read(InputStream input, String repository_id)
+  {
+    try
+      {
+        final int position = getCurrentPosition(input);
+        // We may need to jump back if the value is read via value factory.
+        input.mark(512);
+
+        int value_tag = input.read_long();
+        checkTag(value_tag);
+
+        String codebase = null;
+        String[] ids = null;
+        String id = repository_id;
+
+        // Check for the agreed null value.
+        if (value_tag == vt_NULL)
+          return null;
+        else if (value_tag == vt_INDIRECTION)
+          return readIndirection(input);
+        else
+          {
+            // Read the value.
+            if ((value_tag & vf_CODEBASE) != 0)
+              {
+                // The codebase is present. The codebase is a space
+                // separated list of URLs from where the implementing
+                // code can be downloaded.
+                codebase = read_string(input);
+              }
+
+            if ((value_tag & vf_MULTIPLE_IDS) != 0)
+              {
+                // Multiple supported repository ids are present.
+                ids = read_string_array(input);
+              }
+            else if ((value_tag & vf_ID) != 0)
+              {
+                // Single supported repository id is present.
+                id = read_string(input);
+              }
+          }
+
+        BoxedValueHelper helper = getHelper(null, id);
+        // The existing implementing object.
+        java.lang.Object ox = null;
+
+        if (helper != null)
+          ox = null; // Helper will care about the instantiating.
+        else if (id.equals(WStringValueHelper.id()))
+          helper = m_StringValueHelper;
+        else
+          ox = createInstance(id, ids, codebase);
+        return (Serializable) read_instance(input, position, ox, value_tag,
+          helper, id, ids, codebase);
+      }
+    catch (Exception ex)
+      {
+        MARSHAL m = new MARSHAL();
+        m.minor = Minor.Value;
+        m.initCause(ex);
+        throw m;
+      }
+  }
+
+  /**
+   * Read the value base from the given input stream when the value base class
+   * is available. Hence there is no need to guess it from the repository id.
+   *
+   * @param input a stream to read from.
+   * @param value_class the class of the value being read.
+   *
+   * @return the loaded value.
+   *
+   * @throws MARSHAL if the reading has failed due any reason.
+   */
+  public static Serializable read(InputStream input, Class value_class)
+  {
+    final int position = getCurrentPosition(input);
+
+    String id = null;
+    String[] ids = null;
+    String codebase = null;
+
+    try
+      {
+        int value_tag = input.read_long();
+        checkTag(value_tag);
+
+        // Check for the agreed null value.
+        if (value_tag == vt_NULL)
+          return null;
+        else if (value_tag == vt_INDIRECTION)
+          return readIndirection(input);
+        else
+          {
+            // Read the value.
+            if ((value_tag & vf_CODEBASE) != 0)
+              {
+                // The codebase is present.
+                codebase = read_string(input);
+              }
+
+            if ((value_tag & vf_MULTIPLE_IDS) != 0)
+              {
+                // Multiple supported repository ids are present.
+                ids = read_string_array(input);
+              }
+            else if ((value_tag & vf_ID) != 0)
+              {
+                // Single supported repository id is present.
+                id = read_string(input);
+              }
+          }
+
+        BoxedValueHelper vHelper = id != null ? getHelper(value_class, id)
+          : getHelper(value_class, ids);
+
+        java.lang.Object ox;
+
+        if (vHelper == null)
+          {
+            try
+              {
+                ox = createInstance(id, ids, codebase);
+              }
+            catch (Exception e)
+              {
+                ox = null;
+              }
+
+            if (ox != null)
+              {
+                if (value_class != null
+                  && !value_class.isAssignableFrom(ox.getClass()))
+                  {
+                    MARSHAL m = new MARSHAL(ox.getClass() + " is not a "
+                    + value_class.getName());
+                    m.minor = Minor.ClassCast;
+                    throw m;
+                  }
+              }
+          }
+        else
+          ox = null;
+
+        ox = read_instance(input, position, ox, value_tag, vHelper, id, ids,
+          codebase);
+        return (Serializable) ox;
+      }
+    catch (MARSHAL m)
+      {
+        throw m;
+      }
+    catch (SystemException sysEx)
+      {
+        // OK.
+        throw sysEx;
+      }
+    catch (Exception ex)
+      {
+        MARSHAL m = new MARSHAL("Cant read " + value_class);
+        m.minor = Minor.Value;
+        m.initCause(ex);
+        throw m;
+      }
+  }
+
+  /**
+   * Read the value base from the given input stream when the unitialised
+   * instance is available. Hence there is no need to guess the class from the
+   * repository id and then to instantiate an instance.
+   *
+   * @param input a stream to read from.
+   *
+   * @param value_instance an pre-created instance of the value. If the helper
+   * is not null, this parameter is ignored an should be null.
+   *
+   * @param helper a helper to create an instance and read the object- specific
+   * part of the record. If the value_instance is used instead, this parameter
+   * should be null.
+   *
+   * @return the loaded value.
+   *
+   * @throws MARSHAL if the reading has failed due any reason.
+   */
+  public static Object read(InputStream input, Object value_instance,
+    BoxedValueHelper helper)
+  {
+    final int position = getCurrentPosition(input);
+
+    String id = null;
+    String[] ids = null;
+    String codebase = null;
+
+    try
+      {
+        int value_tag = input.read_long();
+        checkTag(value_tag);
+
+        // Check for the agreed null value.
+        if (value_tag == vt_NULL)
+          return null;
+        else if (value_tag == vt_INDIRECTION)
+          return readIndirection(input);
+        else
+          {
+            // Read the value.
+            if ((value_tag & vf_CODEBASE) != 0)
+              {
+                // The codebase is present.
+                codebase = read_string(input);
+              }
+
+            if ((value_tag & vf_MULTIPLE_IDS) != 0)
+              {
+                // Multiple supported repository ids are present.
+                ids = read_string_array(input);
+              }
+            else if ((value_tag & vf_ID) != 0)
+              {
+                // Single supported repository id is present.
+                id = read_string(input);
+              }
+          }
+
+        Class value_class = value_instance == null ? null
+          : value_instance.getClass();
+
+        if (helper == null)
+          helper = id != null ? getHelper(value_class, id) : getHelper(
+            value_class, ids);
+
+        value_instance = read_instance(input, position, value_instance,
+          value_tag, helper, id, ids, codebase);
+        return value_instance;
+      }
+    catch (Exception ex)
+      {
+        MARSHAL m = new MARSHAL();
+        m.minor = Minor.Value;
+        m.initCause(ex);
+        throw m;
+      }
+  }
+
+  /**
+   * Read using provided boxed value helper. This method expects the full value
+   * type header, followed by contents, that are delegated to the provided
+   * helper. It handles null.
+   *
+   * @param input the stream to read from.
+   * @param helper the helper that reads the type-specific part of the content.
+   *
+   * @return the value, created by the helper, or null if the header indicates
+   * that null was previously written.
+   */
+  public static Serializable read(InputStream input, BoxedValueHelper helper)
+  {
+    return (Serializable) read(input, null, helper);
+  }
+
+  /**
+   * Fill in the instance fields by the data from the input stream. The method
+   * assumes that the value header, if any, is already behind. The information
+   * from the stream is stored into the passed ox parameter.
+   *
+   * @param input an input stream to read from.
+   *
+   * @param value a pre-instantiated value type object, must be either
+   * Streamable or CustomMarshal. If the helper is used, this parameter is
+   * ignored and should be null.
+   *
+   * @param value_tag the tag that must be read previously.
+   * @param helper the helper for read object specific part; may be null to read
+   * in using other methods.
+   *
+   * @return the value that was read.
+   */
+  static Object read_instance(InputStream input, final int position,
+    Object value, int value_tag, BoxedValueHelper helper, String id,
+    String[] ids, String codebase)
+  {
+    if (helper != m_StringValueHelper && id != null)
+      if (id.equals(StringValueHelper.id()))
+        {
+          value = null;
+          helper = m_StringValueHelper;
+        }
+
+    try
+      {
+        if ((value_tag & vf_CHUNKING) != 0)
+          {
+            BufferedCdrOutput output = createBuffer(input, 1024);
+            // Read the current (not a nested one) value in this spec case.
+            readNestedValue(value_tag, input, output, -1);
+            BufferredCdrInput ci = new BufferredCdrInput(output.buffer.getBuffer());
+            ci.setRunTime(output.getRunTime());
+
+            input = new HeadlessInput(ci, input);
+          }
+        else
+          {
+            if (input instanceof BufferredCdrInput)
+              {
+                // Highly probable case.
+                input = new HeadlessInput((BufferredCdrInput) input, null);
+              }
+            else if (input instanceof HeadlessInput)
+              {
+                // There is no need to instantiate one more HeadlessInput
+                // as we can just reset.
+                ((HeadlessInput) input).subsequentCalls = false;
+              }
+            else
+              {
+                BufferedCdrOutput bout = new BufferedCdrOutput();
+                int c;
+                while ((c = input.read()) >= 0)
+                  bout.write((byte) c);
+                input = new HeadlessInput(
+                  (BufferredCdrInput) bout.create_input_stream(), input);
+              }
+          }
+      }
+    catch (IOException ex)
+      {
+        MARSHAL m = new MARSHAL("Unable to read chunks");
+        m.minor = Minor.Value;
+        m.initCause(ex);
+        throw m;
+      }
+
+    return readValue(input, position, value, helper, id, ids, codebase);
+  }
+
+  /**
+   * Create a buffer, inheriting critical settings from the passed input stream.
+   */
+  private static BufferedCdrOutput createBuffer(InputStream input, int proposed_size)
+  {
+    BufferedCdrOutput bout;
+    bout = new BufferedCdrOutput(2 * proposed_size + 256);
+
+    if (input instanceof BufferredCdrInput)
+      {
+        BufferredCdrInput in = (BufferredCdrInput) input;
+        bout.setBigEndian(in.isBigEndian());
+      }
+
+    if (input instanceof gnuValueStream)
+      bout.setRunTime(((gnuValueStream) input).getRunTime());
+    else
+      bout.setRunTime(new gnuRuntime(null, null));
+    return bout;
+  }
+
+  /**
+   * Read the chunked nested value from the given input stream, transferring the
+   * contents to the given output stream.
+   *
+   * @param value_tag the value tag of the value being read.
+   * @param input the input stream from where the remainder of the nested value
+   * must be read.
+   * @param output the output stream where the unchunked nested value must be
+   * copied.
+   *
+   * @return the tag that ended the nested value.
+   */
+  public static int readNestedValue(int value_tag, InputStream input,
+    BufferedCdrOutput output, int level)
+    throws IOException
+  {
+    String id = null;
+    if (level < -1)
+      {
+        // For the first level, this information is already behind.
+        output.write_long(value_tag - vf_CHUNKING);
+
+        // The nested value should be aways chunked.
+        if ((value_tag & vf_CHUNKING) == 0)
+          {
+            MARSHAL m = new MARSHAL("readNestedValue: must be chunked");
+            m.minor = Minor.Chunks;
+            throw m;
+          }
+        else if (value_tag == vt_NULL)
+          {
+            MARSHAL m = new MARSHAL("readNestedValue: nul");
+            m.minor = Minor.Chunks;
+            throw m;
+          }
+        else if (value_tag == vt_INDIRECTION)
+          {
+            MARSHAL m = new MARSHAL("readNestedValue: indirection");
+            m.minor = Minor.Chunks;
+            throw m;
+          }
+        else
+          {
+            // Read the value.
+            if ((value_tag & vf_CODEBASE) != 0)
+              {
+                String codebase = read_string(input);
+                write_string(output, codebase);
+              }
+
+            if ((value_tag & vf_MULTIPLE_IDS) != 0)
+              {
+                // Multiple supported repository ids are present.
+                String[] ids = read_string_array(input);
+                id = ids[0];
+                write_string_array(output, ids);
+              }
+            else if ((value_tag & vf_ID) != 0)
+              {
+                id = read_string(input);
+                write_string(output, id);
+              }
+          }
+      }
+
+    int n = -1;
+
+    // Read all chunks.
+    int chunk_size;
+
+    byte[] r = null;
+
+    while (true)
+      {
+        // Read the size of the next chunk or it may also be the
+        // header of the nested value.
+        chunk_size = input.read_long();
+
+        // End of chunk terminator.
+        if (chunk_size < 0 && chunk_size >= level)
+          return chunk_size;
+        else if (chunk_size >= 0x7FFFFF00)
+          {
+            int onInput = getCurrentPosition(input) - 4;
+            int onOutput = output.getPosition();
+            output.getRunTime().redirect(onInput, onOutput);
+            // Value over 0x7FFFFF00 indicates that the nested value
+            // starts here. Read the nested value, storing it into the output.
+            // First parameter is actually the value tag.
+            chunk_size = readNestedValue(chunk_size, input, output, level - 1);
+            if (chunk_size < 0 && chunk_size >= level)
+              return chunk_size;
+          }
+        else
+          {
+            // The chunk follows.
+            if (r == null || r.length < chunk_size)
+              r = new byte[chunk_size + 256];
+
+            n = 0;
+            while (n < chunk_size)
+              n += input.read(r, n, chunk_size - n);
+            output.write(r, 0, n);
+          }
+      }
+  }
+
+  /**
+   * Read the value (the header must be behind).
+   */
+  public static Serializable readValue(InputStream input, final int position,
+    Object value, BoxedValueHelper helper, String id, String[] ids,
+    String codebase)
+  {
+    gnuRuntime g;
+    gnuValueStream c = ((gnuValueStream) input);
+    if (c.getRunTime() == null)
+      {
+        g = new gnuRuntime(codebase, value);
+        c.setRunTime(g);
+      }
+    else
+      {
+        g = c.getRunTime();
+        g.addCodeBase(codebase);
+        g.target = (Serializable) value;
+      }
+    if (value != null)
+      g.objectWritten(value, position);
+
+    if (input instanceof HeadlessInput)
+      ((HeadlessInput) input).subsequentCalls = false;
+
+    boolean ok = true;
+
+    // The user-defined io operations are implemented.
+    if (value instanceof CustomMarshal)
+      {
+        CustomMarshal marsh = (CustomMarshal) value;
+        marsh.unmarshal((DataInputStream) input);
+      }
+    else
+    // The IDL-generated io operations are implemented.
+    if (value instanceof Streamable)
+      {
+        ((Streamable) value)._read(input);
+      }
+    else if (helper != null)
+      {
+        // If helper is non-null the value should normally be null.
+        value = helper.read_value(input);
+        g.objectWritten(value, position);
+      }
+    else
+      {
+        ok = false;
+        ValueFactory factory = null;
+        org.omg.CORBA_2_3.ORB orb = (org.omg.CORBA_2_3.ORB) input.orb();
+
+        if (id != null)
+          factory = orb.lookup_value_factory(id);
+
+        if (factory == null && ids != null)
+          {
+            for (int i = 0; i < ids.length && factory == null; i++)
+              {
+                factory = orb.lookup_value_factory(ids[i]);
+              }
+          }
+
+        if (factory != null)
+          {
+            value = factory.read_value((org.omg.CORBA_2_3.portable.InputStream) input);
+            ok = true;
+          }
+      }
+
+    if (!ok && value instanceof Serializable)
+    // Delegate to ValueHandler
+      {
+        if (ids != null && ids.length > 0)
+          id = ids[0];
+
+        value = handler.readValue(input, position, value.getClass(), id, g);
+        ok = true;
+      }
+
+    if (!ok)
+      {
+        if (value != null)
+          {
+            MARSHAL m = new MARSHAL(value.getClass().getName()
+            + " must be Streamable, CustomMarshal or Serializable");
+            m.minor = Minor.UnsupportedValue;
+            throw m;
+          }
+        else
+          {
+            MARSHAL m = new MARSHAL("Unable to instantiate " + id + ":" + list(ids)
+            + " helper " + helper);
+            m.minor = Minor.UnsupportedValue;
+            throw m;
+          }
+      }
+    else
+      return (Serializable) value;
+  }
+
+  /**
+   * Conveniency method to list ids in exception reports.
+   */
+  static String list(String[] s)
+  {
+    if (s == null)
+      return "null";
+    else
+      {
+        CPStringBuilder b = new CPStringBuilder("{");
+        for (int i = 0; i < s.length; i++)
+          {
+            b.append(s[i]);
+            b.append(" ");
+          }
+        b.append("}");
+        return b.toString();
+      }
+  }
+
+  /**
+   * Write the value base into the given stream.
+   *
+   * @param output a stream to write to.
+   *
+   * @param value a value type object, must be either Streamable or
+   * CustomMarshal.
+   *
+   * @throws MARSHAL if the writing failed due any reason.
+   */
+  public static void write(OutputStream output, Serializable value)
+  {
+    // Write null if this is a null value.
+    if (value == null)
+      output.write_long(vt_NULL);
+    else if (value instanceof String)
+      write(output, value, m_StringValueHelper);
+    else
+      write(output, value, value.getClass());
+  }
+
+  /**
+   * Write the value base into the given stream, stating that it is an instance
+   * of the given class.
+   *
+   * @param output a stream to write to.
+   *
+   * @param value a value to write.
+   *
+   * @throws MARSHAL if the writing failed due any reason.
+   */
+  public static void write(OutputStream output, Serializable value,
+    Class substitute)
+  {
+    // Write null if this is a null value.
+    if (value == null)
+      output.write_long(vt_NULL);
+    else if (value instanceof String || substitute == String.class)
+      writeString(output, value);
+    else
+      {
+        String vId = ObjectCreator.getRepositoryId(value.getClass());
+        if (substitute == null || value.getClass().equals(substitute))
+          write_instance(output, value, vId, getHelper(value.getClass(), vId));
+        else
+          {
+            String vC = ObjectCreator.getRepositoryId(substitute);
+            String[] ids = new String[] { vId, vC };
+            BoxedValueHelper h = getHelper(substitute.getClass(), ids);
+            // If the helper is available, it is also responsible for
+            // providing the repository Id. Otherwise, write both
+            // ids.
+            if (h == null)
+              write_instance(output, value, ids, null);
+            else
+              write_instance(output, value, h.get_id(), null);
+          }
+      }
+  }
+
+  /**
+   * Write the value base into the given stream, supplementing it with an array
+   * of the provided repository ids plus the repository id, derived from the
+   * passed value.
+   *
+   * @param output a stream to write to.
+   *
+   * @param value a value to write.
+   *
+   * @throws MARSHAL if the writing failed due any reason.
+   */
+  public static void write(OutputStream output, Serializable value,
+    String[] multiple_ids)
+  {
+    // Write null if this is a null value.
+    if (value == null)
+      output.write_long(vt_NULL);
+    else
+      {
+        String[] ids = new String[multiple_ids.length + 1];
+        ids[0] = ObjectCreator.getRepositoryId(value.getClass());
+        System.arraycopy(multiple_ids, 0, ids, 1, multiple_ids.length);
+        BoxedValueHelper h = getHelper(value.getClass(), ids);
+        write_instance(output, value, ids, h);
+      }
+  }
+
+  /**
+   * Write value when its repository Id is explicitly given. Only this Id is
+   * written, the type of value is not taken into consideration.
+   *
+   * @param output an output stream to write into.
+   * @param value a value to write.
+   * @param id a value repository id.
+   */
+  public static void write(OutputStream output, Serializable value, String id)
+  {
+    if (value == null)
+      output.write_long(vt_NULL);
+    else
+      write_instance(output, value, id, getHelper(value.getClass(), id));
+  }
+
+  /**
+   * Write standard value type header, followed by contents, produced by the
+   * boxed value helper.
+   *
+   * @param output the stream to write to.
+   * @param value the value to write, can be null.
+   * @param helper the helper that writes the value content if it is not null
+   * (must be provided for this method).
+   */
+  public static void write(OutputStream output, Serializable value,
+    BoxedValueHelper helper)
+  {
+    if (helper == null)
+      throw new AssertionError("Helper must be provided");
+    if (value == null)
+      output.write_long(vt_NULL);
+    else
+      write_instance(output, value, helper.get_id(), helper);
+  }
+
+  /**
+   * Write the parameter that is surely a string and not null.
+   */
+  private static void writeString(OutputStream output, Serializable string)
+  {
+    write_instance(output, string, m_StringValueHelper.get_id(),
+      m_StringValueHelper);
+  }
+
+  /**
+   * Write value when its repository Id is explicitly given. Does not handle
+   * null.
+   *
+   * @param output an output stream to write into.
+   * @param value a value to write.
+   * @param ids a value repository id (can be either single string or string
+   * array).
+   * @param helper a helper, writing object - specifical part. Can be null if
+   * the value should be written using other methods.
+   */
+  static void write_instance(OutputStream output, Serializable value,
+    Object ids, BoxedValueHelper helper)
+  {
+    gnuValueStream rout = null;
+    gnuRuntime runtime = null;
+
+    try
+      {
+        if (output instanceof gnuValueStream)
+          {
+            int position;
+            rout = (gnuValueStream) output;
+            runtime = rout.getRunTime();
+
+            if (runtime == null)
+              {
+                runtime = new gnuRuntime(null, value);
+                rout.setRunTime(runtime);
+                rout.getRunTime().objectWritten(value,
+                  position = rout.getPosition());
+              }
+            else if (runtime.target == value)
+              {
+                if (!writeSelf(output, value))
+                  throw new InternalError("Recursive helper call for "
+                    + value.getClass().getName());
+                return;
+              }
+            else
+              {
+                position = runtime.isWrittenAt(value);
+                if (position >= 0)
+                  {
+                    // The object was already written.
+                    output.write_long(vt_INDIRECTION);
+                    output.write_long(position - rout.getPosition());
+                    // Replacing object write data by indirection reference.
+                    return;
+                  }
+                else
+                  {
+                    runtime.objectWritten(value, position = rout.getPosition());
+                  }
+              }
+          }
+
+        int value_tag = vt_VALUE_TAG;
+
+        if (ids instanceof String)
+          value_tag |= vf_ID;
+        else if (ids instanceof String[])
+          // OMG standard requires to set both flags.
+          value_tag |= vf_MULTIPLE_IDS | vf_ID;
+
+        int chunkSizeLocation;
+
+        OutputStream outObj;
+
+        if (USE_CHUNKING)
+          {
+            // Wrap the value being written into one chunk (makes sense only for
+            // compatibility reasons).
+            outObj = output;
+            value_tag |= vf_CHUNKING;
+          }
+        else
+          outObj = output;
+
+        output.write_long(value_tag);
+
+        if ((value_tag & vf_MULTIPLE_IDS) != 0)
+          write_string_array(output, (String[]) ids);
+        else if ((value_tag & vf_ID) != 0)
+          write_string(output, (String) ids);
+
+        if (USE_CHUNKING)
+          {
+            // So far, write 0x55555555 instead of the chunk size (alignment may
+            // take place).
+            output.write_long(0x55555555);
+            // If the chunking is involved, the chunk size must be written here.
+            chunkSizeLocation = rout.getPosition() - INT_SIZE;
+          }
+        else
+          // Not in use for this case.
+          chunkSizeLocation = -1;
+
+        writeValue(outObj, value, helper);
+
+        if (USE_CHUNKING)
+          {
+            // Write the chunk size where the place for it was reserved.
+            int chunkSize = rout.getPosition() - chunkSizeLocation - INT_SIZE;
+            int current = rout.getPosition();
+            rout.seek(chunkSizeLocation);
+            output.write_long(chunkSize);
+            rout.seek(current);
+
+            // The end of record marker.
+            output.write_long(-1);
+          }
+      }
+    finally
+      {
+        if (runtime != null)
+          runtime.target = null;
+      }
+  }
+
+  /**
+   * Write value (after header).
+   */
+  static void writeValue(OutputStream output, Serializable value,
+    BoxedValueHelper helper)
+  {
+    ((gnuValueStream) output).getRunTime().target = value;
+    if (helper != null)
+      helper.write_value(output, value);
+    else if (!writeSelf(output, value))
+      {
+        // Try to find helper via class loader.
+        boolean ok = false;
+
+        if (!ok)
+          {
+            if (output instanceof BufferedCdrOutput)
+              {
+                BufferedCdrOutput b = (BufferedCdrOutput) output;
+                if (b.runtime == null)
+                  b.runtime = new gnuRuntime(null, value);
+              }
+
+            handler.writeValue(output, value);
+          }
+      }
+  }
+
+  /**
+   * Try to write value supposing that it implements self-streamable interfaces.
+   * Return false if it does not or true on success.
+   */
+  static boolean writeSelf(OutputStream output, Serializable value)
+  {
+    // User defined write method is present.
+    if (value instanceof CustomMarshal)
+      {
+        ((CustomMarshal) value).marshal((DataOutputStream) output);
+        return true;
+      }
+    else if (value instanceof Streamable)
+      {
+        ((Streamable) value)._write(output);
+        return true;
+      }
+    return false;
+  }
+
+  /**
+   * Read the indirection data and return the object that was already written to
+   * this stream.
+   *
+   * @param an_input the input stream, must be BufferredCdrInput.
+   */
+  static Serializable readIndirection(InputStream an_input)
+  {
+    if (!(an_input instanceof gnuValueStream))
+      throw new NO_IMPLEMENT(gnuValueStream.class.getName()
+        + " expected as parameter");
+
+    gnuValueStream in = (gnuValueStream) an_input;
+
+    int current_pos = in.getPosition();
+
+    int offset = an_input.read_long();
+    if (offset > -INT_SIZE)
+      {
+        MARSHAL m = new MARSHAL("Indirection tag refers to " + offset
+        + " (must be less than -" + INT_SIZE + ")");
+        m.minor = Minor.Offset;
+        throw m;
+      }
+
+    int stored_at = current_pos + offset;
+
+    if (in.getRunTime() == null)
+      {
+        MARSHAL m = new MARSHAL(stored_at + " offset " + offset + ": not written");
+        m.minor = Minor.Value;
+        throw m;
+      }
+
+    return (Serializable) in.getRunTime().isObjectWrittenAt(stored_at, offset);
+  }
+
+  /**
+   * Check the passed value tag for correctness.
+   *
+   * @param value_tag a tag to check, must be between 0x7fffff00 and 0x7fffffff
+   *
+   * @throws MARSHAL if the tag is outside this interval.
+   */
+  static void checkTag(int value_tag)
+  {
+    if ((value_tag < 0x7fffff00 || value_tag > 0x7fffffff)
+      && value_tag != vt_NULL && value_tag != vt_INDIRECTION)
+      {
+        MARSHAL m = new MARSHAL("Invalid value record, unsupported header tag: "
+        + value_tag + " (0x" + Integer.toHexString(value_tag) + ")");
+        m.minor = Minor.ValueHeaderTag;
+        throw m;
+      }
+
+    if ((value_tag & vf_MULTIPLE_IDS) != 0 && (value_tag & vf_ID) == 0)
+      {
+        MARSHAL m = new MARSHAL("Invalid value record header flag combination (0x"
+        + Integer.toHexString(value_tag) + ")");
+        m.minor = Minor.ValueHeaderFlags;
+        throw m;
+      }
+  }
+
+  /**
+   * Throw MARSHAL.
+   */
+  static void throwIt(String msg, String id1, String id2, Throwable e)
+    throws MARSHAL
+  {
+    MARSHAL m = new MARSHAL(msg + ":'" + id1 + "' versus '" + id2 + "'");
+    if (e != null)
+      m.initCause(e);
+    m.minor = Minor.Value;
+    throw m;
+  }
+
+  /**
+   * Load class by name and create the instance.
+   */
+  static Object createInstance(String id, String[] ids, String codebase)
+  {
+    Object o = null;
+
+    if (id != null)
+      o = _createInstance(id, codebase);
+
+    if (ids != null)
+      for (int i = 0; i < ids.length && o == null; i++)
+        o = _createInstance(ids[i], codebase);
+    return o;
+  }
+
+  static Object _createInstance(String id, String codebase)
+  {
+    if (id == null)
+      return null;
+    if (id.equals(StringValueHelper.id()))
+      return "";
+    StringTokenizer st = new StringTokenizer(id, ":");
+
+    String prefix = st.nextToken();
+    if (prefix.equalsIgnoreCase("IDL"))
+      return ObjectCreator.Idl2Object(id);
+    else if (prefix.equalsIgnoreCase("RMI"))
+      {
+        String className = st.nextToken();
+        String hashCode = st.nextToken();
+        String sid = null;
+        if (st.hasMoreElements())
+          sid = st.nextToken();
+
+        try
+          {
+            Class objectClass = Util.loadClass(className, codebase,
+              Vio.class.getClassLoader());
+
+            String rid = ObjectCreator.getRepositoryId(objectClass);
+
+            if (!rid.equals(id))
+              {
+                // If direct string comparison fails, compare by meaning.
+                StringTokenizer st2 = new StringTokenizer(rid, ":");
+                if (!st2.nextToken().equals("RMI"))
+                  throw new InternalError("RMI format expected: '" + rid + "'");
+                if (!st2.nextToken().equals(className))
+                  throwIt("Class name mismatch", id, rid, null);
+
+                try
+                  {
+                    long h1 = Long.parseLong(hashCode, 16);
+                    long h2 = Long.parseLong(st2.nextToken(), 16);
+                    if (h1 != h2)
+                      throwIt("Hashcode mismatch", id, rid, null);
+
+                    if (sid != null && st2.hasMoreTokens())
+                      {
+                        long s1 = Long.parseLong(hashCode, 16);
+                        long s2 = Long.parseLong(st2.nextToken(), 16);
+                        if (s1 != s2)
+                          throwIt("serialVersionUID mismatch", id, rid, null);
+                      }
+                  }
+                catch (NumberFormatException e)
+                  {
+                    throwIt("Invalid hashcode or svuid format: ", id, rid, e);
+                  }
+              }
+
+            // Low - level instantiation required here.
+            return instantiateAnyWay(objectClass);
+          }
+        catch (Exception ex)
+          {
+            MARSHAL m = new MARSHAL("Unable to instantiate " + id);
+            m.minor = Minor.Instantiation;
+            m.initCause(ex);
+            throw m;
+          }
+      }
+    else
+      throw new NO_IMPLEMENT("Unsupported prefix " + prefix + ":");
+  }
+
+  /**
+   * Read string, expecting the probable indirection.
+   */
+  static String read_string(InputStream input)
+  {
+    gnuValueStream g = (gnuValueStream) input;
+    int previous = g.getPosition();
+    int l = input.read_long();
+    if (l != vt_INDIRECTION)
+      {
+        g.seek(previous);
+        String s = input.read_string();
+        if (g.getRunTime() == null)
+          g.setRunTime(new gnuRuntime(null, null));
+        g.getRunTime().singleIdWritten(s, previous);
+        return s;
+      }
+    else
+      {
+        gnuRuntime r = g.getRunTime();
+        int base = g.getPosition();
+        int delta = input.read_long();
+        if (r == null)
+          {
+            previous = g.getPosition();
+            g.seek(base + delta);
+            String indir = input.read_string();
+            g.seek(previous);
+            return indir;
+          }
+        else
+          {
+            return (String) r.isObjectWrittenAt(base + delta, delta);
+          }
+      }
+  }
+
+  /**
+   * Read string array, expecting the probable indirection.
+   */
+  static String[] read_string_array(InputStream input)
+  {
+    gnuValueStream g = (gnuValueStream) input;
+    int previous = g.getPosition();
+    int l = input.read_long();
+    if (l != vt_INDIRECTION)
+      {
+        g.seek(previous);
+        String[] s = StringSeqHelper.read(input);
+        if (g.getRunTime() == null)
+          g.setRunTime(new gnuRuntime(null, null));
+        g.getRunTime().objectWritten(s, previous);
+        return s;
+      }
+    else
+      {
+        gnuRuntime r = g.getRunTime();
+        int base = g.getPosition();
+        int delta = input.read_long();
+        if (r == null)
+          {
+            previous = g.getPosition();
+            g.seek(base + delta);
+            String[] indir = StringSeqHelper.read(input);
+            g.seek(previous);
+            return indir;
+          }
+        else
+          {
+            return (String[]) r.isObjectWrittenAt(base + delta, delta);
+          }
+      }
+  }
+
+  /**
+   * Write repository Id, probably shared.
+   */
+  static void write_string(OutputStream output, String id)
+  {
+    if (output instanceof gnuValueStream)
+      {
+        gnuValueStream b = (gnuValueStream) output;
+        if (b != null)
+          {
+            int written = b.getRunTime().idWrittenAt(id);
+            if (written >= 0)
+              {
+                // Reuse existing id record.
+                output.write_long(vt_INDIRECTION);
+                int p = b.getPosition();
+                output.write_long(written - p);
+              }
+            else
+              {
+                b.getRunTime().singleIdWritten(id, b.getPosition());
+                output.write_string(id);
+              }
+          }
+      }
+    else
+      output.write_string(id);
+  }
+
+  /**
+   * Write repository Id, probably shared.
+   */
+  static void write_string_array(OutputStream output, String[] ids)
+  {
+    if (output instanceof gnuValueStream)
+      {
+        gnuValueStream b = (gnuValueStream) output;
+        if (b != null)
+          {
+            int written = b.getRunTime().idWrittenAt(ids);
+            if (written >= 0)
+              {
+                // Reuse existing id record.
+                output.write_long(vt_INDIRECTION);
+                int p = b.getPosition();
+                output.write_long(written - p);
+              }
+            else
+              {
+                b.getRunTime().multipleIdsWritten(ids, b.getPosition());
+                StringSeqHelper.write(output, ids);
+              }
+          }
+      }
+    else
+      StringSeqHelper.write(output, ids);
+  }
+
+  /**
+   * Get the helper that could write the given object, or null if no pre-defined
+   * helper available for this object.
+   */
+  public static BoxedValueHelper getHelper(Class x, Object ids)
+  {
+    if (x != null && x.equals(String.class))
+      return m_StringValueHelper;
+    else if (x != null && x.isArray())
+      return new ArrayValueHelper(x);
+    else if (ids instanceof String)
+      return locateHelper((String) ids);
+    else if (ids instanceof String[])
+      {
+        String[] ia = (String[]) ids;
+        BoxedValueHelper h;
+        for (int i = 0; i < ia.length; i++)
+          {
+            h = locateHelper(ia[i]);
+            if (h != null)
+              return h;
+          }
+        return null;
+      }
+    else
+      return null;
+  }
+
+  /**
+   * Get the helper that could write the given object, or null if no pre-defined
+   * helper available for this object.
+   */
+  public static BoxedValueHelper getHelper(Class x, String id)
+  {
+    if (x != null && x.equals(String.class))
+      return m_StringValueHelper;
+    else if (x != null && x.isArray())
+      return new ArrayValueHelper(x);
+    else
+      return locateHelper(id);
+  }
+
+  /**
+   * Try to locate helper from the repository id.
+   */
+  static BoxedValueHelper locateHelper(String id)
+  {
+    if (id != null)
+      {
+        if (id.equals(m_StringValueHelper.get_id()))
+          return m_StringValueHelper;
+        else
+        // Try to locate helper for IDL type.
+        if (id.startsWith("IDL:"))
+          {
+            try
+              {
+                Class helperClass = ObjectCreator.findHelper(id);
+                if (BoxedValueHelper.class.isAssignableFrom(helperClass))
+                  return (BoxedValueHelper) helperClass.newInstance();
+                else if (helperClass != null)
+                  return new IDLTypeHelper(helperClass);
+                else
+                  return null;
+              }
+            catch (Exception ex)
+              {
+                return null;
+              }
+          }
+      }
+    return null;
+  }
+
+  /**
+   * Get the current position.
+   */
+  static int getCurrentPosition(InputStream x)
+  {
+    if (x instanceof gnuValueStream)
+      return ((gnuValueStream) x).getPosition();
+    else
+      return 0;
+  }
+
+  /**
+   * Instantiate an instance of this class anyway; also in the case when it has
+   * no parameterless or any other constructor. The fields will be assigned
+   * while reading the class from the stream.
+   *
+   * @param clazz a class for that the instance should be instantiated.
+   */
+  public static Object instantiateAnyWay(Class clazz)
+    throws Exception
+  {
+    Class first_nonserial = clazz;
+
+    while (Serializable.class.isAssignableFrom(first_nonserial)
+      || Modifier.isAbstract(first_nonserial.getModifiers()))
+      first_nonserial = first_nonserial.getSuperclass();
+
+    final Class local_constructor_class = first_nonserial;
+
+    Constructor constructor = local_constructor_class.getDeclaredConstructor(new Class[0]);
+
+    return VMVio.allocateObject(clazz, constructor.getDeclaringClass(),
+      constructor);
+  }
+}