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

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

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

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

1 files changed, 590 insertions, 0 deletions

diff --git a/libjava/classpath/gnu/CORBA/ObjectCreator.java b/libjava/classpath/gnu/CORBA/ObjectCreator.java
new file mode 100644
index 000000000..292495a1f
--- /dev/null
+++ b/libjava/classpath/gnu/CORBA/ObjectCreator.java
@@ -0,0 +1,590 @@
+/* ObjectCreator.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;
+
+import gnu.CORBA.CDR.UnknownExceptionCtxHandler;
+import gnu.CORBA.CDR.BufferredCdrInput;
+import gnu.CORBA.CDR.BufferedCdrOutput;
+import gnu.CORBA.CDR.AbstractCdrInput;
+import gnu.CORBA.GIOP.ServiceContext;
+import gnu.CORBA.typecodes.RecordTypeCode;
+import gnu.classpath.VMStackWalker;
+
+import org.omg.CORBA.Any;
+import org.omg.CORBA.CompletionStatus;
+import org.omg.CORBA.CompletionStatusHelper;
+import org.omg.CORBA.MARSHAL;
+import org.omg.CORBA.SystemException;
+import org.omg.CORBA.TCKind;
+import org.omg.CORBA.UNKNOWN;
+import org.omg.CORBA.UserException;
+import org.omg.CORBA.portable.IDLEntity;
+import org.omg.CORBA.portable.InputStream;
+import org.omg.CORBA.portable.OutputStream;
+import org.omg.CORBA.portable.ValueBase;
+
+import java.lang.reflect.Method;
+import java.util.Map;
+import java.util.WeakHashMap;
+
+import javax.rmi.CORBA.Util;
+
+/**
+ * Creates java objects from the agreed IDL names for the simple case when the
+ * CORBA object is directly mapped into the locally defined java class.
+ *
+ * @author Audrius Meskauskas (AudriusA@Bioinformatics.org)
+ */
+public class ObjectCreator
+{
+  /**
+   * The standard OMG prefix.
+   */
+  public static final String OMG_PREFIX = "omg.org/";
+
+  /**
+   * The standard java prefix.
+   */
+  public static final String JAVA_PREFIX = "org.omg.";
+
+  /**
+   * The prefix for classes that are placed instide the gnu.CORBA namespace.
+   */
+  public static final String CLASSPATH_PREFIX = "gnu.CORBA.";
+
+  /**
+   * Maps classes to they IDL or RMI names. Computing RMI name is an expensive
+   * operations, so frequently used RMI keys are reused. The map must be weak to
+   * ensure that the class can be unloaded, when applicable.
+   */
+  public static Map m_names = new WeakHashMap();
+
+  /**
+   * Maps IDL strings into known classes. The map must be weak to ensure that
+   * the class can be unloaded, when applicable.
+   */
+  public static Map m_classes = new WeakHashMap();
+
+  /**
+   * Maps IDL types to they helpers.
+   */
+  public static Map m_helpers = new WeakHashMap();
+
+  /**
+   * Try to instantiate an object with the given IDL name. The object must be
+   * mapped to the local java class. The omg.org domain must be mapped into the
+   * object in either org/omg or gnu/CORBA namespace.
+   *
+   * @param idl name
+   * @return instantiated object instance or null if no such available.
+   */
+  public static java.lang.Object createObject(String idl, String suffix)
+  {
+    synchronized (m_classes)
+      {
+        Class known = (Class) (suffix == null ? m_classes.get(idl)
+          : m_classes.get(idl + 0xff + suffix));
+        Object object;
+
+        if (known != null)
+          {
+            try
+              {
+                return known.newInstance();
+              }
+            catch (Exception ex)
+              {
+                RuntimeException rex = new RuntimeException(idl + " suffix "
+                  + suffix, ex);
+                throw rex;
+              }
+          }
+        else
+          {
+            if (suffix == null)
+              suffix = "";
+            try
+              {
+                known = forName(toClassName(JAVA_PREFIX, idl) + suffix);
+                object = known.newInstance();
+              }
+            catch (Exception ex)
+              {
+                try
+                  {
+                    known = forName(toClassName(CLASSPATH_PREFIX, idl)
+                      + suffix);
+                    object = known.newInstance();
+                  }
+                catch (Exception exex)
+                  {
+                    return null;
+                  }
+              }
+            m_classes.put(idl + 0xff + suffix, known);
+            return object;
+          }
+      }
+  }
+
+  /**
+   * Read the system exception from the given stream.
+   *
+   * @param input the CDR stream to read from.
+   * @param contexts the service contexts in request/reply header/
+   *
+   * @return the exception that has been stored in the stream (IDL name, minor
+   * code and completion status).
+   */
+  public static SystemException readSystemException(InputStream input,
+    ServiceContext[] contexts)
+  {
+    SystemException exception;
+
+    String idl = input.read_string();
+    int minor = input.read_ulong();
+    CompletionStatus completed = CompletionStatusHelper.read(input);
+
+    try
+      {
+        exception = (SystemException) createObject(idl, null);
+        exception.minor = minor;
+        exception.completed = completed;
+      }
+    catch (Exception ex)
+      {
+        UNKNOWN u = new UNKNOWN("Unsupported system exception " + idl, minor,
+          completed);
+        u.initCause(ex);
+        throw u;
+      }
+
+    try
+      {
+        // If UnknownExceptionInfo is present in the contexts, read it and
+        // set as a cause of this exception.
+        ServiceContext uEx = ServiceContext.find(
+          ServiceContext.UnknownExceptionInfo, contexts);
+
+        if (uEx != null)
+          {
+            BufferredCdrInput in = new BufferredCdrInput(uEx.context_data);
+            in.setOrb(in.orb());
+            if (input instanceof AbstractCdrInput)
+              {
+                ((AbstractCdrInput) input).cloneSettings(in);
+              }
+
+            Throwable t = UnknownExceptionCtxHandler.read(in, contexts);
+            exception.initCause(t);
+          }
+      }
+    catch (Exception ex)
+      {
+        // Unsupported context format. Do not terminate as the user program may
+        // not need it.
+      }
+
+    return exception;
+  }
+
+  /**
+   * Reads the user exception, having the given Id, from the input stream. The
+   * id is expected to be in the form like
+   * 'IDL:test/org/omg/CORBA/ORB/communication/ourUserException:1.0'
+   *
+   * @param idl the exception idl name.
+   * @param input the stream to read from.
+   *
+   * @return the loaded exception.
+   * @return null if the helper class cannot be found.
+   */
+  public static UserException readUserException(String idl, InputStream input)
+  {
+    try
+      {
+        Class helperClass = findHelper(idl);
+
+        Method read = helperClass.getMethod("read",
+          new Class[] { org.omg.CORBA.portable.InputStream.class });
+
+        return (UserException) read.invoke(null, new Object[] { input });
+      }
+    catch (MARSHAL mex)
+      {
+        // This one is ok to throw
+        throw mex;
+      }
+    catch (Exception ex)
+      {
+        ex.printStackTrace();
+        return null;
+      }
+  }
+
+  /**
+   * Gets the helper class name from the string like
+   * 'IDL:test/org/omg/CORBA/ORB/communication/ourUserException:1.0'
+   *
+   * @param IDL the idl name.
+   */
+  public static String toHelperName(String IDL)
+  {
+    String s = IDL;
+    int a = s.indexOf(':') + 1;
+    int b = s.lastIndexOf(':');
+
+    s = IDL.substring(a, b);
+
+    if (s.startsWith(OMG_PREFIX))
+      s = JAVA_PREFIX + s.substring(OMG_PREFIX.length());
+
+    return s.replace('/', '.') + "Helper";
+  }
+
+  /**
+   * Writes the system exception data to CDR output stream.
+   *
+   * @param output a stream to write data to.
+   * @param ex an exception to write.
+   */
+  public static void writeSystemException(OutputStream output,
+    SystemException ex)
+  {
+    String exIDL = getRepositoryId(ex.getClass());
+    output.write_string(exIDL);
+    output.write_ulong(ex.minor);
+    CompletionStatusHelper.write(output, ex.completed);
+  }
+
+  /**
+   * Converts the given IDL name to class name.
+   *
+   * @param IDL the idl name.
+   *
+   */
+  protected static String toClassName(String prefix, String IDL)
+  {
+    String s = IDL;
+    int a = s.indexOf(':') + 1;
+    int b = s.lastIndexOf(':');
+
+    s = IDL.substring(a, b);
+
+    if (s.startsWith(OMG_PREFIX))
+      s = prefix + s.substring(OMG_PREFIX.length());
+
+    return s.replace('/', '.');
+  }
+
+  /**
+   * Converts the given IDL name to class name and tries to load the matching
+   * class. The OMG prefix (omg.org) is replaced by the java prefix org.omg. No
+   * other prefixes are added.
+   *
+   * @param IDL the idl name.
+   *
+   * @return the matching class or null if no such is available.
+   */
+  public static Class Idl2class(String IDL)
+  {
+    synchronized (m_classes)
+      {
+        Class c = (Class) m_classes.get(IDL);
+
+        if (c != null)
+          return c;
+        else
+          {
+            String s = IDL;
+            int a = s.indexOf(':') + 1;
+            int b = s.lastIndexOf(':');
+
+            s = IDL.substring(a, b);
+
+            if (s.startsWith(OMG_PREFIX))
+              s = JAVA_PREFIX + s.substring(OMG_PREFIX.length());
+
+            String cn = s.replace('/', '.');
+
+            try
+              {
+                c = forName(cn);
+                m_classes.put(IDL, c);
+                return c;
+              }
+            catch (ClassNotFoundException ex)
+              {
+                return null;
+              }
+          }
+      }
+  }
+
+  /**
+   * Converts the given IDL name to class name, tries to load the matching class
+   * and create an object instance with parameterless constructor. The OMG
+   * prefix (omg.org) is replaced by the java prefix org.omg. No other prefixes
+   * are added.
+   *
+   * @param IDL the idl name.
+   *
+   * @return instantiated object instance or null if such attempt was not
+   * successful.
+   */
+  public static java.lang.Object Idl2Object(String IDL)
+  {
+    Class cx = Idl2class(IDL);
+
+    try
+      {
+        if (cx != null)
+          return cx.newInstance();
+        else
+          return null;
+      }
+    catch (Exception ex)
+      {
+        return null;
+      }
+  }
+
+  /**
+   * Convert the class name to IDL or RMI name (repository id). If the class
+   * inherits from IDLEntity, ValueBase or SystemException, returns repository
+   * Id in the IDL:(..) form. If it does not, returns repository Id in the
+   * RMI:(..) form.
+   *
+   * @param cx the class for that the name must be computed.
+   *
+   * @return the idl or rmi name.
+   */
+  public static synchronized String getRepositoryId(Class cx)
+  {
+    String name = (String) m_names.get(cx);
+    if (name != null)
+      return name;
+
+    String cn = cx.getName();
+    if (!(IDLEntity.class.isAssignableFrom(cx)
+      || ValueBase.class.isAssignableFrom(cx) || SystemException.class.isAssignableFrom(cx)))
+      {
+        // Not an IDL entity.
+        name = Util.createValueHandler().getRMIRepositoryID(cx);
+      }
+    else
+      {
+        if (cn.startsWith(JAVA_PREFIX))
+          cn = OMG_PREFIX
+            + cn.substring(JAVA_PREFIX.length()).replace('.', '/');
+        else if (cn.startsWith(CLASSPATH_PREFIX))
+          cn = OMG_PREFIX
+            + cn.substring(CLASSPATH_PREFIX.length()).replace('.', '/');
+
+        name = "IDL:" + cn + ":1.0";
+      }
+    m_names.put(cx, name);
+    return name;
+  }
+
+  /**
+   * Insert the passed parameter into the given Any, assuming that the helper
+   * class is available. The helper class must have the "Helper" suffix and be
+   * in the same package as the class of the object being inserted.
+   *
+   * @param into the target to insert.
+   *
+   * @param object the object to insert. It can be any object as far as the
+   * corresponding helper is provided.
+   *
+   * @return true on success, false otherwise.
+   */
+  public static boolean insertWithHelper(Any into, Object object)
+  {
+    try
+      {
+        String helperClassName = object.getClass().getName() + "Helper";
+        Class helperClass = forName(helperClassName);
+
+        Method insert = helperClass.getMethod("insert", new Class[] {
+          Any.class, object.getClass() });
+
+        insert.invoke(null, new Object[] { into, object });
+
+        return true;
+      }
+    catch (Exception exc)
+      {
+        // Failed due some reason.
+        return false;
+      }
+  }
+
+  /**
+   * Insert the system exception into the given Any.
+   */
+  public static boolean insertSysException(Any into, SystemException exception)
+  {
+    try
+      {
+        BufferedCdrOutput output = new BufferedCdrOutput();
+
+        String m_exception_id = getRepositoryId(exception.getClass());
+        output.write_string(m_exception_id);
+        output.write_ulong(exception.minor);
+        CompletionStatusHelper.write(output, exception.completed);
+
+        String name = getDefaultName(m_exception_id);
+
+        GeneralHolder h = new GeneralHolder(output);
+
+        into.insert_Streamable(h);
+
+        RecordTypeCode r = new RecordTypeCode(TCKind.tk_except);
+        r.setId(m_exception_id);
+        r.setName(name);
+        into.type(r);
+
+        return true;
+      }
+    catch (Exception ex)
+      {
+        ex.printStackTrace();
+        return false;
+      }
+  }
+
+  /**
+   * Get the type name from the IDL string.
+   */
+  public static String getDefaultName(String idl)
+  {
+    int f1 = idl.lastIndexOf("/");
+    int p1 = (f1 < 0) ? 0 : f1;
+    int p2 = idl.indexOf(":", p1);
+    if (p2 < 0)
+      p2 = idl.length();
+
+    String name = idl.substring(f1 + 1, p2);
+    return name;
+  }
+
+  /**
+   * Insert this exception into the given Any. On failure, insert the UNKNOWN
+   * exception.
+   */
+  public static void insertException(Any into, Throwable exception)
+  {
+    boolean ok = false;
+    if (exception instanceof SystemException)
+      ok = insertSysException(into, (SystemException) exception);
+    else if (exception instanceof UserException)
+      ok = insertWithHelper(into, exception);
+
+    if (!ok)
+      ok = insertSysException(into, new UNKNOWN());
+    if (!ok)
+      throw new InternalError("Exception wrapping broken");
+  }
+
+  /**
+   * Find helper for the class with the given name.
+   */
+  public static Class findHelper(String idl)
+  {
+    synchronized (m_helpers)
+      {
+        Class c = (Class) m_helpers.get(idl);
+        if (c != null)
+          return c;
+        try
+          {
+            String helper = toHelperName(idl);
+            c = forName(helper);
+
+            m_helpers.put(idl, c);
+            return c;
+          }
+        catch (Exception ex)
+          {
+            return null;
+          }
+      }
+  }
+
+  /**
+   * Load the class with the given name. This method tries to use the context
+   * class loader first. If this fails, it searches for the suitable class
+   * loader in the caller stack trace. This method is a central point where all
+   * requests to find a class by name are delegated.
+   */
+  public static Class forName(String className) throws ClassNotFoundException
+  {
+    try
+      {
+        return Class.forName(className, true,
+                             Thread.currentThread().getContextClassLoader());
+      }
+    catch (ClassNotFoundException nex)
+      {
+        /**
+         * Returns the first user defined class loader on the call stack, or
+         * null when no non-null class loader was found.
+         */
+        Class[] ctx = VMStackWalker.getClassContext();
+        for (int i = 0; i < ctx.length; i++)
+          {
+            // Since we live in a class loaded by the bootstrap
+            // class loader, getClassLoader is safe to call without
+            // needing to be wrapped in a privileged action.
+            ClassLoader cl = ctx[i].getClassLoader();
+            try
+              {
+                if (cl != null)
+                  return Class.forName(className, true, cl);
+              }
+            catch (ClassNotFoundException nex2)
+              {
+                // Try next.
+              }
+          }
+      }
+    throw new ClassNotFoundException(className);
+  }
+}