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.

16 files changed, 5434 insertions, 0 deletions

diff --git a/libjava/classpath/gnu/CORBA/DynAn/AbstractAny.java b/libjava/classpath/gnu/CORBA/DynAn/AbstractAny.java
new file mode 100644
index 000000000..0f3b897df
--- /dev/null
+++ b/libjava/classpath/gnu/CORBA/DynAn/AbstractAny.java
@@ -0,0 +1,177 @@
+/* AbstractAny.java --
+   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.DynAn;
+
+import gnu.CORBA.TypeKindNamer;
+
+import org.omg.CORBA.Any;
+import org.omg.CORBA.LocalObject;
+import org.omg.CORBA.ORB;
+import org.omg.CORBA.TypeCode;
+import org.omg.DynamicAny.DynAnyPackage.TypeMismatch;
+
+import java.io.Serializable;
+
+/**
+ * The top of our DynAny implementation, this class provides ORB that is
+ * required to create anys and factory that is required to initialise DynAnys.
+ *
+ * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
+ */
+public abstract class AbstractAny
+  extends LocalObject
+  implements Serializable
+{
+  /**
+   * Use serialVersionUID for interoperability.
+   */
+  private static final long serialVersionUID = 1;
+
+  /**
+   * The "initial final_type" that can be an alias of the known final_type.
+   */
+  public TypeCode official_type;
+
+  /**
+   * The "basic" final_type to that the final_type finally evaluates.
+   */
+  public final TypeCode final_type;
+
+  /**
+   * The DynAny factory, required in initializations.
+   */
+  public final gnuDynAnyFactory factory;
+
+  /**
+   * The ORB, to that this DynAny belongs.
+   */
+  public final ORB orb;
+
+  /**
+   * The minor code, indicating the error, related to work with non - GNU
+   * Classpath DynAny.
+   */
+  short MINOR = 8148;
+
+  /**
+   * The message about the empty structure or exception.
+   */
+  static final String EMPTY = "Empty structure with no fields.";
+
+  /**
+   * The message about the structure or exception size mismatch.
+   */
+  static final String SIZE = "Size mismatch.";
+
+  /**
+   * The message about the content of this DynAny being equal to
+   * <code>null</code>
+   */
+  static final String ISNULL = "The content is null";
+
+  /**
+   * The change value listener.
+   */
+  ValueChangeListener listener;
+
+  /**
+   * Create the abstract dyn any.
+   */
+  public AbstractAny(TypeCode oType, TypeCode aType,
+                        gnuDynAnyFactory aFactory, ORB anOrb
+                       )
+  {
+    official_type = oType;
+    final_type = aType;
+    factory = aFactory;
+    orb = anOrb;
+  }
+
+  /**
+   * Get the typecode.
+   */
+  public TypeCode type()
+  {
+    return official_type;
+  }
+
+  /**
+   * Create the Any.
+   */
+  public Any createAny()
+  {
+    return orb.create_any();
+  }
+
+  /**
+   * The "value changed" listener.
+   */
+  protected void valueChanged()
+  {
+    if (listener != null)
+      listener.changed();
+  }
+
+  /**
+   * Check the type.
+   */
+  void checkType(TypeCode expected, TypeCode actual)
+          throws TypeMismatch
+  {
+    if (!expected.equal(actual))
+      throw new TypeMismatch(typeMismatch(expected, actual));
+  }
+
+  /**
+   * Format "Type mismatch" string.
+   */
+  String typeMismatch(TypeCode expected, TypeCode actual)
+  {
+    return TypeKindNamer.nameIt(expected) + " expected " +
+           TypeKindNamer.nameIt(actual);
+  }
+
+  /**
+   * Format "size mismatch" string.
+   */
+  String sizeMismatch(int here, int other)
+  {
+    return "Size mismatch, " + other + " (expected " + here + ")";
+  }
+}
diff --git a/libjava/classpath/gnu/CORBA/DynAn/DivideableAny.java b/libjava/classpath/gnu/CORBA/DynAn/DivideableAny.java
new file mode 100644
index 000000000..ae73cfe6f
--- /dev/null
+++ b/libjava/classpath/gnu/CORBA/DynAn/DivideableAny.java
@@ -0,0 +1,512 @@
+/* DivideableAny.java --
+   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.DynAn;
+
+import org.omg.CORBA.Any;
+import org.omg.CORBA.CompletionStatus;
+import org.omg.CORBA.ORB;
+import org.omg.CORBA.Object;
+import org.omg.CORBA.TypeCode;
+import org.omg.CORBA.UNKNOWN;
+import org.omg.DynamicAny.DynAny;
+import org.omg.DynamicAny.DynAnyPackage.InvalidValue;
+import org.omg.DynamicAny.DynAnyPackage.TypeMismatch;
+import org.omg.DynamicAny.DynValueCommon;
+
+import java.io.Serializable;
+
+/**
+ * Provides a base for DynAnys, having multiple components.
+ *
+ * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
+ */
+public abstract class DivideableAny
+  extends AbstractAny
+  implements Serializable
+{
+  /**
+   * Use serialVersionUID for interoperability.
+   */
+  private static final long serialVersionUID = 1;
+
+  /**
+   * The array of the components that in general case may have different
+   * final_type.
+   */
+  protected DynAny[] array;
+
+  /**
+   * The internal pointer.
+   */
+  protected int pos = 0;
+
+  public DivideableAny(TypeCode oType, TypeCode aType,
+                       gnuDynAnyFactory aFactory, ORB anOrb
+                      )
+  {
+    super(oType, aType, aFactory, anOrb);
+  }
+
+  /**
+   * Advance forward.
+   */
+  public boolean next()
+  {
+    pos++;
+    return array.length > pos;
+  }
+
+  /**
+   * Set zero position.
+   */
+  public void rewind()
+  {
+    pos = 0;
+  }
+
+  /**
+   * Set a position.
+   */
+  public boolean seek(int p)
+  {
+    pos = p;
+    return pos >= 0 && array.length > pos;
+  }
+
+  /**
+   * Get the insertion point as DynAny. This method may throw exceptions if the
+   * current insertion point does not support reading or insertion of the
+   * primitive types.
+   *
+   * @return the focused component, from where the primitve value can be read or
+   * where it can be inserted.
+   * @throws InvalidValue if the primitive value cannot be inserted at the given
+   * point.
+   */
+  protected DynAny focused()
+                    throws InvalidValue, TypeMismatch
+  {
+    if (pos >= 0 && pos < array.length)
+      {
+        if (array [ pos ].component_count() == 0)
+          return array [ pos ];
+        else
+          throw new TypeMismatch("Multiple coponents at " + pos);
+      }
+    else
+      throw new InvalidValue("Out of bounds at " + pos + " valid 0.." +
+                             (array.length - 1)
+                            );
+  }
+
+  /** {@inheritDoc} */
+  public int component_count()
+  {
+    return array.length;
+  }
+
+  /**
+   * Return the second (enclosed any) that is stored in the wrapped Any.
+   */
+  public Any get_any()
+              throws TypeMismatch, InvalidValue
+  {
+    return focused().get_any();
+  }
+
+  /** {@inheritDoc} */
+  public boolean get_boolean()
+                      throws TypeMismatch, InvalidValue
+  {
+    return focused().get_boolean();
+  }
+
+  /** {@inheritDoc} */
+  public char get_char()
+                throws TypeMismatch, InvalidValue
+  {
+    return focused().get_char();
+  }
+
+  /** {@inheritDoc} */
+  public double get_double()
+                    throws TypeMismatch, InvalidValue
+  {
+    return focused().get_double();
+  }
+
+  /** {@inheritDoc} */
+  public float get_float()
+                  throws TypeMismatch, InvalidValue
+  {
+    return focused().get_float();
+  }
+
+  /** {@inheritDoc} */
+  public int get_long()
+               throws TypeMismatch, InvalidValue
+  {
+    return focused().get_long();
+  }
+
+  /** {@inheritDoc} */
+  public long get_longlong()
+                    throws TypeMismatch, InvalidValue
+  {
+    return focused().get_longlong();
+  }
+
+  /** {@inheritDoc} */
+  public byte get_octet()
+                 throws TypeMismatch, InvalidValue
+  {
+    return focused().get_octet();
+  }
+
+  /** {@inheritDoc} */
+  public Object get_reference()
+                       throws TypeMismatch, InvalidValue
+  {
+    return focused().get_reference();
+  }
+
+  /** {@inheritDoc} */
+  public short get_short()
+                  throws TypeMismatch, InvalidValue
+  {
+    return focused().get_short();
+  }
+
+  /** {@inheritDoc} */
+  public String get_string()
+                    throws TypeMismatch, InvalidValue
+  {
+    return focused().get_string();
+  }
+
+  /** {@inheritDoc} */
+  public TypeCode get_typecode()
+                        throws TypeMismatch, InvalidValue
+  {
+    return focused().get_typecode();
+  }
+
+  /** {@inheritDoc} */
+  public int get_ulong()
+                throws TypeMismatch, InvalidValue
+  {
+    return focused().get_ulong();
+  }
+
+  /** {@inheritDoc} */
+  public long get_ulonglong()
+                     throws TypeMismatch, InvalidValue
+  {
+    return focused().get_ulonglong();
+  }
+
+  /** {@inheritDoc} */
+  public short get_ushort()
+                   throws TypeMismatch, InvalidValue
+  {
+    return focused().get_ushort();
+  }
+
+  /** {@inheritDoc} */
+  public Serializable get_val()
+                       throws TypeMismatch, InvalidValue
+  {
+    if (pos >= 0 && pos < array.length)
+      {
+        if (array [ pos ] instanceof DynValueCommon)
+          return array [ pos ].get_val();
+        else
+          throw new TypeMismatch();
+      }
+    else
+      throw new InvalidValue("Out of bounds at " + pos + " valid 0.." +
+                             (array.length - 1)
+                            );
+  }
+
+  /** {@inheritDoc} */
+  public char get_wchar()
+                 throws TypeMismatch, InvalidValue
+  {
+    return focused().get_wchar();
+  }
+
+  /** {@inheritDoc} */
+  public String get_wstring()
+                     throws TypeMismatch, InvalidValue
+  {
+    return focused().get_wstring();
+  }
+
+  /** {@inheritDoc} */
+  public void insert_any(Any a_x)
+                  throws TypeMismatch, InvalidValue
+  {
+    focused().insert_any(a_x);
+    valueChanged();
+  }
+
+  /** {@inheritDoc} */
+  public void insert_boolean(boolean a_x)
+                      throws InvalidValue, TypeMismatch
+  {
+    focused().insert_boolean(a_x);
+    valueChanged();
+  }
+
+  /** {@inheritDoc} */
+  public void insert_char(char a_x)
+                   throws InvalidValue, TypeMismatch
+  {
+    focused().insert_char(a_x);
+    valueChanged();
+  }
+
+  /** {@inheritDoc} */
+  public void insert_double(double a_x)
+                     throws InvalidValue, TypeMismatch
+  {
+    focused().insert_double(a_x);
+    valueChanged();
+  }
+
+  /** {@inheritDoc} */
+  public void insert_float(float a_x)
+                    throws InvalidValue, TypeMismatch
+  {
+    focused().insert_float(a_x);
+    valueChanged();
+  }
+
+  /** {@inheritDoc} */
+  public void insert_long(int a_x)
+                   throws InvalidValue, TypeMismatch
+  {
+    focused().insert_long(a_x);
+    valueChanged();
+  }
+
+  /** {@inheritDoc} */
+  public void insert_longlong(long a_x)
+                       throws InvalidValue, TypeMismatch
+  {
+    focused().insert_longlong(a_x);
+    valueChanged();
+  }
+
+  /** {@inheritDoc} */
+  public void insert_octet(byte a_x)
+                    throws InvalidValue, TypeMismatch
+  {
+    focused().insert_octet(a_x);
+    valueChanged();
+  }
+
+  /** {@inheritDoc} */
+  public void insert_reference(Object a_x)
+                        throws InvalidValue, TypeMismatch
+  {
+    focused().insert_reference(a_x);
+    valueChanged();
+  }
+
+  /** {@inheritDoc} */
+  public void insert_short(short a_x)
+                    throws InvalidValue, TypeMismatch
+  {
+    focused().insert_short(a_x);
+    valueChanged();
+  }
+
+  /** {@inheritDoc} */
+  public void insert_string(String a_x)
+                     throws InvalidValue, TypeMismatch
+  {
+    focused().insert_string(a_x);
+    valueChanged();
+  }
+
+  /** {@inheritDoc} */
+  public void insert_typecode(TypeCode a_x)
+                       throws InvalidValue, TypeMismatch
+  {
+    focused().insert_typecode(a_x);
+    valueChanged();
+  }
+
+  /** {@inheritDoc} */
+  public void insert_ulong(int a_x)
+                    throws InvalidValue, TypeMismatch
+  {
+    focused().insert_ulong(a_x);
+    valueChanged();
+  }
+
+  /** {@inheritDoc} */
+  public void insert_ulonglong(long a_x)
+                        throws InvalidValue, TypeMismatch
+  {
+    focused().insert_ulonglong(a_x);
+    valueChanged();
+  }
+
+  /** {@inheritDoc} */
+  public void insert_ushort(short a_x)
+                     throws InvalidValue, TypeMismatch
+  {
+    focused().insert_ushort(a_x);
+    valueChanged();
+  }
+
+  /** {@inheritDoc} */
+  public void insert_val(Serializable a_x)
+                  throws InvalidValue, TypeMismatch
+  {
+    if (pos >= 0 && pos < array.length)
+      {
+        if (array [ pos ] instanceof DynValueCommon)
+          array [ pos ].insert_val(a_x);
+        else
+          throw new TypeMismatch();
+      }
+    else
+      throw new InvalidValue("Out of bounds at " + pos + " valid 0.." +
+                             (array.length - 1)
+                            );
+    valueChanged();
+  }
+
+  /** {@inheritDoc} */
+  public void insert_wchar(char a_x)
+                    throws InvalidValue, TypeMismatch
+  {
+    focused().insert_wchar(a_x);
+    valueChanged();
+  }
+
+  /** {@inheritDoc} */
+  public void insert_wstring(String a_x)
+                      throws InvalidValue, TypeMismatch
+  {
+    focused().insert_wstring(a_x);
+    valueChanged();
+  }
+
+  /** {@inheritDoc} */
+  public DynAny get_dyn_any()
+                     throws TypeMismatch, InvalidValue
+  {
+    return focused().get_dyn_any();
+  }
+
+  /** {@inheritDoc} */
+  public void insert_dyn_any(DynAny insert_it)
+                      throws TypeMismatch, InvalidValue
+  {
+    focused().insert_dyn_any(insert_it);
+  }
+
+  /**
+   * Get current component.
+   *
+   * @return current component or <code>null</code> if the pointer is out of
+   * bounds.
+   */
+  public DynAny current_component()
+                           throws TypeMismatch
+  {
+    if (array.length == 0)
+      throw new TypeMismatch("empty");
+    return (pos >= 0 && pos < array.length) ? array [ pos ] : null;
+  }
+
+  /**
+   * No action, cleanup is done by garbage collector in java.
+   */
+  public void destroy()
+  {
+  }
+
+  /**
+   * Involved in equal(DynAny).
+   */
+  public abstract Any to_any()
+                      throws TypeMismatch;
+
+  /**
+   * Compares with other DynAny for equality. The final_type, array size and
+   * array members must match.
+   */
+  public boolean equal(DynAny other)
+  {
+    try
+      {
+        if (!official_type.equal(other.type()))
+          return false;
+        else if (other instanceof DivideableAny)
+          {
+            DivideableAny x = (DivideableAny) other;
+            if (x.array.length != array.length)
+              return false;
+
+            for (int i = 0; i < array.length; i++)
+              {
+                if (!array [ i ].equal(x.array [ i ]))
+                  return false;
+              }
+            return true;
+          }
+        else if (other == null || other instanceof AbstractAny)
+          return false;
+        else
+          return other.to_any().equal(to_any());
+      }
+    catch (TypeMismatch e)
+      {
+        UNKNOWN u = new UNKNOWN(MINOR, CompletionStatus.COMPLETED_NO);
+        u.initCause(e);
+        throw u;
+      }
+  }
+}
diff --git a/libjava/classpath/gnu/CORBA/DynAn/NameValuePairHolder.java b/libjava/classpath/gnu/CORBA/DynAn/NameValuePairHolder.java
new file mode 100644
index 000000000..c3214e6ad
--- /dev/null
+++ b/libjava/classpath/gnu/CORBA/DynAn/NameValuePairHolder.java
@@ -0,0 +1,94 @@
+/* NameValuePairHolder.java --
+   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.DynAn;
+
+import org.omg.CORBA.NameValuePair;
+import org.omg.CORBA.NameValuePairHelper;
+import org.omg.CORBA.TypeCode;
+import org.omg.CORBA.portable.InputStream;
+import org.omg.CORBA.portable.OutputStream;
+import org.omg.CORBA.portable.Streamable;
+
+/**
+ * The name-value pair holder. The {@link NameValuePair} has no standard holder
+ * defined, but it is needed to store the {@link NameValuePair} into {@link Any}.
+ *
+ * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
+ */
+public class NameValuePairHolder
+  implements Streamable
+{
+  /**
+   * The stored value of the name value pair.
+   */
+  public NameValuePair value;
+
+  public NameValuePairHolder()
+  {
+  }
+
+  public NameValuePairHolder(NameValuePair a_value)
+  {
+    value = a_value;
+  }
+
+  /**
+   * Read the name value pair.
+   */
+  public void _read(InputStream input)
+  {
+    value = NameValuePairHelper.read(input);
+  }
+
+  /**
+   * Return the typecode of the name value pair.
+   */
+  public TypeCode _type()
+  {
+    return NameValuePairHelper.type();
+  }
+
+  /**
+   * Write the name value pair.
+   */
+  public void _write(OutputStream output)
+  {
+    NameValuePairHelper.write(output, value);
+  }
+}
diff --git a/libjava/classpath/gnu/CORBA/DynAn/RecordAny.java b/libjava/classpath/gnu/CORBA/DynAn/RecordAny.java
new file mode 100644
index 000000000..8badd2011
--- /dev/null
+++ b/libjava/classpath/gnu/CORBA/DynAn/RecordAny.java
@@ -0,0 +1,405 @@
+/* RecordAny.java --
+   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.DynAn;
+
+import gnu.CORBA.Unexpected;
+import gnu.CORBA.HolderLocator;
+
+import org.omg.CORBA.Any;
+import org.omg.CORBA.ORB;
+import org.omg.CORBA.TCKind;
+import org.omg.CORBA.TypeCode;
+import org.omg.CORBA.TypeCodePackage.BadKind;
+import org.omg.CORBA.TypeCodePackage.Bounds;
+import org.omg.CORBA.portable.Streamable;
+import org.omg.DynamicAny.DynAny;
+import org.omg.DynamicAny.DynAnyPackage.InvalidValue;
+import org.omg.DynamicAny.DynAnyPackage.TypeMismatch;
+import org.omg.DynamicAny.DynStruct;
+import org.omg.DynamicAny.DynValueCommonOperations;
+import org.omg.DynamicAny.NameDynAnyPair;
+import org.omg.DynamicAny.NameValuePair;
+
+import java.io.Serializable;
+
+import java.lang.reflect.Field;
+
+/**
+ * A shared base for both dynamic structure an dynamic value final_type.
+ *
+ * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
+ */
+public abstract class RecordAny
+  extends DivideableAny
+  implements DynAny, Serializable
+{
+  /**
+   * Use serialVersionUID for interoperability.
+   */
+  private static final long serialVersionUID = 1;
+  String[] fNames;
+
+  /**
+   * Creates the structure with the given typecode.
+   *
+   * @param fields The DynAny's, representing the fields of the structure.
+   */
+  public RecordAny(TypeCode oType, TypeCode aType,
+                        gnuDynAnyFactory aFactory, ORB anOrb
+                       )
+  {
+    super(oType, aType, aFactory, anOrb);
+  }
+
+  /** @inheritDoc */
+  public TCKind current_member_kind()
+                             throws TypeMismatch, InvalidValue
+  {
+    if (array.length == 0)
+      throw new TypeMismatch(EMPTY);
+    try
+      {
+        return final_type.member_type(pos).kind();
+      }
+    catch (BadKind e)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(e);
+        throw t;
+      }
+    catch (Bounds e)
+      {
+        InvalidValue t = new InvalidValue();
+        t.initCause(e);
+        throw t;
+      }
+  }
+
+  /** @inheritDoc */
+  public String current_member_name()
+                             throws TypeMismatch, InvalidValue
+  {
+    if (array.length == 0)
+      throw new TypeMismatch(EMPTY);
+    try
+      {
+        return final_type.member_name(pos);
+      }
+    catch (BadKind e)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(e);
+        throw t;
+      }
+    catch (Bounds e)
+      {
+        InvalidValue t = new InvalidValue();
+        t.initCause(e);
+        throw t;
+      }
+  }
+
+  /**
+   * Get content of the structure. This method must be defined on a different
+   * name because get_members_as_dyn_any() throws exception only in some of the
+   * supported interfaces.
+   */
+  public NameDynAnyPair[] gnu_get_members_as_dyn_any()
+  {
+    NameDynAnyPair[] r = new NameDynAnyPair[ array.length ];
+    for (int i = 0; i < r.length; i++)
+      {
+        try
+          {
+            r [ i ] = new NameDynAnyPair(fNames [ i ], array [ i ]);
+          }
+        catch (Exception ex)
+          {
+            throw new Unexpected(ex);
+          }
+      }
+    return r;
+  }
+
+  /**
+   * Get content of the structure. This method must be defined on a different
+   * name because get_members_as_dyn_any() throws exception only in some of the
+   * supported interfaces.
+   */
+  public NameValuePair[] gnu_get_members()
+  {
+    NameValuePair[] r = new NameValuePair[ array.length ];
+    for (int i = 0; i < r.length; i++)
+      {
+        try
+          {
+            r [ i ] = new NameValuePair(fNames [ i ], array [ i ].to_any());
+          }
+        catch (Exception ex)
+          {
+            throw new Unexpected(ex);
+          }
+      }
+    return r;
+  }
+
+  /**
+   * Set members from the provided array.
+   */
+  public void set_members_as_dyn_any(NameDynAnyPair[] value)
+                              throws TypeMismatch, InvalidValue
+  {
+    if (value.length != array.length)
+      throw new InvalidValue(sizeMismatch(array.length, value.length));
+
+    for (int i = 0; i < value.length; i++)
+      {
+        DynAny dynAny = value [ i ].value;
+        checkType(dynAny.type(), i);
+        checkName(value [ i ].id, i);
+
+        array [ i ] = dynAny;
+      }
+    pos = 0;
+  }
+
+  /**
+   * Check the name at the given position ("" matches everything).
+   */
+  private void checkName(String xName, int i)
+                  throws TypeMismatch
+  {
+    if (xName.length() > 0 && fNames [ i ].length() > 0)
+      if (!xName.equals(fNames [ i ]))
+        throw new TypeMismatch("Field name mismatch " + xName + " expected " +
+                               fNames [ i ]
+                              );
+  }
+
+  /**
+   * Check the type at the given position.
+   */
+  private void checkType(TypeCode t, int i)
+                  throws TypeMismatch
+  {
+    if (!array [ i ].type().equal(t))
+      throw new TypeMismatch(typeMismatch(array [ i ].type(), t) + " field " +
+                             i
+                            );
+  }
+
+  /**
+   * Set members from the provided array.
+   */
+  public void set_members(NameValuePair[] value)
+                   throws TypeMismatch, InvalidValue
+  {
+    if (value.length != array.length)
+      throw new InvalidValue(sizeMismatch(array.length, value.length));
+
+    for (int i = 0; i < value.length; i++)
+      {
+        Any any = value [ i ].value;
+        checkType(any.type(), i);
+        checkName(value [ i ].id, i);
+
+        array [ i ].from_any(any);
+      }
+    pos = 0;
+  }
+
+  /** @inheritDoc */
+  public void assign(DynAny from)
+              throws TypeMismatch
+  {
+    checkType(official_type, from.type());
+    if (from instanceof DynStruct)
+      {
+        try
+          {
+            set_members_as_dyn_any(((DynStruct) from).get_members_as_dyn_any());
+          }
+        catch (InvalidValue e)
+          {
+            TypeMismatch t = new TypeMismatch("Invalid value");
+            t.initCause(e);
+            throw t;
+          }
+      }
+    else
+      throw new TypeMismatch("Not a DynStruct");
+  }
+
+  /**
+   * Create a copy.
+   */
+  public DynAny copy()
+  {
+    DynAny[] c = new DynAny[ array.length ];
+    for (int i = 0; i < c.length; i++)
+      {
+        c [ i ] = array [ i ].copy();
+      }
+
+    RecordAny d = newInstance(official_type, final_type, factory, orb);
+    d.array = c;
+    return d;
+  }
+
+  /**
+   * Create a new instance when copying.
+   */
+  protected abstract RecordAny newInstance(TypeCode oType, TypeCode aType,
+                                                gnuDynAnyFactory aFactory,
+                                                ORB anOrb
+                                               );
+
+  /**
+   * Done via reflection.
+   */
+  public Any to_any()
+  {
+    try
+      {
+        Streamable sHolder = HolderLocator.createHolder(official_type);
+
+        Class sHolderClass = sHolder.getClass();
+        Field sHolderValue = sHolderClass.getField("value");
+        Class sClass = sHolderValue.getType();
+
+        Object structure = sClass.newInstance();
+        Object member;
+        Any am;
+        Field vread;
+        Field vwrite;
+        Streamable memberHolder;
+
+        for (int i = 0; i < array.length; i++)
+          {
+            am = array [ i ].to_any();
+            memberHolder = am.extract_Streamable();
+            vwrite = structure.getClass().getField(final_type.member_name(i));
+            vread = memberHolder.getClass().getField("value");
+            member = vread.get(memberHolder);
+            vwrite.set(structure, member);
+          }
+
+        Any g = createAny();
+        sHolderValue.set(sHolder, structure);
+        g.insert_Streamable(sHolder);
+        g.type(official_type);
+        return g;
+      }
+    catch (Exception e)
+      {
+        throw new Unexpected(e);
+      }
+  }
+
+  /**
+   * Done via reflection.
+   */
+  public void from_any(Any an_any)
+                throws TypeMismatch, InvalidValue
+  {
+    checkType(official_type, an_any.type());
+    try
+      {
+        Streamable s = an_any.extract_Streamable();
+        if (s == null)
+          {
+            if (this instanceof DynValueCommonOperations)
+              {
+                ((DynValueCommonOperations) this).set_to_null();
+                return;
+              }
+            else
+              throw new InvalidValue(ISNULL);
+          }
+
+        Object structure = s.getClass().getField("value").get(s);
+        if (structure == null && (this instanceof DynValueCommonOperations))
+          {
+            ((DynValueCommonOperations) this).set_to_null();
+            return;
+          }
+
+        Any member;
+        Streamable holder;
+        Object field;
+        TypeCode fType;
+        Field fField;
+
+        for (int i = 0; i < array.length; i++)
+          {
+            fField = structure.getClass().getField(fNames [ i ]);
+            field = fField.get(structure);
+            fType = array [ i ].type();
+            holder = HolderLocator.createHolder(fType);
+
+            member = createAny();
+            holder.getClass().getField("value").set(holder, field);
+            member.insert_Streamable(holder);
+            member.type(fType);
+
+            array [ i ].from_any(member);
+          }
+
+        if (this instanceof DynValueCommonOperations)
+          ((DynValueCommonOperations) this).set_to_value();
+      }
+    catch (InvalidValue v)
+      {
+        throw v;
+      }
+    catch (NoSuchFieldException ex)
+      {
+        TypeMismatch v =
+          new TypeMismatch("holder value does not match typecode");
+        v.initCause(ex);
+        throw v;
+      }
+    catch (Exception ex)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(ex);
+        throw t;
+      }
+  }
+}
diff --git a/libjava/classpath/gnu/CORBA/DynAn/UndivideableAny.java b/libjava/classpath/gnu/CORBA/DynAn/UndivideableAny.java
new file mode 100644
index 000000000..da4e9618e
--- /dev/null
+++ b/libjava/classpath/gnu/CORBA/DynAn/UndivideableAny.java
@@ -0,0 +1,493 @@
+/* Undivideable.java --
+   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.DynAn;
+
+import java.io.Serializable;
+
+import org.omg.CORBA.Any;
+import org.omg.CORBA.ORB;
+import org.omg.CORBA.Object;
+import org.omg.CORBA.TypeCode;
+import org.omg.DynamicAny.DynAny;
+import org.omg.DynamicAny.DynAnyPackage.InvalidValue;
+import org.omg.DynamicAny.DynAnyPackage.TypeMismatch;
+
+/**
+ * Represent DynAny that has no internal components (DynEnum and so on). The
+ * methods, related to internal components, throw exceptions or return agreed
+ * values like null.
+ *
+ * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
+ */
+public abstract class UndivideableAny
+  extends AbstractAny
+  implements Serializable
+{
+  /**
+   * Use serialVersionUID for interoperability.
+   */
+  private static final long serialVersionUID = 1;
+
+  /**
+   * Create a new instance with the given typecode.
+   */
+  public UndivideableAny(TypeCode oType, TypeCode aType,
+                         gnuDynAnyFactory aFactory, ORB anOrb)
+  {
+    super(oType, aType, aFactory, anOrb);
+  }
+
+  /**
+   * There are no components.
+   *
+   * @return 0, always.
+   */
+  public int component_count()
+  {
+    return 0;
+  }
+
+  /**
+   * There is no current component.
+   *
+   * @throws TypeMismatch, always.
+   */
+  public DynAny current_component()
+    throws TypeMismatch
+  {
+    throw new TypeMismatch("Not applicable");
+  }
+
+  /**
+   * Returns without action.
+   */
+  public void destroy()
+  {
+  }
+
+  /**
+   * Not in use.
+   */
+  public Any get_any()
+    throws TypeMismatch, InvalidValue
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public boolean get_boolean()
+    throws TypeMismatch, InvalidValue
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public char get_char()
+    throws TypeMismatch, InvalidValue
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public double get_double()
+    throws TypeMismatch, InvalidValue
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public DynAny get_dyn_any()
+    throws TypeMismatch, InvalidValue
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public float get_float()
+    throws TypeMismatch, InvalidValue
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public int get_long()
+    throws TypeMismatch, InvalidValue
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public long get_longlong()
+    throws TypeMismatch, InvalidValue
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public byte get_octet()
+    throws TypeMismatch, InvalidValue
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public Object get_reference()
+    throws TypeMismatch, InvalidValue
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public short get_short()
+    throws TypeMismatch, InvalidValue
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public String get_string()
+    throws TypeMismatch, InvalidValue
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public TypeCode get_typecode()
+    throws TypeMismatch, InvalidValue
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public int get_ulong()
+    throws TypeMismatch, InvalidValue
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public long get_ulonglong()
+    throws TypeMismatch, InvalidValue
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public short get_ushort()
+    throws TypeMismatch, InvalidValue
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public Serializable get_val()
+    throws TypeMismatch, InvalidValue
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public char get_wchar()
+    throws TypeMismatch, InvalidValue
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public String get_wstring()
+    throws TypeMismatch, InvalidValue
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public void insert_any(Any an_any)
+    throws TypeMismatch, InvalidValue
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public void insert_boolean(boolean a_x)
+    throws InvalidValue, TypeMismatch
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public void insert_char(char a_x)
+    throws InvalidValue, TypeMismatch
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public void insert_double(double a_x)
+    throws InvalidValue, TypeMismatch
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public void insert_dyn_any(DynAny insert_it)
+    throws TypeMismatch, InvalidValue
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public void insert_float(float a_x)
+    throws InvalidValue, TypeMismatch
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public void insert_long(int a_x)
+    throws InvalidValue, TypeMismatch
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public void insert_longlong(long a_x)
+    throws InvalidValue, TypeMismatch
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public void insert_octet(byte a_x)
+    throws InvalidValue, TypeMismatch
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public void insert_reference(Object a_x)
+    throws InvalidValue, TypeMismatch
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public void insert_short(short a_x)
+    throws InvalidValue, TypeMismatch
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public void insert_string(String a_x)
+    throws InvalidValue, TypeMismatch
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public void insert_typecode(TypeCode a_x)
+    throws InvalidValue, TypeMismatch
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public void insert_ulong(int a_x)
+    throws InvalidValue, TypeMismatch
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public void insert_ulonglong(long a_x)
+    throws InvalidValue, TypeMismatch
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public void insert_ushort(short a_x)
+    throws InvalidValue, TypeMismatch
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public void insert_val(Serializable a_x)
+    throws InvalidValue, TypeMismatch
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public void insert_wchar(char a_x)
+    throws InvalidValue, TypeMismatch
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public void insert_wstring(String a_x)
+    throws InvalidValue, TypeMismatch
+  {
+    throw new TypeMismatch();
+  }
+
+  /**
+   * Not in use.
+   */
+  public boolean next()
+  {
+    return false;
+  }
+
+  /**
+   * Not in use.
+   */
+  public void rewind()
+  {
+  }
+
+  /**
+   * Not in use.
+   */
+  public boolean seek(int p)
+  {
+    return false;
+  }
+
+  /**
+   * Get the typecode of this enumeration.
+   */
+  public TypeCode type()
+  {
+    return official_type;
+  }
+
+  /**
+   * Compares with other DynAny for equality.
+   */
+  public boolean equals(java.lang.Object other)
+  {
+    if (other instanceof DynAny)
+      return equal((DynAny) other);
+    else
+      return false;
+  }
+
+  /**
+   * This depends on an object.
+   */
+  public abstract boolean equal(DynAny other);
+
+}
diff --git a/libjava/classpath/gnu/CORBA/DynAn/ValueChangeListener.java b/libjava/classpath/gnu/CORBA/DynAn/ValueChangeListener.java
new file mode 100644
index 000000000..4c3a456d2
--- /dev/null
+++ b/libjava/classpath/gnu/CORBA/DynAn/ValueChangeListener.java
@@ -0,0 +1,50 @@
+/* ValueChangeListener.java --
+   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.DynAn;
+
+/**
+ * An interface, able to receive notification about the change of value
+ * of some DynAny.
+ *
+ * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
+ */
+public interface ValueChangeListener
+{
+  void changed();
+}
diff --git a/libjava/classpath/gnu/CORBA/DynAn/gnuDynAny.java b/libjava/classpath/gnu/CORBA/DynAn/gnuDynAny.java
new file mode 100644
index 000000000..314426c82
--- /dev/null
+++ b/libjava/classpath/gnu/CORBA/DynAn/gnuDynAny.java
@@ -0,0 +1,945 @@
+/* gnuDynAny.java --
+   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.DynAn;
+
+import gnu.CORBA.CDR.BufferedCdrOutput;
+import gnu.CORBA.OctetHolder;
+import gnu.CORBA.Unexpected;
+import gnu.CORBA.WCharHolder;
+import gnu.CORBA.WStringHolder;
+import gnu.CORBA.HolderLocator;
+import gnu.CORBA.TypeKindNamer;
+import gnu.CORBA.GeneralHolder;
+
+import org.omg.CORBA.Any;
+import org.omg.CORBA.AnyHolder;
+import org.omg.CORBA.BooleanHolder;
+import org.omg.CORBA.CharHolder;
+import org.omg.CORBA.DoubleHolder;
+import org.omg.CORBA.FloatHolder;
+import org.omg.CORBA.IntHolder;
+import org.omg.CORBA.LongHolder;
+import org.omg.CORBA.MARSHAL;
+import org.omg.CORBA.ORB;
+import org.omg.CORBA.Object;
+import org.omg.CORBA.ObjectHolder;
+import org.omg.CORBA.ShortHolder;
+import org.omg.CORBA.StringHolder;
+import org.omg.CORBA.TCKind;
+import org.omg.CORBA.TypeCode;
+import org.omg.CORBA.TypeCodeHolder;
+import org.omg.CORBA.TypeCodePackage.BadKind;
+import org.omg.CORBA.ValueBaseHolder;
+import org.omg.CORBA.portable.InputStream;
+import org.omg.CORBA.portable.OutputStream;
+import org.omg.CORBA.portable.Streamable;
+import org.omg.DynamicAny.DynAny;
+import org.omg.DynamicAny.DynAnyPackage.InvalidValue;
+import org.omg.DynamicAny.DynAnyPackage.TypeMismatch;
+
+import java.io.IOException;
+import java.io.Serializable;
+
+import java.util.Arrays;
+
+/**
+ * The primitive dynamic Any holds the value basic final_type that cannot be
+ * traversed.
+ *
+ * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
+ */
+public class gnuDynAny extends AbstractAny implements DynAny, Serializable
+{
+  /**
+   * Use serialVersionUID for interoperability.
+   */
+  private static final long serialVersionUID = 1;
+
+  /**
+   * The enclosed Streamable, holding the actual value.
+   */
+  protected Streamable holder;
+
+  /**
+   * Create DynAny providing the holder.
+   *
+   * @param a_holder
+   */
+  public gnuDynAny(Streamable aHolder, TypeCode oType, TypeCode aType,
+    gnuDynAnyFactory aFactory, ORB anOrb
+  )
+  {
+    super(oType, aType, aFactory, anOrb);
+    holder = aHolder;
+  }
+
+  /**
+   * Assign the contents of the given {@link DynAny} to this DynAny.
+   *
+   * @param from the source to assign from.
+   */
+  public void assign(DynAny from) throws TypeMismatch
+  {
+    checkType(official_type, from.type());
+
+    if (from instanceof gnuDynAny)
+      holder = ((gnuDynAny) from).holder;
+    else
+      holder = from.to_any().extract_Streamable();
+    valueChanged();
+  }
+
+  /**
+   * Create a copy of this {@link DynAny} via buffer read/write.
+   */
+  public DynAny copy()
+  {
+    if (holder != null)
+      {
+        BufferedCdrOutput buffer = new BufferedCdrOutput();
+        holder._write(buffer);
+
+        gnuDynAny other;
+        try
+          {
+            other =
+              new gnuDynAny((Streamable) (holder.getClass().newInstance()),
+                official_type, final_type, factory, orb
+              );
+          }
+        catch (Exception e)
+          {
+            // Holder must have parameterless constructor.
+            throw new Unexpected(e);
+          }
+        other.holder._read(buffer.create_input_stream());
+        return other;
+      }
+    else
+      {
+        return new gnuDynAny(null, official_type, final_type, factory, orb);
+      }
+  }
+
+  /**
+   * Always returns <code>null</code>.
+   *
+   * @return <code>null</code>, always.
+   */
+  public DynAny current_component() throws TypeMismatch
+  {
+    throw new TypeMismatch("Not applicable for " +
+      TypeKindNamer.nameIt(final_type)
+    );
+  }
+
+  /**
+   * Returns without action, leaving all work to the garbage collector.
+   */
+  public void destroy()
+  {
+  }
+
+  /**
+   * Takes the passed parameter as the enclosed {@link Any} reference.
+   *
+   * @param an_any the {@link Any} that will be used as an enclosed reference.
+   *
+   * @throws TypeMismatch if the final_type of the passed Any is not the same as
+   * the final_type, currently stored in this Any.
+   */
+  public void from_any(Any an_any) throws TypeMismatch, InvalidValue
+  {
+    checkType(official_type, an_any.type());
+
+    Streamable a_holder = an_any.extract_Streamable();
+    if (a_holder == null)
+      {
+        throw new InvalidValue(ISNULL);
+      }
+    else if (a_holder instanceof GeneralHolder)
+      {
+        holder = HolderLocator.createHolder(official_type);
+        if (holder == null)
+          holder = HolderLocator.createHolder(final_type);
+
+        if (holder == null)
+          holder = ((GeneralHolder) a_holder).Clone();
+        else
+          {
+            InputStream in = an_any.create_input_stream();
+            holder._read(in);
+            try
+              {
+                in.close();
+              }
+            catch (IOException ex)
+              {
+                throw new Unexpected(ex);
+              }
+          }
+      }
+    else
+      {
+        try
+          {
+            InputStream in = an_any.create_input_stream();
+            holder = (Streamable) a_holder.getClass().newInstance();
+            holder._read(in);
+            in.close();
+          }
+        catch (Exception ex)
+          {
+            TypeMismatch t = new TypeMismatch();
+            t.initCause(ex);
+            throw t;
+          }
+      }
+    valueChanged();
+  }
+
+  /**
+   * Return the second (enclosed any) that is stored in the wrapped Any.
+   */
+  public Any get_any() throws TypeMismatch
+  {
+    try
+      {
+        return ((AnyHolder) holder).value;
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch m = new TypeMismatch();
+        m.initCause(cex);
+        throw m;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public boolean get_boolean() throws TypeMismatch
+  {
+    try
+      {
+        return ((BooleanHolder) holder).value;
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch m = new TypeMismatch();
+        m.initCause(cex);
+        throw m;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public char get_char() throws TypeMismatch
+  {
+    try
+      {
+        return ((CharHolder) holder).value;
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch m = new TypeMismatch();
+        m.initCause(cex);
+        throw m;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public double get_double() throws TypeMismatch
+  {
+    try
+      {
+        return ((DoubleHolder) holder).value;
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch m = new TypeMismatch();
+        m.initCause(cex);
+        throw m;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public float get_float() throws TypeMismatch
+  {
+    try
+      {
+        return ((FloatHolder) holder).value;
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch m = new TypeMismatch();
+        m.initCause(cex);
+        throw m;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public int get_long() throws TypeMismatch
+  {
+    try
+      {
+        return ((IntHolder) holder).value;
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch m = new TypeMismatch();
+        m.initCause(cex);
+        throw m;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public long get_longlong() throws TypeMismatch
+  {
+    try
+      {
+        return ((LongHolder) holder).value;
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch m = new TypeMismatch();
+        m.initCause(cex);
+        throw m;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public byte get_octet() throws TypeMismatch
+  {
+    try
+      {
+        return ((OctetHolder) holder).value;
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch m = new TypeMismatch();
+        m.initCause(cex);
+        throw m;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public Object get_reference() throws TypeMismatch
+  {
+    try
+      {
+        return ((ObjectHolder) holder).value;
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch m = new TypeMismatch();
+        m.initCause(cex);
+        throw m;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public short get_short() throws TypeMismatch
+  {
+    try
+      {
+        return ((ShortHolder) holder).value;
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch m = new TypeMismatch();
+        m.initCause(cex);
+        throw m;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public String get_string() throws TypeMismatch
+  {
+    try
+      {
+        return ((StringHolder) holder).value;
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch m = new TypeMismatch();
+        m.initCause(cex);
+        throw m;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public TypeCode get_typecode() throws TypeMismatch
+  {
+    try
+      {
+        return ((TypeCodeHolder) holder).value;
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch m = new TypeMismatch();
+        m.initCause(cex);
+        throw m;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public int get_ulong() throws TypeMismatch
+  {
+    check(TCKind.tk_ulong);
+    return get_long();
+  }
+
+  /** {@inheritDoc} */
+  public long get_ulonglong() throws TypeMismatch
+  {
+    check(TCKind.tk_ulonglong);
+    return get_longlong();
+  }
+
+  /** {@inheritDoc} */
+  public short get_ushort() throws TypeMismatch
+  {
+    check(TCKind.tk_ushort);
+    return get_short();
+  }
+
+  /** {@inheritDoc} */
+  public Serializable get_val() throws TypeMismatch
+  {
+    try
+      {
+        return ((ValueBaseHolder) holder).value;
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch m = new TypeMismatch();
+        m.initCause(cex);
+        throw m;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public char get_wchar() throws TypeMismatch
+  {
+    try
+      {
+        return ((WCharHolder) holder).value;
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch m = new TypeMismatch();
+        m.initCause(cex);
+        throw m;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public String get_wstring() throws TypeMismatch
+  {
+    try
+      {
+        return ((WStringHolder) holder).value;
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch m = new TypeMismatch();
+        m.initCause(cex);
+        throw m;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public void insert_any(Any a_x) throws TypeMismatch, InvalidValue
+  {
+    try
+      {
+        if (a_x.type().kind().value() == TCKind._tk_null)
+          ((AnyHolder) holder).value = a_x;
+        else
+          {
+            OutputStream buf = a_x.create_output_stream();
+            buf.write_any(a_x);
+            holder._read(buf.create_input_stream());
+            buf.close();
+          }
+        valueChanged();
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(cex);
+        throw t;
+      }
+    catch (MARSHAL m)
+      {
+        InvalidValue v = new InvalidValue();
+        v.initCause(m);
+        throw v;
+      }
+    catch (IOException ex)
+      {
+        throw new Unexpected(ex);
+      }
+  }
+
+  /** {@inheritDoc} */
+  public void insert_boolean(boolean a_x) throws InvalidValue, TypeMismatch
+  {
+    try
+      {
+        ((BooleanHolder) holder).value = a_x;
+        valueChanged();
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(cex);
+        throw t;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public void insert_char(char a_x) throws InvalidValue, TypeMismatch
+  {
+    try
+      {
+        ((CharHolder) holder).value = a_x;
+        valueChanged();
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(cex);
+        throw t;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public void insert_double(double a_x) throws InvalidValue, TypeMismatch
+  {
+    try
+      {
+        ((DoubleHolder) holder).value = a_x;
+        valueChanged();
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(cex);
+        throw t;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public void insert_float(float a_x) throws InvalidValue, TypeMismatch
+  {
+    try
+      {
+        ((FloatHolder) holder).value = a_x;
+        valueChanged();
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(cex);
+        throw t;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public void insert_long(int a_x) throws InvalidValue, TypeMismatch
+  {
+    try
+      {
+        ((IntHolder) holder).value = a_x;
+        valueChanged();
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(cex);
+        throw t;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public void insert_longlong(long a_x) throws InvalidValue, TypeMismatch
+  {
+    try
+      {
+        ((LongHolder) holder).value = a_x;
+        valueChanged();
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(cex);
+        throw t;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public void insert_octet(byte a_x) throws InvalidValue, TypeMismatch
+  {
+    try
+      {
+        ((OctetHolder) holder).value = a_x;
+        valueChanged();
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(cex);
+        throw t;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public void insert_reference(Object a_x) throws InvalidValue, TypeMismatch
+  {
+    try
+      {
+        ((ObjectHolder) holder).value = a_x;
+        valueChanged();
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(cex);
+        throw t;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public void insert_short(short a_x) throws InvalidValue, TypeMismatch
+  {
+    try
+      {
+        ((ShortHolder) holder).value = a_x;
+        valueChanged();
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(cex);
+        throw t;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public void insert_string(String a_x) throws InvalidValue, TypeMismatch
+  {
+    try
+      {
+        if (a_x != null &&
+          final_type.length() > 0 &&
+          a_x.length() > final_type.length()
+        )
+          throw new InvalidValue(a_x.length() + " exceeds bound, " +
+            final_type.length()
+          );
+        ((StringHolder) holder).value = a_x;
+        valueChanged();
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(cex);
+        throw t;
+      }
+    catch (BadKind e)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(e);
+        throw t;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public void insert_typecode(TypeCode a_x) throws InvalidValue, TypeMismatch
+  {
+    try
+      {
+        ((TypeCodeHolder) holder).value = a_x;
+        valueChanged();
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(cex);
+        throw t;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public void insert_ulong(int a_x) throws InvalidValue, TypeMismatch
+  {
+    try
+      {
+        ((IntHolder) holder).value = a_x;
+        valueChanged();
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(cex);
+        throw t;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public void insert_ulonglong(long a_x) throws InvalidValue, TypeMismatch
+  {
+    try
+      {
+        ((LongHolder) holder).value = a_x;
+        valueChanged();
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(cex);
+        throw t;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public void insert_ushort(short a_x) throws InvalidValue, TypeMismatch
+  {
+    try
+      {
+        ((ShortHolder) holder).value = a_x;
+        valueChanged();
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(cex);
+        throw t;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public void insert_val(Serializable a_x) throws InvalidValue, TypeMismatch
+  {
+    try
+      {
+        ((ValueBaseHolder) holder).value = a_x;
+        valueChanged();
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(cex);
+        throw t;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public void insert_wchar(char a_x) throws InvalidValue, TypeMismatch
+  {
+    try
+      {
+        ((WCharHolder) holder).value = a_x;
+        valueChanged();
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(cex);
+        throw t;
+      }
+  }
+
+  /** {@inheritDoc} */
+  public void insert_wstring(String a_x) throws InvalidValue, TypeMismatch
+  {
+    try
+      {
+        if (a_x != null &&
+          final_type.length() > 0 &&
+          a_x.length() > type().length()
+        )
+          throw new InvalidValue(a_x.length() + " exceeds bound, " +
+            final_type.length()
+          );
+        ((WStringHolder) holder).value = a_x;
+        valueChanged();
+      }
+    catch (ClassCastException cex)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(cex);
+        throw t;
+      }
+    catch (BadKind e)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(e);
+        throw t;
+      }
+  }
+
+  /**
+   * The objects, enclosed inside this class, have only one component (self).
+   *
+   * @return false, always (no other action).
+   */
+  public boolean next()
+  {
+    return false;
+  }
+
+  /**
+   * Returns without action.
+   */
+  public void rewind()
+  {
+  }
+
+  /**
+   * This objects, stored in this wrapper, never have multiple internal
+   * components to seek.
+   *
+   * @return false, always (no other action).
+   */
+  public boolean seek(int p)
+  {
+    return false;
+  }
+
+  /**
+   * Returns the enclosed {@link Any}.
+   *
+   * @return the enclosed {@link Any}.
+   */
+  public Any to_any()
+  {
+    Any a = createAny();
+    a.insert_Streamable(holder);
+    a.type(official_type);
+    return a;
+  }
+
+  /** {@inheritDoc} */
+  public TypeCode type()
+  {
+    return official_type;
+  }
+
+  /**
+   * Compute hashcode in a trivial way.
+   */
+  protected int getHashCodeSimple(int maximum)
+  {
+    int h = super.hashCode() / 2;
+    if (h < 0)
+      h = -h;
+    return h % maximum;
+  }
+
+  /**
+   * Inserts Any, contained in the parameter, into Any, contained in this
+   * DynAny.
+   */
+  public void insert_dyn_any(DynAny d) throws TypeMismatch, InvalidValue
+  {
+    check(d.type().kind());
+
+    Any a = d.to_any();
+    holder = a.extract_Streamable();
+    valueChanged();
+  }
+
+  /**
+   * Checks for equality. The DynAnys are equal if the stored Anys are equal.
+   */
+  public boolean equal(DynAny other)
+  {
+    if (other instanceof AbstractAny)
+      {
+        if (other instanceof gnuDynAny)
+          {
+            gnuDynAny x = (gnuDynAny) other;
+
+            if (!x.holder.getClass().equals(holder.getClass()))
+              return false;
+
+            BufferedCdrOutput b1 = new BufferedCdrOutput();
+            x.holder._write(b1);
+
+            BufferedCdrOutput b2 = new BufferedCdrOutput(b1.buffer.size() + 10);
+            holder._write(b2);
+
+            return Arrays.equals(b1.buffer.toByteArray(),
+              b2.buffer.toByteArray()
+            );
+          }
+        else
+          return false;
+      }
+    if (other == null)
+      return false;
+    else if (other.component_count() != component_count() ||
+      !official_type.equal(other.type())
+    )
+      return false;
+    else
+      return other.to_any().equal(to_any());
+  }
+
+  /**
+   * This final_type has no components.
+   *
+   * @return 0, always.
+   */
+  public int component_count()
+  {
+    return 0;
+  }
+
+  public DynAny get_dyn_any() throws TypeMismatch, InvalidValue
+  {
+    return new gnuDynAny(holder, official_type, final_type, factory, orb);
+  }
+
+  private void check(TCKind t) throws TypeMismatch
+  {
+    if (t.value() != final_type.kind().value())
+      throw new TypeMismatch(t.value() + "!=" + final_type.kind().value());
+  }
+}
diff --git a/libjava/classpath/gnu/CORBA/DynAn/gnuDynAnyFactory.java b/libjava/classpath/gnu/CORBA/DynAn/gnuDynAnyFactory.java
new file mode 100644
index 000000000..b42e63213
--- /dev/null
+++ b/libjava/classpath/gnu/CORBA/DynAn/gnuDynAnyFactory.java
@@ -0,0 +1,356 @@
+/* gnuDynAnyFactory.java --
+   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.DynAn;
+
+import gnu.CORBA.Poa.ORB_1_4;
+import gnu.CORBA.Unexpected;
+import gnu.CORBA.HolderLocator;
+import gnu.CORBA.TypeKindNamer;
+
+import org.omg.CORBA.Any;
+import org.omg.CORBA.LocalObject;
+import org.omg.CORBA.TCKind;
+import org.omg.CORBA.TypeCode;
+import org.omg.CORBA.TypeCodePackage.BadKind;
+import org.omg.CORBA.UserException;
+import org.omg.CORBA.portable.Streamable;
+import org.omg.DynamicAny.DynAny;
+import org.omg.DynamicAny.DynAnyFactory;
+import org.omg.DynamicAny.DynAnyFactoryPackage.InconsistentTypeCode;
+import org.omg.DynamicAny.DynArray;
+import org.omg.DynamicAny.DynEnum;
+import org.omg.DynamicAny.DynFixed;
+import org.omg.DynamicAny.DynSequence;
+import org.omg.DynamicAny.DynStruct;
+import org.omg.DynamicAny.DynUnion;
+import org.omg.DynamicAny.DynValue;
+import org.omg.DynamicAny.DynValueBox;
+
+/**
+ * This class is returned by ORB when resolving
+ * initial reference "DynAnyFactory".
+ *
+ * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
+ */
+public class gnuDynAnyFactory
+  extends LocalObject
+  implements DynAnyFactory
+{
+  /**
+   * Use serialVersionUID for interoperability.
+   */
+  private static final long serialVersionUID = 1;
+
+  /**
+   * The ORB, to that the factory belongs.
+   */
+  final ORB_1_4 orb;
+
+  /**
+   * Create a new factory, specifying the ORB to that the factory belongs.
+   *
+   * @param anOrb
+   */
+  public gnuDynAnyFactory(ORB_1_4 anOrb)
+  {
+    orb = anOrb;
+  }
+
+  /**
+   * Get the orb.
+   */
+  public ORB_1_4 getOrb()
+  {
+    return orb;
+  }
+
+  /**
+   * Create an initialised array.
+   */
+  public DynArray create_array(TypeCode official, TypeCode type)
+  {
+    return new gnuDynArray(official, type, this, orb, true);
+  }
+
+  /**
+   * Create an empty sequence.
+   */
+  public DynSequence create_sequence(TypeCode official, TypeCode type)
+  {
+    return new gnuDynSequence(official, type, this, orb);
+  }
+
+  /**
+   * Create structure.
+   *
+   * @param official the type that was originally passed as a parameter by user.
+   * May be alias of some other type.
+   * @param type the type into that the "official type" evaluates during alias
+   * resolving. Initially equal to "official type".
+   */
+  public DynStruct create_structure(TypeCode official, TypeCode type)
+  {
+    return new gnuDynStruct(official, type, this, orb);
+  }
+
+  /**
+   * Create union.
+   *
+   * @param official the type that was originally passed as a parameter by user.
+   * May be alias of some other type.
+   * @param type the type into that the "official type" evaluates during alias
+   * resolving. Initially equal to "official type".
+   */
+  public DynUnion create_union(TypeCode official, TypeCode type)
+  {
+    try
+      {
+        return new gnuDynUnion(official, type, this, orb);
+      }
+    catch (Exception ex)
+      {
+        throw new Unexpected(ex);
+      }
+  }
+
+  /**
+   * Create value.
+   *
+   * @param official the type that was originally passed as a parameter by user.
+   * May be alias of some other type.
+   * @param type the type into that the "official type" evaluates during alias
+   * resolving. Initially equal to "official type".
+   */
+  public DynValue create_value(TypeCode official, TypeCode type)
+  {
+    return new gnuDynValue(official, type, this, orb);
+  }
+
+  /**
+   * Create value box.
+   *
+   * @param official the type that was originally passed as a parameter by user.
+   * May be alias of some other type.
+   * @param type the type into that the "official type" evaluates during alias
+   * resolving. Initially equal to "official type".
+   */
+  public DynValueBox create_value_box(TypeCode official, TypeCode type)
+  {
+    return new gnuDynValueBox(official, type, this, orb);
+  }
+
+  /**
+   * Create enumeration.
+   *
+   * @param official the type that was originally passed as a parameter by user.
+   * May be alias of some other type.
+   * @param type the type into that the "official type" evaluates during alias
+   * resolving. Initially equal to "official type".
+   */
+  public DynEnum create_enumeration(TypeCode official, TypeCode type)
+  {
+    return new gnuDynEnum(official, type, this, orb);
+  }
+
+  /**
+   * Create fixed.
+   *
+   * @param official the type that was originally passed as a parameter by user.
+   * May be alias of some other type.
+   * @param type the type into that the "official type" evaluates during alias
+   * resolving. Initially equal to "official type".
+   */
+  public DynFixed create_fixed(TypeCode official, TypeCode type)
+  {
+    return new gnuDynFixed(official, type, this, orb);
+  }
+
+  /**
+   * Create alias.
+   *
+   * @param official the type that was originally passed as a parameter by user.
+   * May be alias of some other type.
+   * @param type the type into that the "official type" evaluates during alias
+   * resolving. Initially equal to "official type".
+   */
+  public DynAny create_alias(TypeCode official, TypeCode type)
+                      throws InconsistentTypeCode
+  {
+    try
+      {
+        return create_dyn_any_from_type_code(official, type.content_type());
+      }
+    catch (BadKind e)
+      {
+        throw new Unexpected(e);
+      }
+  }
+
+  /**
+   * Create the undivideable DynAny.
+   */
+  public DynAny create_simple(TypeCode official, TypeCode type)
+  {
+    Streamable holder = HolderLocator.createHolder(type);
+    return new gnuDynAny(holder, official, type, this, orb);
+  }
+
+  /**
+   * Create the DynAny from typecode.
+   */
+  public DynAny create_dyn_any_from_type_code(TypeCode type)
+                                       throws InconsistentTypeCode
+  {
+    return create_dyn_any_from_type_code(type, type);
+  }
+
+  /**
+   * Create the DynAny from typecode.
+   *
+   * @param official the type that was originally passed as a parameter by user.
+   * May be alias of some other type.
+   * @param type the type into that the "official type" evaluates during alias
+   * resolving. Initially equal to "official type".
+   */
+  public DynAny create_dyn_any_from_type_code(TypeCode official, TypeCode type)
+                                       throws InconsistentTypeCode
+  {
+    DynAny d;
+    try
+      {
+        switch (type.kind().value())
+          {
+            case TCKind._tk_array :
+              return create_array(official, type);
+
+            case TCKind._tk_sequence :
+              return create_sequence(official, type);
+
+            case TCKind._tk_struct :
+            case TCKind._tk_except :
+              return create_structure(official, type);
+
+            case TCKind._tk_union :
+              return create_union(official, type);
+
+            case TCKind._tk_value :
+              return create_value(official, type);
+
+            case TCKind._tk_value_box :
+              return create_value_box(official, type);
+
+            case TCKind._tk_enum :
+              return create_enumeration(official, type);
+
+            case TCKind._tk_fixed :
+              return create_fixed(official, type);
+
+            case TCKind._tk_alias :
+              return create_alias(official, type);
+
+            case TCKind._tk_null :
+              return new gnuDynAny(null, official, type, this, orb);
+
+            case TCKind._tk_TypeCode :
+              d = create_simple(official, type);
+              d.insert_typecode(orb.get_primitive_tc(TCKind.tk_null));
+              return d;
+
+            case TCKind._tk_any :
+              d = create_simple(official, type);
+
+              Any empty_any = orb.create_any();
+              empty_any.type(orb.get_primitive_tc(TCKind.tk_null));
+              d.insert_any(empty_any);
+              return d;
+
+            case TCKind._tk_wstring :
+              d = create_simple(official, type);
+              d.insert_wstring("");
+              return d;
+
+            case TCKind._tk_string :
+              d = create_simple(official, type);
+              d.insert_string("");
+              return d;
+
+            case TCKind._tk_native :
+            case TCKind._tk_Principal :
+            case TCKind._tk_abstract_interface :
+              throw new InconsistentTypeCode("Following API, the " +
+                                             TypeKindNamer.nameIt(type) +
+                                             " must not be supported."
+                                            );
+
+            default :
+              return create_simple(official, type);
+          }
+      }
+    catch (UserException uex)
+      {
+        InconsistentTypeCode it = new InconsistentTypeCode();
+        it.initCause(uex);
+        throw it;
+      }
+  }
+
+  /**
+   * Create the DynAny using the passed value as template and assign this value.
+   */
+  public DynAny create_dyn_any(Any value)
+                        throws InconsistentTypeCode
+  {
+    DynAny created = create_dyn_any_from_type_code(value.type());
+    try
+      {
+        created.from_any(value);
+      }
+    catch (UserException uex)
+      {
+        InconsistentTypeCode t = new InconsistentTypeCode("Inconsistent Any");
+        t.initCause(uex);
+        throw t;
+      }
+    catch (Exception e)
+      {
+        throw new Unexpected(e);
+      }
+    return created;
+  }
+}
diff --git a/libjava/classpath/gnu/CORBA/DynAn/gnuDynArray.java b/libjava/classpath/gnu/CORBA/DynAn/gnuDynArray.java
new file mode 100644
index 000000000..5676c3d39
--- /dev/null
+++ b/libjava/classpath/gnu/CORBA/DynAn/gnuDynArray.java
@@ -0,0 +1,337 @@
+/* gnuDynArray.java --
+   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.DynAn;
+
+import gnu.CORBA.Unexpected;
+import gnu.CORBA.HolderLocator;
+
+import org.omg.CORBA.Any;
+import org.omg.CORBA.BAD_PARAM;
+import org.omg.CORBA.ORB;
+import org.omg.CORBA.TCKind;
+import org.omg.CORBA.TypeCode;
+import org.omg.CORBA.portable.Streamable;
+import org.omg.DynamicAny.DynAny;
+import org.omg.DynamicAny.DynAnyFactoryPackage.InconsistentTypeCode;
+import org.omg.DynamicAny.DynAnyPackage.InvalidValue;
+import org.omg.DynamicAny.DynAnyPackage.TypeMismatch;
+import org.omg.DynamicAny.DynArray;
+
+import java.io.Serializable;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.Field;
+
+/**
+ * Provides support for dynamic array or sequence, where all members have the
+ * same final_type.
+ *
+ * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
+ */
+public class gnuDynArray
+  extends DivideableAny
+  implements DynArray, Serializable
+{
+  /**
+   * Use serialVersionUID for interoperability.
+   */
+  private static final long serialVersionUID = 1;
+
+  /**
+   * The component "official" type (may be alias).
+   */
+  final TypeCode official_components;
+
+  /**
+   * The component "final" type, after resolving any aliases.
+   */
+  final TypeCode final_components;
+
+  /**
+   * Creates new array.
+   *
+   * @param aType the final_type of array.
+   * @param aFactory the factory, used to initialise default values.
+   * @param orb the ORB to that this DynAny belongs.
+   * @param initialise_array if false, the array is not initialised in
+   * constructor.
+   *
+   *
+   * @throws BAD_PARAM if the passed typecode does not provide the length().
+   */
+  public gnuDynArray(TypeCode oType, TypeCode aType, gnuDynAnyFactory aFactory,
+                     ORB anOrb, boolean initialise_array
+                    )
+              throws BAD_PARAM
+  {
+    super(oType, aType, aFactory, anOrb);
+
+    try
+      {
+        official_components = final_type.content_type();
+
+        TypeCode component = official_components;
+        while (component.kind().value() == TCKind._tk_alias)
+          component = component.content_type();
+        final_components = component;
+
+        if (initialise_array)
+          {
+            array = new DynAny[ aType.length() ];
+            for (int i = 0; i < array.length; i++)
+              {
+                array [ i ] =
+                  factory.create_dyn_any_from_type_code(official_components);
+              }
+          }
+      }
+    catch (Exception e)
+      {
+        BAD_PARAM bad = new BAD_PARAM("Unable to initialise array");
+        bad.initCause(e);
+        throw bad;
+      }
+  }
+
+  /**
+   * Copy one DynAny into another.
+   */
+  public void assign(DynAny from)
+              throws TypeMismatch
+  {
+    checkType(official_type, from.type());
+    if (from instanceof DynArray && from.component_count() == array.length)
+      {
+        DynArray dyn = (DynArray) from;
+        array = dyn.get_elements_as_dyn_any();
+      }
+    else
+      throw new TypeMismatch();
+  }
+
+  /**
+   * Create a copy.
+   */
+  public DynAny copy()
+  {
+    DynAny[] c = new DynAny[ array.length ];
+    for (int i = 0; i < c.length; i++)
+      {
+        c [ i ] = array [ i ].copy();
+      }
+
+    gnuDynArray d =
+      new gnuDynArray(official_type, final_type, factory, orb, false);
+    d.array = c;
+    return d;
+  }
+
+  /**
+   * Get elements as array of anys.
+   */
+  public Any[] get_elements()
+  {
+    Any[] r = new Any[ array.length ];
+    for (int i = 0; i < r.length; i++)
+      r [ i ] = array [ i ].to_any();
+    return r;
+  }
+
+  /** {@inheritDoc} */
+  public DynAny[] get_elements_as_dyn_any()
+  {
+    DynAny[] a = new DynAny[ array.length ];
+    for (int i = 0; i < a.length; i++)
+      {
+        a [ i ] = array [ i ].copy();
+      }
+    return a;
+  }
+
+  /**
+   * Set elements when array of dyn anys is provided. This method can set nested
+   * data structures as an array components.
+   */
+  public void set_elements_as_dyn_any(DynAny[] value)
+                               throws InvalidValue, TypeMismatch
+  {
+    if (value.length != array.length)
+      throw new InvalidValue(sizeMismatch(array.length, value.length));
+    for (int i = 0; i < value.length; i++)
+      {
+        checkType(official_components, value [ i ].type());
+        array [ i ].assign(value [ i ]);
+      }
+    pos = 0;
+    valueChanged();
+  }
+
+  /**
+   * Set elements when array of ordinary anys is provided.
+   */
+  public void set_elements(Any[] value)
+                    throws InvalidValue, TypeMismatch
+  {
+    if (value.length != array.length)
+      throw new InvalidValue(sizeMismatch(array.length, value.length));
+
+    for (int i = 0; i < value.length; i++)
+      {
+        checkType(official_components, value [ i ].type());
+        try
+          {
+            array [ i ] = factory.create_dyn_any(value [ i ]);
+          }
+        catch (InconsistentTypeCode e)
+          {
+            TypeMismatch t = new TypeMismatch();
+            t.initCause(e);
+            throw t;
+          }
+      }
+    pos = 0;
+    valueChanged();
+  }
+
+  /**
+   * Done via reflection.
+   */
+  public Any to_any()
+  {
+    try
+      {
+        Streamable memberHolder =
+          HolderLocator.createHolder(official_components);
+
+        if (memberHolder == null)
+          memberHolder = HolderLocator.createHolder(final_components);
+
+        Class memberHolderClass = memberHolder.getClass();
+        Class memberClass = memberHolderClass.getField("value").getType();
+
+        Object members = Array.newInstance(memberClass, array.length);
+        Object member;
+        Any am;
+        Field value = memberHolder.getClass().getField("value");
+
+        for (int i = 0; i < array.length; i++)
+          {
+            // Recursive call should support multidimensional arrays.
+            am = array [ i ].to_any();
+            memberHolder = am.extract_Streamable();
+            member = value.get(memberHolder);
+            Array.set(members, i, member);
+          }
+
+        Streamable arrayHolder = HolderLocator.createHolder(official_type);
+        arrayHolder.getClass().getField("value").set(arrayHolder, members);
+
+        Any g = createAny();
+        g.insert_Streamable(arrayHolder);
+        g.type(official_type);
+        return g;
+      }
+    catch (Exception e)
+      {
+        throw new Unexpected(e);
+      }
+  }
+
+  /**
+   * Done via reflection.
+   */
+  public void from_any(Any an_any)
+                throws TypeMismatch, InvalidValue
+  {
+    checkType(official_type, an_any.type());
+    try
+      {
+        Streamable s = an_any.extract_Streamable();
+        Object members = s.getClass().getField("value").get(s);
+
+        checkArrayValid(members);
+
+        Any member;
+        Streamable holder;
+        Class holderClass = null;
+
+        for (int i = 0; i < array.length; i++)
+          {
+            if (holderClass == null)
+              {
+                holder = HolderLocator.createHolder(official_components);
+                if (holder == null)
+                  holder = HolderLocator.createHolder(final_components);
+                holderClass = holder.getClass();
+              }
+            else
+              holder = (Streamable) holderClass.newInstance();
+
+            member = createAny();
+            holder.getClass().getField("value").set(holder,
+                                                    Array.get(members, i)
+                                                   );
+            member.insert_Streamable(holder);
+            member.type(official_components);
+
+            // This may lead to recursion, supporting multidimensional
+            // arrays.
+            array [ i ].from_any(member);
+          }
+      }
+    catch (Exception ex)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(ex);
+        throw t;
+      }
+    valueChanged();
+  }
+
+  /**
+   * Check if array size is valid and (for sequences) resized
+   * if required. Called from from_any.
+   */
+  protected void checkArrayValid(Object members)
+                          throws TypeMismatch, InvalidValue
+  {
+    if (array.length != Array.getLength(members))
+      throw new InvalidValue(sizeMismatch(array.length, Array.getLength(members)));
+  }
+}
diff --git a/libjava/classpath/gnu/CORBA/DynAn/gnuDynEnum.java b/libjava/classpath/gnu/CORBA/DynAn/gnuDynEnum.java
new file mode 100644
index 000000000..76b0a9527
--- /dev/null
+++ b/libjava/classpath/gnu/CORBA/DynAn/gnuDynEnum.java
@@ -0,0 +1,244 @@
+/* gnuDynEnum.java --
+   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.DynAn;
+
+import gnu.CORBA.Unexpected;
+
+import org.omg.CORBA.Any;
+import org.omg.CORBA.BAD_PARAM;
+import org.omg.CORBA.MARSHAL;
+import org.omg.CORBA.ORB;
+import org.omg.CORBA.TypeCode;
+import org.omg.CORBA.portable.InputStream;
+import org.omg.DynamicAny.DynAny;
+import org.omg.DynamicAny.DynAnyPackage.InvalidValue;
+import org.omg.DynamicAny.DynAnyPackage.TypeMismatch;
+import org.omg.DynamicAny.DynEnum;
+
+import java.io.IOException;
+
+import java.util.Arrays;
+
+/**
+ * Our implementation of dynamic enumeration.
+ *
+ * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
+ */
+public class gnuDynEnum extends UndivideableAny implements DynEnum
+{
+  /**
+   * Use serialVersionUID for interoperability.
+   */
+  private static final long serialVersionUID = 1;
+
+  /**
+   * The valid string values of the enumeration. Most of enumerations are short,
+   * counting 2-5 memebers. With so small number of memebers, it seems not
+   * reasonable to use hashtables.
+   */
+  final String[] values;
+
+  /**
+   * The current value of enum.
+   */
+  int current;
+
+  /**
+   * Create a new dyn enum from the given typecode.
+   */
+  public gnuDynEnum(TypeCode oType, TypeCode aType, gnuDynAnyFactory aFactory,
+    ORB anOrb
+  )
+  {
+    super(oType, aType, aFactory, anOrb);
+    try
+      {
+        values = new String[ final_type.member_count() ];
+
+        for (int i = 0; i < values.length; i++)
+          {
+            values [ i ] = final_type.member_name(i);
+          }
+      }
+    catch (Exception e)
+      {
+        throw new BAD_PARAM("Not enum");
+      }
+  }
+
+  /**
+   * Create a clone of the given enum, sharing values and final_type.
+   */
+  public gnuDynEnum(gnuDynEnum from)
+  {
+    super(from.official_type, from.final_type, from.factory, from.orb);
+    values = from.values;
+  }
+
+  /**
+   * Assign the Enum from the passed value. The passed DynAny must hold the
+   * enumeration of exactly the same final_type.
+   */
+  public void assign(DynAny from) throws TypeMismatch
+  {
+    checkType(official_type, from.type());
+    if (!(from instanceof DynEnum))
+      throw new TypeMismatch("Not a DynEnum");
+    try
+      {
+        set_as_ulong(((DynEnum) from).get_as_ulong());
+      }
+    catch (InvalidValue e)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(e);
+        throw t;
+      }
+  }
+
+  /**
+   * Copy this DynEnum.
+   */
+  public DynAny copy()
+  {
+    gnuDynEnum other = new gnuDynEnum(this);
+    other.current = current;
+    return other;
+  }
+
+  /**
+   * Compares for equality.
+   */
+  public boolean equal(DynAny other)
+  {
+    if (other instanceof gnuDynEnum)
+      {
+        gnuDynEnum oe = (gnuDynEnum) other;
+        return current == oe.current &&
+        (oe.values == values || Arrays.equals(values, oe.values));
+      }
+    else if (other instanceof DynEnum)
+      {
+        DynEnum oe = (DynEnum) other;
+        return current == oe.get_as_ulong() && official_type.equal(oe.type());
+      }
+    else
+      return false;
+  }
+
+  /**
+   * Set value from any that must contain enumeration.
+   */
+  public void from_any(Any an_any) throws TypeMismatch, InvalidValue
+  {
+    checkType(official_type, an_any.type());
+    try
+      {
+        InputStream in = an_any.create_input_stream();
+        set_as_ulong(in.read_long());
+        in.close();
+      }
+    catch (MARSHAL eof)
+      {
+        throw new InvalidValue();
+      }
+    catch (IOException ex)
+      {
+        throw new Unexpected(ex);
+      }
+  }
+
+  /**
+   * Get the value of this enumeration as string.
+   */
+  public String get_as_string()
+  {
+    return values [ current ];
+  }
+
+  /**
+   * Get the value of this enumeration as int.
+   */
+  public int get_as_ulong()
+  {
+    return current;
+  }
+
+  /**
+   * Set the value of this enumeration as string.
+   */
+  public void set_as_string(String value) throws InvalidValue
+  {
+    for (int i = 0; i < values.length; i++)
+      {
+        if (values [ i ].equals(value))
+          {
+            current = i;
+            valueChanged();
+            return;
+          }
+      }
+    throw new InvalidValue(value);
+  }
+
+  /**
+   * Set the value of this enumeration as int.
+   */
+  public void set_as_ulong(int value) throws InvalidValue
+  {
+    if (value < 0 || value >= values.length)
+      throw new InvalidValue(value + " not in [0.." + values.length);
+    else
+      {
+        current = value;
+        valueChanged();
+      }
+  }
+
+  /**
+   * Wrap the enumeration value into any.
+   */
+  public Any to_any()
+  {
+    Any a = createAny();
+    a.insert_long(current);
+    a.type(official_type);
+    return a;
+  }
+}
diff --git a/libjava/classpath/gnu/CORBA/DynAn/gnuDynFixed.java b/libjava/classpath/gnu/CORBA/DynAn/gnuDynFixed.java
new file mode 100644
index 000000000..9c7ea8252
--- /dev/null
+++ b/libjava/classpath/gnu/CORBA/DynAn/gnuDynFixed.java
@@ -0,0 +1,252 @@
+/* gnuDynFixed.java --
+   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.DynAn;
+
+import org.omg.CORBA.Any;
+import org.omg.CORBA.BAD_OPERATION;
+import org.omg.CORBA.BAD_PARAM;
+import org.omg.CORBA.ORB;
+import org.omg.CORBA.TypeCode;
+import org.omg.DynamicAny.DynAny;
+import org.omg.DynamicAny.DynAnyPackage.InvalidValue;
+import org.omg.DynamicAny.DynAnyPackage.TypeMismatch;
+import org.omg.DynamicAny.DynFixed;
+import org.omg.DynamicAny.DynFixedOperations;
+
+import java.math.BigDecimal;
+
+/**
+ * Implements DynAny, holding CORBA <code>fixed</code>. This class is derived
+ * from gnuDynEnm to avoid repetetive inclusion of unused DynAny methods.
+ *
+ * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
+ */
+public class gnuDynFixed extends UndivideableAny implements DynFixed
+{
+  /**
+   * Use serialVersionUID for interoperability.
+   */
+  private static final long serialVersionUID = 1;
+
+  /**
+   * The default value, assigned in the new instance.
+   */
+  static final BigDecimal ZERO = new BigDecimal("0.0");
+
+  /**
+   * The content of the dyn fixed, wrapped in this DynAny.
+   */
+  BigDecimal value;
+
+  /**
+   * The number of digits after the decimal point.
+   */
+  final int scale;
+
+  /**
+   * The number of digits.
+   */
+  final int digits;
+
+  /**
+   * Create a new instance of the dyn fixed.
+   */
+  public gnuDynFixed(TypeCode oType, TypeCode aType,
+    gnuDynAnyFactory aFactory, ORB anOrb
+  )
+  {
+    super(oType, aType, aFactory, anOrb);
+    try
+      {
+        digits = final_type.fixed_digits();
+        scale = final_type.fixed_scale();
+      }
+    catch (Exception e)
+      {
+        throw new BAD_PARAM("Not a fixed");
+      }
+    value = ZERO;
+  }
+
+  /**
+   * Clone the current instance.
+   */
+  public gnuDynFixed(gnuDynFixed from)
+  {
+    super(from.official_type, from.final_type, from.factory, from.orb);
+    digits = from.digits;
+    scale = from.scale;
+    value = from.value;
+  }
+
+  /**
+   * Get the value of the wrapped dyn fixed, as string.
+   */
+  public String get_value()
+  {
+    return value.toString();
+  }
+
+  /**
+   * Set the value.
+   */
+  public boolean set_value(String fixed_value)
+    throws TypeMismatch, InvalidValue
+  {
+    // Count the digits till decimal point.
+    int digs = 0;
+    char c;
+    boolean leading0 = true;
+    Digs:
+    for (int i = 0; i < fixed_value.length(); i++)
+      {
+        c = fixed_value.charAt(i);
+        if (Character.isDigit(c))
+          {
+            if (!(c == '0' && leading0))
+              digs++;
+            if (c != '0')
+              leading0 = false;
+          }
+        else if (c == '.')
+          break Digs;
+      }
+    if (digs > (digits - scale))
+      throw new InvalidValue("Too many digits: " + digs + " for " + digits +
+        "." + scale
+      );
+
+    try
+      {
+        value = new BigDecimal(fixed_value);
+      }
+    catch (NumberFormatException ex)
+      {
+        if (fixed_value.trim().length() == 0)
+          throw new InvalidValue("Empty string passed");
+
+        TypeMismatch inva =
+          new TypeMismatch("Not a number: '" + fixed_value + "'");
+        inva.initCause(ex);
+        throw inva;
+      }
+
+    valueChanged();
+    return value.scale() <= scale;
+  }
+
+  /**
+   * Assign the value from another BigDecimal.
+   */
+  public void assign(DynAny from) throws TypeMismatch
+  {
+    checkType(official_type, from.type());
+
+    if (from instanceof gnuDynFixed)
+      {
+        gnuDynFixed other = (gnuDynFixed) from;
+        value = other.value;
+      }
+    else if (from instanceof DynFixedOperations)
+      {
+        value = new BigDecimal(((DynFixedOperations) from).get_value());
+      }
+    else
+      throw new TypeMismatch("Not a DynFixed");
+    valueChanged();
+  }
+
+  /**
+   * Create a copy.
+   */
+  public DynAny copy()
+  {
+    return new gnuDynFixed(this);
+  }
+
+  /**
+   * Compare for equality.
+   */
+  public boolean equal(DynAny other)
+  {
+    if (other instanceof gnuDynFixed)
+      {
+        // Normally, this code would be executed.
+        return value.equals(((gnuDynFixed) other).value);
+      }
+    if (other instanceof DynFixedOperations)
+      {
+        // This may be involved when mixing implementations.
+        return ((DynFixedOperations) other).get_value().equals(get_value());
+      }
+    else
+      return false;
+  }
+
+  /**
+   * Set the value from Any (must hold <code>fixed</code> with the matching
+   * typecode.).
+   */
+  public void from_any(Any an_any) throws TypeMismatch, InvalidValue
+  {
+    try
+      {
+        checkType(official_type, an_any.type());
+
+        value = an_any.extract_fixed();
+        valueChanged();
+      }
+    catch (BAD_OPERATION e)
+      {
+        InvalidValue t = new InvalidValue();
+        t.initCause(e);
+        throw t;
+      }
+  }
+
+  /**
+   * Create and return Any, holding this DynFixed value.
+   */
+  public Any to_any()
+  {
+    Any g = createAny();
+    g.insert_fixed(value, official_type);
+    return g;
+  }
+}
diff --git a/libjava/classpath/gnu/CORBA/DynAn/gnuDynSequence.java b/libjava/classpath/gnu/CORBA/DynAn/gnuDynSequence.java
new file mode 100644
index 000000000..d006c24a5
--- /dev/null
+++ b/libjava/classpath/gnu/CORBA/DynAn/gnuDynSequence.java
@@ -0,0 +1,254 @@
+/* gnuDynSequence.java --
+   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.DynAn;
+
+import gnu.CORBA.Unexpected;
+
+import org.omg.CORBA.Any;
+import org.omg.CORBA.BAD_PARAM;
+import org.omg.CORBA.ORB;
+import org.omg.CORBA.TypeCode;
+import org.omg.CORBA.TypeCodePackage.BadKind;
+import org.omg.DynamicAny.DynAny;
+import org.omg.DynamicAny.DynAnyFactoryPackage.InconsistentTypeCode;
+import org.omg.DynamicAny.DynAnyPackage.InvalidValue;
+import org.omg.DynamicAny.DynAnyPackage.TypeMismatch;
+import org.omg.DynamicAny.DynSequence;
+
+import java.io.Serializable;
+
+import java.lang.reflect.*;
+
+public class gnuDynSequence
+  extends gnuDynArray
+  implements DynSequence, Serializable
+{
+  /**
+   * Use serialVersionUID for interoperability.
+   */
+  private static final long serialVersionUID = 1;
+
+  /**
+   * The bound of the sequence, as defined in typecode.
+   */
+  final int bound;
+
+  /**
+   * Create a new gnuDynSequence with the given typecode.
+   *
+   * @throws BAD_PARAM if the passed typecode is probably not a sequence
+   * typecode.
+   */
+  public gnuDynSequence(TypeCode oType, TypeCode aType,
+                        gnuDynAnyFactory aFactory, ORB anOrb
+                       )
+                 throws BAD_PARAM
+  {
+    super(oType, aType, aFactory, anOrb, false);
+    array = new DynAny[ 0 ];
+    try
+      {
+        bound = final_type.length();
+      }
+    catch (BadKind ex)
+      {
+        throw new Unexpected(ex);
+      }
+  }
+
+  /**
+   * Get the length of the sequence.
+   */
+  public int get_length()
+  {
+    return array.length;
+  }
+
+  /**
+   * Resize the sequence, preserving components.
+   */
+  public void set_length(int length)
+                  throws InvalidValue
+  {
+    checkBound(length);
+    if (length == array.length)
+      return; // Nothing to do.
+    else if (length < array.length)
+      {
+        // Truncate.
+        DynAny[] d = new DynAny[ length ];
+        for (int i = 0; i < d.length; i++)
+          d [ i ] = array [ i ];
+        array = d;
+      }
+    else
+      {
+        // Expand.
+        DynAny[] d = new DynAny[ length ];
+        for (int i = 0; i < array.length; i++)
+          d [ i ] = array [ i ];
+
+        for (int i = array.length; i < d.length; i++)
+          {
+            try
+              {
+                d [ i ] =
+                  factory.create_dyn_any_from_type_code(official_components);
+              }
+            catch (InconsistentTypeCode e)
+              {
+                throw new Unexpected(e);
+              }
+          }
+        array = d;
+      }
+    valueChanged();
+  }
+
+  /**
+   * Copy one DynAny into another.
+   */
+  public void assign(DynAny from)
+              throws TypeMismatch
+  {
+    checkType(official_type, from.type());
+    if (from instanceof DynSequence)
+      {
+        DynSequence dyn = (DynSequence) from;
+        array = dyn.get_elements_as_dyn_any();
+      }
+    else
+      throw new TypeMismatch();
+  }
+
+  /*
+   * Set the contenst of the sequence, resizing if required.
+   */
+  public void set_elements_as_dyn_any(DynAny[] value)
+                               throws InvalidValue, TypeMismatch
+  {
+    checkBound(value.length);
+    if (array.length != value.length)
+      set_length(value.length);
+
+    for (int i = 0; i < value.length; i++)
+      {
+        checkType(official_components, value [ i ].type());
+        array [ i ].assign(value [ i ]);
+      }
+    valueChanged();
+  }
+
+  /**
+   * Set the elements from array of Any's.
+   */
+  public void set_elements(Any[] value)
+                    throws InvalidValue, TypeMismatch
+  {
+    checkBound(value.length);
+
+    DynAny[] prev = array;
+
+    array = new DynAny[ value.length ];
+    try
+      {
+        super.set_elements(value);
+
+        // valueChanged() is called in super.set_elements(value).
+      }
+
+    // On the problem, value does not change.
+    catch (TypeMismatch ex)
+      {
+        array = prev;
+        throw ex;
+      }
+    catch (InvalidValue ex)
+      {
+        array = prev;
+        throw ex;
+      }
+    catch (RuntimeException rex)
+      {
+        array = prev;
+        throw rex;
+      }
+  }
+
+  /**
+   * Create a copy.
+   */
+  public DynAny copy()
+  {
+    DynAny[] c = new DynAny[ array.length ];
+    for (int i = 0; i < c.length; i++)
+      {
+        c [ i ] = array [ i ].copy();
+      }
+
+    gnuDynSequence d =
+      new gnuDynSequence(official_type, final_type, factory, orb);
+    d.array = c;
+    return d;
+  }
+
+  /**
+   * Check the bound.
+   *
+   * @param x the value to check.
+   */
+  void checkBound(int x)
+           throws InvalidValue
+  {
+    if (bound != 0)
+      if (x < 0 || x > bound)
+        throw new InvalidValue(x + " out of bounds, valid [0.." + bound + "]");
+  }
+
+  /**
+   * Check if array size is valid. Called from from_any.
+   */
+  protected void checkArrayValid(Object members)
+                          throws TypeMismatch, InvalidValue
+  {
+    checkBound(Array.getLength(members));
+    if (get_length() != Array.getLength(members))
+      set_length(Array.getLength(members));
+  }
+}
diff --git a/libjava/classpath/gnu/CORBA/DynAn/gnuDynStruct.java b/libjava/classpath/gnu/CORBA/DynAn/gnuDynStruct.java
new file mode 100644
index 000000000..b15aff3e1
--- /dev/null
+++ b/libjava/classpath/gnu/CORBA/DynAn/gnuDynStruct.java
@@ -0,0 +1,109 @@
+/* gnuDynStruct.java --
+   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.DynAn;
+
+import java.io.Serializable;
+
+import org.omg.CORBA.ORB;
+import org.omg.CORBA.TypeCode;
+import org.omg.DynamicAny.DynStruct;
+import org.omg.DynamicAny.NameDynAnyPair;
+import org.omg.DynamicAny.NameValuePair;
+import gnu.CORBA.Unexpected;
+import org.omg.DynamicAny.DynAny;
+
+/**
+ * Implementation of the DynStruct.
+ *
+ * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
+ */
+public class gnuDynStruct
+  extends RecordAny
+  implements DynStruct, Serializable
+{
+  /**
+   * Use serialVersionUID for interoperability.
+   */
+  private static final long serialVersionUID = 1;
+
+  /**
+   * Create an instance.
+   */
+  public gnuDynStruct(TypeCode oType, TypeCode aType,
+                      gnuDynAnyFactory aFactory, ORB anOrb)
+  {
+    super(oType, aType, aFactory, anOrb);
+
+    // Initialise fields.
+    try
+      {
+        array = new DynAny[ final_type.member_count() ];
+        fNames = new String[ array.length ];
+        for (int i = 0; i < array.length; i++)
+          {
+            array [ i ] =
+              factory.create_dyn_any_from_type_code(final_type.member_type(i));
+            fNames [ i ] = final_type.member_name(i);
+          }
+      }
+    catch (Exception e)
+      {
+        throw new Unexpected(e);
+      }
+  }
+
+  /** @inheritDoc */
+  protected RecordAny newInstance(TypeCode oType, TypeCode aType,
+                                       gnuDynAnyFactory aFactory, ORB anOrb)
+  {
+    return new gnuDynStruct(oType, aType, aFactory, anOrb);
+  }
+
+  /** @inheritDoc */
+  public NameDynAnyPair[] get_members_as_dyn_any()
+  {
+    return super.gnu_get_members_as_dyn_any();
+  }
+
+  /** @inheritDoc */
+  public NameValuePair[] get_members()
+  {
+    return super.gnu_get_members();
+  }
+}
diff --git a/libjava/classpath/gnu/CORBA/DynAn/gnuDynUnion.java b/libjava/classpath/gnu/CORBA/DynAn/gnuDynUnion.java
new file mode 100644
index 000000000..adbc5731d
--- /dev/null
+++ b/libjava/classpath/gnu/CORBA/DynAn/gnuDynUnion.java
@@ -0,0 +1,437 @@
+/* gnuDynUnion.java --
+   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.DynAn;
+
+import gnu.CORBA.Unexpected;
+
+import org.omg.CORBA.Any;
+import org.omg.CORBA.MARSHAL;
+import org.omg.CORBA.ORB;
+import org.omg.CORBA.TCKind;
+import org.omg.CORBA.TypeCode;
+import org.omg.CORBA.TypeCodePackage.BadKind;
+import org.omg.CORBA.portable.InputStream;
+import org.omg.CORBA.portable.OutputStream;
+import org.omg.DynamicAny.DynAny;
+import org.omg.DynamicAny.DynAnyFactoryPackage.InconsistentTypeCode;
+import org.omg.DynamicAny.DynAnyPackage.InvalidValue;
+import org.omg.DynamicAny.DynAnyPackage.TypeMismatch;
+import org.omg.DynamicAny.DynUnion;
+
+import java.io.Serializable;
+
+/**
+ * Implementation of DynUnion.
+ *
+ * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
+ */
+public class gnuDynUnion
+  extends DivideableAny
+  implements DynUnion, Serializable, ValueChangeListener
+{
+  /**
+   * Use serialVersionUID for interoperability.
+   */
+  private static final long serialVersionUID = 1;
+
+  /**
+   * The discrimintor of this union.
+   */
+  DynAny discriminator;
+
+  /**
+   * The message string that occurs several times throwing exception.
+   */
+  static String NOAM = "No active member";
+
+  /**
+   * Create a new instance with the given typecode.
+   *
+   * @param aType the final_type, must be final_type of the union.
+   */
+  public gnuDynUnion(TypeCode oType, TypeCode aType, gnuDynAnyFactory aFactory,
+                     ORB anOrb
+                    )
+              throws InconsistentTypeCode
+  {
+    super(oType, aType, aFactory, anOrb);
+    try
+      {
+        discriminator =
+          factory.create_dyn_any_from_type_code(final_type.discriminator_type());
+
+        ((AbstractAny) discriminator).listener = this;
+
+        if (final_type.default_index() >= 0)
+          set_to_default_member();
+        else
+          set_to_no_active_member();
+      }
+    catch (Exception ex)
+      {
+        InconsistentTypeCode inc = new InconsistentTypeCode("discriminator");
+        inc.initCause(ex);
+        throw inc;
+      }
+  }
+
+  /*
+   * (non-Javadoc)
+   *
+   * @see gnu.CORBA.DynAn.DivideableAny#to_any()
+   */
+  public Any to_any()
+  {
+    Any a = createAny();
+    OutputStream ou = a.create_output_stream();
+    discriminator.to_any().write_value(ou);
+    if (array.length == 2)
+      array [ 1 ].to_any().write_value(ou);
+    a.read_value(ou.create_input_stream(), final_type);
+    return a;
+  }
+
+  /**
+   * Assign from another identical structure.
+   */
+  public void assign(DynAny from)
+              throws TypeMismatch
+  {
+    checkType(official_type, from.type());
+    if (!(from instanceof DynUnion))
+      throw new TypeMismatch("DynUnion required");
+    else
+      {
+        try
+          {
+            DynUnion u = (DynUnion) from;
+            discriminator.assign(u.get_discriminator());
+            if (u.has_no_active_member())
+              {
+                if (array.length != 1)
+                  array = new DynAny[] { discriminator };
+              }
+            else
+              {
+                if (array.length != 2)
+                  array = new DynAny[] { discriminator, u.member().copy() };
+                else
+                  array [ 1 ] = u.member().copy();
+              }
+          }
+        catch (InvalidValue e)
+          {
+            throw new Unexpected(e);
+          }
+      }
+    valueChanged();
+  }
+
+  /** @inheritDoc */
+  public DynAny copy()
+  {
+    try
+      {
+        gnuDynUnion other =
+          new gnuDynUnion(official_type, final_type, factory, orb);
+        other.discriminator = discriminator.copy();
+        ((AbstractAny) other.discriminator).listener = other;
+        if (array.length == 1)
+          {
+            other.array = new DynAny[] { other.discriminator };
+          }
+        else
+          {
+            other.array =
+              new DynAny[] { other.discriminator, array [ 1 ].copy() };
+          }
+        return other;
+      }
+    catch (InconsistentTypeCode ex)
+      {
+        throw new Unexpected(ex);
+      }
+  }
+
+  /**
+   * Done via reading from stream.
+   */
+  public void from_any(Any an_any)
+                throws TypeMismatch, InvalidValue
+  {
+    checkType(official_type, an_any.type());
+
+    Any adis = createAny();
+    try
+      {
+        InputStream stream = an_any.create_input_stream();
+        adis.read_value(stream, final_type.discriminator_type());
+
+        DynAny nd = factory.create_dyn_any(adis);
+
+        set_discriminator(nd);
+        if (array.length == 2)
+          {
+            // Reusing the same Any <code>adis</code>.
+            adis.read_value(stream, array [ 1 ].type());
+            array [ 1 ].from_any(adis);
+          }
+      }
+    catch (InconsistentTypeCode it)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(it);
+        throw t;
+      }
+    catch (MARSHAL m)
+      {
+        InvalidValue t = new InvalidValue();
+        t.initCause(m);
+        throw t;
+      }
+    catch (BadKind b)
+      {
+        throw new Unexpected(b);
+      }
+    valueChanged();
+  }
+
+  /** @inheritDoc */
+  public TCKind discriminator_kind()
+  {
+    return discriminator.type().kind();
+  }
+
+  /** @inheritDoc */
+  public DynAny get_discriminator()
+  {
+    return discriminator;
+  }
+
+  /** @inheritDoc */
+  public boolean has_no_active_member()
+  {
+    return array.length == 1;
+  }
+
+  /** @inheritDoc */
+  public TCKind member_kind()
+                     throws InvalidValue
+  {
+    return member().type().kind();
+  }
+
+  /**
+   * Get the name of the current variant of the union.
+   */
+  public String member_name()
+                     throws InvalidValue
+  {
+    if (array.length == 1)
+      throw new InvalidValue(NOAM);
+    try
+      {
+        Any da = discriminator.to_any();
+
+
+        // Get the discriminator variant.
+        for (int i = 0; i < final_type.member_count(); i++)
+          {
+            if (final_type.member_label(i).equal(da))
+              return final_type.member_name(i);
+          }
+        throw new InvalidValue(NOAM);
+      }
+    catch (Exception e)
+      {
+        InvalidValue t = new InvalidValue("Err");
+        t.initCause(e);
+        throw t;
+      }
+  }
+
+  /** @inheritDoc */
+  public DynAny member()
+                throws InvalidValue
+  {
+    if (array.length < 2)
+      throw new InvalidValue(NOAM);
+    else
+      return array [ 1 ];
+  }
+
+  /**
+   * Set the union discriminator.
+   */
+  public void set_discriminator(DynAny aDiscriminator)
+                         throws TypeMismatch
+  {
+    try
+      {
+        if (!aDiscriminator.type().equal(final_type.discriminator_type()))
+          throw new TypeMismatch("Wrong discriminator final_type for " +
+                                 final_type.name()
+                                );
+
+        // Seting the same discriminator value again should not change
+        // the fields of the current member.
+        if (!discriminator.equal(aDiscriminator))
+          {
+            discriminator.assign(aDiscriminator);
+            updateMember();
+          }
+        else
+          {
+            pos = array.length == 2 ? 1 : 0;
+          }
+      }
+    catch (Exception e)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(e);
+        throw t;
+      }
+  }
+
+  /**
+   * Set to default member, if one exists.
+   */
+  public void set_to_default_member()
+                             throws TypeMismatch
+  {
+    try
+      {
+        int di = final_type.default_index();
+        if (di < 0)
+          throw new TypeMismatch("Union " + final_type.name() +
+                                 "has no default index"
+                                );
+
+        Any da = final_type.member_label(di);
+        discriminator.from_any(da);
+        updateMember();
+      }
+    catch (TypeMismatch m)
+      {
+        // This one OK.
+        throw m;
+      }
+    catch (Exception e)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(e);
+        throw t;
+      }
+  }
+
+  /** @inheritDoc */
+  public void set_to_no_active_member()
+                               throws TypeMismatch
+  {
+    try
+      {
+        if (final_type.default_index() >= 0)
+          {
+            throw new TypeMismatch("Explicit default case defined.");
+          }
+      }
+    catch (BadKind ex)
+      {
+        // The default index is not set.
+      }
+    array = new DynAny[] { discriminator };
+    valueChanged();
+  }
+
+  /**
+   * Update member, in accordance with discriminator value.
+   */
+  public void updateMember()
+                    throws TypeMismatch
+  {
+    try
+      {
+        Any da = discriminator.to_any();
+
+
+        // Get the discriminator variant.
+        for (int i = 0; i < final_type.member_count(); i++)
+          {
+            if (final_type.member_label(i).equal(da))
+              {
+                array =
+                  new DynAny[]
+                  {
+                    discriminator,
+                    factory.create_dyn_any_from_type_code(final_type.member_type(i))
+                  };
+                pos = 1;
+                valueChanged();
+                return;
+              }
+          }
+      }
+    catch (Exception e)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(e);
+        throw t;
+      }
+
+    // Discrimintator does not point to valid member.
+    array = new DynAny[] { discriminator };
+    pos = 0;
+    valueChanged();
+  }
+
+  /**
+   * Called when the discriminator is changed.
+   */
+  public void changed()
+  {
+    try
+      {
+        updateMember();
+      }
+    catch (TypeMismatch ex)
+      {
+        throw new Unexpected(ex);
+      }
+  }
+}
diff --git a/libjava/classpath/gnu/CORBA/DynAn/gnuDynValue.java b/libjava/classpath/gnu/CORBA/DynAn/gnuDynValue.java
new file mode 100644
index 000000000..32b2f0d1a
--- /dev/null
+++ b/libjava/classpath/gnu/CORBA/DynAn/gnuDynValue.java
@@ -0,0 +1,380 @@
+/* gnuDynValue.java --
+   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.DynAn;
+
+import gnu.CORBA.Minor;
+import gnu.CORBA.Unexpected;
+
+import org.omg.CORBA.Any;
+import org.omg.CORBA.BAD_PARAM;
+import org.omg.CORBA.MARSHAL;
+import org.omg.CORBA.ORB;
+import org.omg.CORBA.TCKind;
+import org.omg.CORBA.TypeCode;
+import org.omg.CORBA.VM_TRUNCATABLE;
+import org.omg.CORBA.portable.OutputStream;
+import org.omg.CORBA.portable.ValueFactory;
+import org.omg.DynamicAny.DynAny;
+import org.omg.DynamicAny.DynAnyPackage.InvalidValue;
+import org.omg.DynamicAny.DynAnyPackage.TypeMismatch;
+import org.omg.DynamicAny.DynStruct;
+import org.omg.DynamicAny.DynValue;
+import org.omg.DynamicAny.DynValueCommon;
+import org.omg.DynamicAny.DynValueOperations;
+import org.omg.DynamicAny.NameDynAnyPair;
+import org.omg.DynamicAny.NameValuePair;
+
+import java.io.Serializable;
+
+/**
+ * Implementation of DynValue.
+ *
+ * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
+ */
+public class gnuDynValue extends RecordAny implements DynValue,
+  Serializable
+{
+  /**
+   * Use serialVersionUID for interoperability.
+   */
+  private static final long serialVersionUID = 1;
+
+  /**
+   * If true, the value of this ValueType is set to null.
+   */
+  boolean isNull;
+
+  /**
+   * Create an instance.
+   */
+  public gnuDynValue(TypeCode oType, TypeCode aType,
+    gnuDynAnyFactory aFactory, ORB anOrb
+  )
+  {
+    super(oType, aType, aFactory, anOrb);
+
+    // Initialise fields. The array of fields also includes all inherited
+    // fields.
+    try
+      {
+        array = new DynAny[ final_type.member_count() ];
+        fNames = new String[ array.length ];
+        for (int i = 0; i < array.length; i++)
+          {
+            array [ i ] =
+              factory.create_dyn_any_from_type_code(final_type.member_type(i));
+            fNames [ i ] = final_type.member_name(i);
+          }
+
+        // Search of inherited members.
+        if (final_type.type_modifier() == VM_TRUNCATABLE.value)
+          {
+            TypeCode parent = final_type.concrete_base_type();
+            DynAny ancestor = factory.create_dyn_any_from_type_code(parent);
+
+            if (ancestor instanceof DynValue)
+              {
+                // Add members of ancestor in front of the curren members.
+                DynValue anc = (DynValue) ancestor;
+                anc.set_to_value();
+
+                NameDynAnyPair[] aar = anc.get_members_as_dyn_any();
+                inheritFields(aar);
+              }
+            else if (ancestor instanceof DynStruct)
+              {
+                // Add members of ancestor in front of the curren members.
+                DynStruct anc = (DynStruct) ancestor;
+                NameDynAnyPair[] aar = anc.get_members_as_dyn_any();
+                inheritFields(aar);
+              }
+            else
+              throw new BAD_PARAM("The parent of " + final_type.id() + ", " +
+                parent.id() + ", is not structure nor value."
+              );
+          }
+      }
+    catch (Exception e)
+      {
+        throw new Unexpected(e);
+      }
+
+    set_to_null();
+  }
+
+  /**
+   * Inherit the provided fields.
+   */
+  private void inheritFields(NameDynAnyPair[] aar)
+  {
+    DynAny[] nArray = new DynAny[ array.length + aar.length ];
+    String[] nNames = new String[ array.length + aar.length ];
+    int p = 0;
+    for (int i = 0; i < aar.length; i++)
+      {
+        nArray [ p ] = aar [ i ].value;
+        nNames [ p ] = aar [ i ].id;
+        p++;
+      }
+
+    for (int i = 0; i < array.length; i++)
+      {
+        nArray [ p ] = array [ i ];
+        nNames [ p ] = fNames [ i ];
+        p++;
+      }
+
+    array = nArray;
+    fNames = nNames;
+  }
+
+  /** @inheritDoc */
+  public TCKind current_member_kind() throws TypeMismatch, InvalidValue
+  {
+    if (isNull)
+      throw new TypeMismatch(ISNULL);
+    else
+      return super.current_member_kind();
+  }
+
+  /** @inheritDoc */
+  public String current_member_name() throws TypeMismatch, InvalidValue
+  {
+    if (isNull)
+      throw new TypeMismatch(ISNULL);
+    else
+      return super.current_member_name();
+  }
+
+  /** @inheritDoc */
+  public NameDynAnyPair[] get_members_as_dyn_any() throws InvalidValue
+  {
+    if (isNull)
+      throw new InvalidValue(ISNULL);
+    return super.gnu_get_members_as_dyn_any();
+  }
+
+  /** @inheritDoc */
+  public NameValuePair[] get_members() throws InvalidValue
+  {
+    if (isNull)
+      throw new InvalidValue(ISNULL);
+    else
+      return super.gnu_get_members();
+  }
+
+  /** @inheritDoc */
+  public void set_members_as_dyn_any(NameDynAnyPair[] value)
+    throws TypeMismatch, InvalidValue
+  {
+    super.set_members_as_dyn_any(value);
+    isNull = false;
+  }
+
+  /** @inheritDoc */
+  public void set_members(NameValuePair[] value)
+    throws TypeMismatch, InvalidValue
+  {
+    super.set_members(value);
+    isNull = false;
+  }
+
+  /** @inheritDoc */
+  public boolean is_null()
+  {
+    return isNull;
+  }
+
+  /** @inheritDoc */
+  public void set_to_null()
+  {
+    isNull = true;
+    valueChanged();
+  }
+
+  /** @inheritDoc */
+  public void set_to_value()
+  {
+    isNull = false;
+    valueChanged();
+  }
+
+  /**
+   * Create a new instance.
+   */
+  protected RecordAny newInstance(TypeCode oType, TypeCode aType,
+    gnuDynAnyFactory aFactory, ORB anOrb
+  )
+  {
+    gnuDynValue v = new gnuDynValue(oType, aType, aFactory, anOrb);
+    if (isNull)
+      v.set_to_null();
+    else
+      v.set_to_value();
+    return v;
+  }
+
+  /**
+   * Compare for equality, minding null values.
+   */
+  public boolean equal(DynAny other)
+  {
+    if (other instanceof DynValueOperations)
+      {
+        DynValueCommon o = (DynValueCommon) other;
+        if (isNull)
+          return o.is_null() && o.type().equal(official_type);
+        else
+          return !o.is_null() && super.equal(other);
+      }
+    else
+      return false;
+  }
+
+  /**
+   * Get the focused component, throwing exception if the current value is null.
+   */
+  protected DynAny focused() throws InvalidValue, TypeMismatch
+  {
+    if (isNull)
+      throw new TypeMismatch(ISNULL);
+    else
+      return super.focused();
+  }
+
+  /**
+   * Convert into Any.
+   */
+  public Any to_any()
+  {
+    if (isNull)
+      {
+        Any a0 = createAny();
+        a0.type(orb.get_primitive_tc(TCKind.tk_null));
+        return a0;
+      }
+    else
+      {
+        try
+          {
+            ValueFactory factory =
+              ((org.omg.CORBA_2_3.ORB) orb).lookup_value_factory(official_type.id());
+            if (factory == null)
+              {
+                MARSHAL m = new MARSHAL("Factory for " + official_type.id() +
+                " not registered.");
+                m.minor = Minor.Factory;
+                throw m;
+              }
+
+            OutputStream out = orb.create_output_stream();
+
+            for (int i = 0; i < array.length; i++)
+              array [ i ].to_any().write_value(out);
+
+            org.omg.CORBA_2_3.portable.InputStream in =
+              (org.omg.CORBA_2_3.portable.InputStream) out.create_input_stream();
+            Serializable v = factory.read_value(in);
+
+            Any g = createAny();
+            g.type(official_type);
+            g.insert_Value(v, official_type);
+
+            return g;
+          }
+        catch (Exception e)
+          {
+            throw new Unexpected(e);
+          }
+      }
+  }
+
+  /** @inheritDoc */
+  public void assign(DynAny from) throws TypeMismatch
+  {
+    checkType(official_type, from.type());
+
+    if (from instanceof DynValue)
+      {
+        DynValue other = (DynValue) from;
+        if (other.is_null())
+          set_to_null();
+        else
+          {
+            set_to_value();
+            try
+              {
+                DynValueOperations src = (DynValueOperations) from;
+                set_members_as_dyn_any(src.get_members_as_dyn_any());
+              }
+            catch (InvalidValue e)
+              {
+                TypeMismatch t = new TypeMismatch("Invalid value");
+                t.initCause(e);
+                throw t;
+              }
+          }
+      }
+    else
+      throw new TypeMismatch("Not a DynValue");
+  }
+
+  /**
+   * Get the number of components.
+   */
+  public int component_count()
+  {
+    return isNull ? 0 : super.component_count();
+  }
+
+  /** {@inheritDoc} */
+  public Serializable get_val() throws TypeMismatch, InvalidValue
+  {
+    return to_any().extract_Value();
+  }
+
+  /** {@inheritDoc} */
+  public void insert_val(Serializable a_x) throws InvalidValue, TypeMismatch
+  {
+    Any a = to_any();
+    a.insert_Value(a_x);
+    from_any(a);
+    valueChanged();
+  }
+}
diff --git a/libjava/classpath/gnu/CORBA/DynAn/gnuDynValueBox.java b/libjava/classpath/gnu/CORBA/DynAn/gnuDynValueBox.java
new file mode 100644
index 000000000..9c50534ed
--- /dev/null
+++ b/libjava/classpath/gnu/CORBA/DynAn/gnuDynValueBox.java
@@ -0,0 +1,389 @@
+/* gnuDynValueBox.java --
+   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.DynAn;
+
+import gnu.CORBA.Unexpected;
+import gnu.CORBA.HolderLocator;
+
+import org.omg.CORBA.Any;
+import org.omg.CORBA.ORB;
+import org.omg.CORBA.TCKind;
+import org.omg.CORBA.TypeCode;
+import org.omg.CORBA.TypeCodePackage.BadKind;
+import org.omg.CORBA.portable.Streamable;
+import org.omg.DynamicAny.DynAny;
+import org.omg.DynamicAny.DynAnyFactoryPackage.InconsistentTypeCode;
+import org.omg.DynamicAny.DynAnyPackage.InvalidValue;
+import org.omg.DynamicAny.DynAnyPackage.TypeMismatch;
+import org.omg.DynamicAny.DynValueBox;
+import org.omg.DynamicAny.DynValueBoxOperations;
+import org.omg.DynamicAny.DynValueCommon;
+
+import java.io.Serializable;
+
+import java.lang.reflect.Field;
+
+/**
+ * Implementation of the DynValueBox.
+ *
+ * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
+ */
+public class gnuDynValueBox
+  extends DivideableAny
+  implements DynValueBox, Serializable
+{
+  /**
+   * Use serialVersionUID for interoperability.
+   */
+  private static final long serialVersionUID = 1;
+
+  /**
+   * The final_type of contents of this value box.
+   */
+  final TypeCode content;
+
+  /**
+   * The string for some TypeMismatch exceptions.
+   */
+  String CONTENT = "Box content final_type mismatch";
+
+  /**
+   * Create a new instance of gnuDynValueBox.
+   */
+  public gnuDynValueBox(TypeCode oType, TypeCode aType,
+                        gnuDynAnyFactory aFactory, ORB anOrb
+                       )
+  {
+    super(oType, aType, aFactory, anOrb);
+    try
+      {
+        content = final_type.content_type();
+        array = new DynAny[] { factory.create_dyn_any_from_type_code(content) };
+        set_to_null();
+      }
+    catch (Exception e)
+      {
+        throw new Unexpected(e);
+      }
+  }
+
+  /** @inheritDoc */
+  public void assign(DynAny from)
+              throws TypeMismatch
+  {
+    checkType(official_type, from.type());
+    if (from instanceof DynValueBoxOperations)
+      {
+        DynValueBoxOperations other = (DynValueBoxOperations) from;
+        if (other.is_null())
+          set_to_null();
+        else
+          {
+            DynAny inBox;
+            try
+              {
+                inBox = other.get_boxed_value_as_dyn_any();
+              }
+            catch (InvalidValue e)
+              {
+                TypeMismatch t = new TypeMismatch("Invalid value");
+                t.initCause(e);
+                throw t;
+              }
+            if (!content.equal(inBox.type()))
+              throw new TypeMismatch(CONTENT);
+            array = new DynAny[] { inBox.copy() };
+          }
+      }
+    valueChanged();
+  }
+
+  /** @inheritDoc */
+  public DynAny copy()
+  {
+    gnuDynValueBox other =
+      new gnuDynValueBox(official_type, final_type, factory, orb);
+    if (is_null())
+      other.set_to_null();
+    else
+      {
+        try
+          {
+            other.array = new DynAny[] { array [ 0 ].copy() };
+          }
+        catch (Exception e)
+          {
+            throw new Unexpected(e);
+          }
+      }
+    return other;
+  }
+
+  /**
+   * Returns null for null value, delegates to super. otherwise.
+   */
+  public DynAny current_component()
+                           throws TypeMismatch
+  {
+    if (is_null())
+      return null;
+    else
+      return super.current_component();
+  }
+
+  /**
+   * Compare for equality, minding null values.
+   */
+  public boolean equal(DynAny other)
+  {
+    if (other instanceof DynValueCommon)
+      {
+        DynValueCommon o = (DynValueCommon) other;
+        if (is_null())
+          return o.is_null() && o.type().equal(official_type);
+        else
+          return !o.is_null() && super.equal(other);
+      }
+    else
+      return false;
+  }
+
+  /** @inheritDoc */
+  public void from_any(Any an_any)
+                throws TypeMismatch, InvalidValue
+  {
+    checkType(official_type, an_any.type());
+    try
+      {
+        if (!an_any.type().content_type().equal(content))
+          throw new InvalidValue(CONTENT);
+      }
+    catch (BadKind e)
+      {
+        TypeMismatch t = new TypeMismatch("Not a box");
+        t.initCause(e);
+        throw t;
+      }
+
+    Serializable s = an_any.extract_Value();
+    if (s == null)
+      set_to_null();
+    else
+      {
+        try
+          {
+            Streamable holder = HolderLocator.createHolder(content);
+            Field v = holder.getClass().getField("value");
+            v.set(holder, s);
+
+            Any cont = createAny();
+            cont.insert_Streamable(holder);
+
+            array = new DynAny[] { factory.create_dyn_any(cont) };
+          }
+        catch (Exception ex)
+          {
+            throw new Unexpected(ex);
+          }
+      }
+    valueChanged();
+  }
+
+  /** @inheritDoc */
+  public Any get_boxed_value()
+                      throws InvalidValue
+  {
+    try
+      {
+        if (is_null())
+          throw new InvalidValue(ISNULL);
+        else
+          return array [ 0 ].to_any();
+      }
+    catch (Exception e)
+      {
+        InvalidValue t = new InvalidValue();
+        t.initCause(e);
+        throw t;
+      }
+  }
+
+  /** @inheritDoc */
+  public DynAny get_boxed_value_as_dyn_any()
+                                    throws InvalidValue
+  {
+    if (is_null())
+      throw new InvalidValue(ISNULL);
+    else
+      return array [ 0 ].copy();
+  }
+
+  /** {@inheritDoc} */
+  public Serializable get_val()
+                       throws TypeMismatch, InvalidValue
+  {
+    return to_any().extract_Value();
+  }
+
+  /** {@inheritDoc} */
+  public void insert_val(Serializable a_x)
+                  throws InvalidValue, TypeMismatch
+  {
+    Any a = to_any();
+    a.insert_Value(a_x);
+    from_any(a);
+    valueChanged();
+  }
+
+  /** @inheritDoc */
+  public boolean is_null()
+  {
+    return array.length == 0;
+  }
+
+  /** @inheritDoc */
+  public void set_boxed_value(Any boxIt)
+                       throws TypeMismatch
+  {
+    if (!content.equal(boxIt.type()))
+      throw new TypeMismatch(CONTENT);
+    try
+      {
+        if (is_null())
+          {
+            array = new DynAny[] { factory.create_dyn_any(boxIt) };
+          }
+        else
+          {
+            array [ 0 ].from_any(boxIt);
+          }
+      }
+    catch (Exception e)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(e);
+        throw t;
+      }
+    valueChanged();
+  }
+
+  /** @inheritDoc */
+  public void set_boxed_value_as_dyn_any(DynAny boxIt)
+                                  throws TypeMismatch
+  {
+    if (!content.equal(boxIt.type()))
+      throw new TypeMismatch(CONTENT);
+    try
+      {
+        if (is_null())
+          {
+            array = new DynAny[] { boxIt.copy() };
+          }
+        else
+          {
+            array [ 0 ].assign(boxIt);
+          }
+      }
+    catch (Exception e)
+      {
+        TypeMismatch t = new TypeMismatch();
+        t.initCause(e);
+        throw t;
+      }
+    valueChanged();
+  }
+
+  /** @inheritDoc */
+  public void set_to_null()
+  {
+    array = new DynAny[ 0 ];
+    valueChanged();
+  }
+
+  /** @inheritDoc */
+  public void set_to_value()
+  {
+    try
+      {
+        if (array.length == 0)
+          {
+            array =
+              new DynAny[] { factory.create_dyn_any_from_type_code(content) };
+          }
+      }
+    catch (InconsistentTypeCode e)
+      {
+        throw new Unexpected(e);
+      }
+    valueChanged();
+  }
+
+  /** @inheritDoc */
+  public Any to_any()
+  {
+    Any a = createAny();
+
+    if (!is_null())
+      {
+        try
+          {
+            Streamable holder;
+            if (array [ 0 ] instanceof gnuDynAny)
+              holder = ((gnuDynAny) array [ 0 ]).holder;
+            else
+              {
+                Any uan = array [ 0 ].to_any();
+                holder = uan.extract_Streamable();
+              }
+
+            Field v = holder.getClass().getField("value");
+            Serializable value = (Serializable) v.get(holder);
+            a.type(official_type);
+            a.insert_Value(value, content);
+          }
+        catch (Exception ex)
+          {
+            throw new Unexpected(ex);
+          }
+      }
+    else
+      a.type(orb.get_primitive_tc(TCKind.tk_null));
+    return a;
+  }
+}