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, 825 insertions, 0 deletions

diff --git a/libjava/classpath/gnu/CORBA/Poa/gnuServantObject.java b/libjava/classpath/gnu/CORBA/Poa/gnuServantObject.java
new file mode 100644
index 000000000..17ef452a7
--- /dev/null
+++ b/libjava/classpath/gnu/CORBA/Poa/gnuServantObject.java
@@ -0,0 +1,825 @@
+/* gnuServantObject.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.Poa;
+
+import gnu.CORBA.GIOP.ReplyHeader;
+import gnu.CORBA.IorDelegate;
+import gnu.CORBA.IorObject;
+import gnu.CORBA.Interceptor.gnuServerRequestInfo;
+import gnu.CORBA.typecodes.RecordTypeCode;
+import gnu.CORBA.IOR;
+import gnu.CORBA.IorProvider;
+import gnu.CORBA.Minor;
+import gnu.CORBA.ObjectCreator;
+import gnu.CORBA.Unexpected;
+import gnu.CORBA.ResponseHandlerImpl;
+import gnu.CORBA.StreamHolder;
+
+import gnu.java.lang.CPStringBuilder;
+
+import org.omg.CORBA.Any;
+import org.omg.CORBA.BAD_OPERATION;
+import org.omg.CORBA.BAD_PARAM;
+import org.omg.CORBA.CompletionStatus;
+import org.omg.CORBA.OBJECT_NOT_EXIST;
+import org.omg.CORBA.OBJ_ADAPTER;
+import org.omg.CORBA.ORB;
+import org.omg.CORBA.SystemException;
+import org.omg.CORBA.TCKind;
+import org.omg.CORBA.TRANSIENT;
+import org.omg.CORBA.UserException;
+import org.omg.CORBA.portable.InputStream;
+import org.omg.CORBA.portable.InvokeHandler;
+import org.omg.CORBA.portable.ObjectImpl;
+import org.omg.CORBA.portable.OutputStream;
+import org.omg.CORBA.portable.ResponseHandler;
+import org.omg.PortableInterceptor.ForwardRequest;
+import org.omg.PortableInterceptor.ServerRequestInterceptorOperations;
+import org.omg.PortableServer.CurrentOperations;
+import org.omg.PortableServer.DynamicImplementation;
+import org.omg.PortableServer.ImplicitActivationPolicyValue;
+import org.omg.PortableServer.POA;
+import org.omg.PortableServer.POAManager;
+import org.omg.PortableServer.POAManagerPackage.State;
+import org.omg.PortableServer.Servant;
+import org.omg.PortableServer.ServantLocatorPackage.CookieHolder;
+import org.omg.PortableServer.ServantRetentionPolicyValue;
+import org.omg.PortableServer.portable.Delegate;
+
+import java.io.IOException;
+
+import java.util.Arrays;
+
+/**
+ * Represents a CORBA object, being locally served by the associated servant.
+ * The calls to the object are forwarded to the calls to the servant.
+ *
+ * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org)
+ */
+public class gnuServantObject extends ObjectImpl
+  implements org.omg.CORBA.Object,
+    InvokeHandler,
+    CurrentOperations,
+    IorProvider
+{
+  /**
+   * The associated servant that must also implement the {@link InvokeHandler}
+       * interface. This value can be temporary null if the object was created using
+   * POA.create_reference or POA.create_reference_with_id, private to force
+   * always to use {@link setServant}.
+   */
+  private Servant servant;
+
+  /**
+   * The Id of this object.
+   */
+  public final byte[] Id;
+
+  /**
+   * The poa that takes care about this object.
+   */
+  public final gnuPOA poa;
+
+  /**
+   * The POA manager, used to control the work of this object.
+   */
+  public final POAManager manager;
+
+  /**
+   * The orb.
+   */
+  public final ORB_1_4 orb;
+
+  /**
+   * The object repository ids, if they were specified separately. Normally, the
+   * ids are requested from the servant.
+   */
+  public final String[] repository_ids;
+
+  /**
+   * True indicates that the NO_RETAIN policy applies for the servant.
+   * The servant must be discarded after the each call.
+   */
+  boolean noRetain;
+
+  /**
+   * Create an object with no connected servant. The servant must be set later.
+   *
+   * @param a_repository_ids an array of repository ids, can be null (then ids
+   * will be requested from the servant).
+   * @param an_id the object id.
+   * @param a_poa the POA.
+   */
+  public gnuServantObject(String[] a_repository_ids, byte[] an_id,
+    gnuPOA a_poa, ORB_1_4 an_orb
+  )
+  {
+    repository_ids = a_repository_ids;
+    Id = an_id;
+    manager = a_poa.the_POAManager();
+    poa = a_poa;
+    orb = an_orb;
+
+    noRetain = poa.applies(ServantRetentionPolicyValue.NON_RETAIN);
+  }
+
+  /**
+   * Get the IOR as it would be for this object.
+   */
+  public IOR getIor()
+  {
+    return orb.getLocalIor(this);
+  }
+
+  /**
+   * Create a servant object, associated with the passed servant.
+   *
+   * @param a_servant a servant, serving this object.
+   * @param an_id an Object Id for this object.
+   *
+   * @throws BAD_PARAM if the passed servant is not an {@link InvokeHandler}.
+   */
+  public gnuServantObject(Servant a_servant, byte[] an_id, ORB_1_4 an_orb,
+    gnuPOA a_poa
+  )
+  {
+    Id = an_id;
+    setServant(a_servant);
+    poa = a_poa;
+    if (poa != null)
+      {
+        manager = poa.the_POAManager();
+      }
+    else
+      {
+        manager = null;
+      }
+    repository_ids = null;
+    orb = an_orb;
+
+    noRetain = poa != null && poa.applies(ServantRetentionPolicyValue.NON_RETAIN);
+  }
+
+  /**
+   * Set a servant, if it has not been previously set.
+   *
+   * @param a_servant a servant to set, can be null to indicate the necessity
+   * for the subsequent activation.
+   *
+   * @throws BAD_PARAM if the passed servant is not an {@link InvokeHandler} or
+   * {@link DynamicImplementation} and also not null.
+   */
+  public void setServant(Servant a_servant)
+  {
+    if (a_servant != null &&
+      !(a_servant instanceof InvokeHandler) &&
+      !(a_servant instanceof DynamicImplementation)
+    )
+      {
+        throw new BAD_PARAM("Must be either InvokeHandler or " +
+          "DynamicImplementation, but is " + a_servant
+        );
+      }
+    servant = a_servant;
+  }
+
+  /**
+   * Returns the associated servant.
+   */
+  public Servant getServant()
+  {
+    return servant;
+  }
+
+  /**
+   * Return the associated invocation handler.
+   */
+  public InvokeHandler getHandler(String operation, CookieHolder cookie,
+    boolean forwarding_allowed
+  ) throws gnuForwardRequest
+  {
+    if (servant != null && !noRetain)
+      {
+        return servantToHandler(servant);
+      }
+    else
+      {
+        // Use servant locator to locate the servant.
+        if (poa.servant_locator != null)
+          {
+            try
+              {
+                servant =
+                  poa.servant_locator.preinvoke(Id, poa, operation, cookie);
+                return servantToHandler(servant);
+              }
+            catch (org.omg.PortableServer.ForwardRequest forw_ex)
+              {
+                if (forwarding_allowed)
+                  {
+                    throw new gnuForwardRequest(forw_ex.forward_reference);
+                  }
+                else
+                  {
+                    servant =
+                      ForwardedServant.create(forw_ex.forward_reference);
+                    return servantToHandler(servant);
+                  }
+              }
+          }
+        else
+        // Use servant activator to locate the servant.
+        if (poa.applies(ImplicitActivationPolicyValue.IMPLICIT_ACTIVATION) &&
+          poa.applies(ServantRetentionPolicyValue.RETAIN)
+        )
+          {
+            try
+              {
+                poa.activate_object_with_id(Id, servant, forwarding_allowed);
+                servant = poa.id_to_servant(Id);
+                return servantToHandler(servant);
+              }
+            catch (gnuForwardRequest forwarded)
+              {
+                throw forwarded;
+              }
+            catch (Exception ex)
+              {
+                BAD_OPERATION bad =
+                  new BAD_OPERATION("Unable to activate", Minor.Activation,
+                    CompletionStatus.COMPLETED_NO
+                  );
+                bad.initCause(ex);
+                throw bad;
+              }
+          }
+        else if (poa.default_servant != null)
+          {
+            servant = poa.default_servant;
+            return servantToHandler(servant);
+          }
+
+        // No servant and no servant manager - throw exception.
+        else
+          {
+            throw new BAD_OPERATION("Unable to activate", Minor.Activation,
+              CompletionStatus.COMPLETED_NO
+            );
+          }
+      }
+  }
+
+  /**
+   * Convert the servant to invocation handler.
+   */
+  public InvokeHandler servantToHandler(Servant a_servant)
+  {
+    if (a_servant instanceof InvokeHandler)
+      {
+        return (InvokeHandler) a_servant;
+      }
+    else if (a_servant instanceof DynamicImplementation)
+      {
+        return new DynamicImpHandler((DynamicImplementation) a_servant);
+      }
+    else
+      {
+        throw new BAD_OPERATION(a_servant +
+          " must be either InvokeHandler or " + "POA DynamicImplementation"
+        );
+      }
+  }
+
+  /**
+   * Create a servant object, associated with the passed servant. Requests the
+   * object id from the servant. Depending on the policies of the servants POA,
+   * the calls are eithe not synchronized or synchronized on POA or ORB.
+   *
+   * @param a_servant a servant, serving this object.
+   * @param an_id an Object Id for this object.
+   */
+  public gnuServantObject(Servant a_servant, gnuPOA a_poa)
+  {
+    this(a_servant, a_servant._object_id(), (ORB_1_4) a_servant._orb(), a_poa);
+  }
+
+  /**
+   * Delegates call to servant, passing the poa and Id.
+   */
+  public String[] _ids()
+  {
+    if (repository_ids == null)
+      {
+        return getServant()._all_interfaces(poa, Id);
+      }
+    else
+      {
+        return repository_ids;
+      }
+  }
+
+  /**
+   * Gets a string representation.
+   */
+  public String toString()
+  {
+    CPStringBuilder b = new CPStringBuilder("Servant object (");
+    for (int i = 0; i < Id.length; i++)
+      {
+        b.append(Integer.toHexString(Id [ i ] & 0xFF));
+        b.append(' ');
+      }
+    b.append(')');
+    return b.toString();
+  }
+
+  /**
+   * Always returns true.
+   */
+  public boolean _is_local()
+  {
+    return true;
+  }
+
+  /**
+   * Check if this object could be named by the given repository id.
+   *
+   * @param idl_id the repository id to check.
+   *
+   * @return true if it is one of the possible repository ids of this object.
+   */
+  public boolean _is_a(String idl_id)
+  {
+    String[] maybe = _ids();
+    for (int i = 0; i < maybe.length; i++)
+      {
+        if (maybe [ i ].equals(idl_id))
+          {
+            return true;
+          }
+      }
+    return false;
+  }
+
+  /**
+   * Get an ORB, associated with the servant of this object.
+   *
+   * @return
+   */
+  public ORB _orb()
+  {
+    return getServant()._orb();
+  }
+
+  /**
+   * Handle the invocation (delegates to servant).
+   *
+   * @throws TRANSIENT minor 0x535503e9 if the POA is in discarding mode.
+   * @throws OBJ_ADAPTER minor 0x535503ea if the POA is inactivated.
+   * @throws OBJECT_NOT_EXISTS minor 0x535503ec if this object is inactivated.
+   *
+   * @specnote see {@link POAManagerOperations} for specnotes about the minor
+   * codes.
+   */
+  public OutputStream _invoke(String method, InputStream input,
+    ResponseHandler r_handler
+  ) throws SystemException
+  {
+    boolean intercept = false;
+    ServerRequestInterceptorOperations interceptor = null;
+    gnuServerRequestInfo info = null;
+    ResponseHandlerImpl i_handler = null;
+
+    try
+      {
+        if (orb.iServer != null &&
+          r_handler instanceof ResponseHandlerImpl
+        )
+          {
+            interceptor = orb.iServer;
+
+            i_handler = (ResponseHandlerImpl) r_handler;
+
+            info =
+              new gnuServerRequestInfo(this, i_handler.request_header,
+                i_handler.reply_header
+              );
+            intercept = true;
+
+            interceptor.receive_request_service_contexts(info);
+          }
+
+        try
+          {
+            CookieHolder cookie = null;
+            AOM.Obj self = poa.aom.get(Id);
+
+            if (poa.servant_locator != null)
+              {
+                // If the servant locator is in use, it is always responsible
+                // for providing the servant.
+                self.servant = servant = null;
+                cookie = new CookieHolder();
+              }
+            else if (self != null && self.isDeactiveted())
+              {
+                if (poa.applies(
+                    ImplicitActivationPolicyValue.IMPLICIT_ACTIVATION
+                  ) &&
+                  poa.servant_activator != null
+                )
+                  {
+                    // Reset the servant, forcing the subsequent activation.
+                    servant = null;
+                  }
+                else
+                  {
+                    throw new OBJECT_NOT_EXIST("Object deactivated",
+                      0x535503ec, CompletionStatus.COMPLETED_NO
+                    );
+                  }
+              }
+
+            InvokeHandler handler = getHandler(method, cookie, true);
+
+            Delegate d = null;
+
+            try
+              {
+                d = servant._get_delegate();
+                orb.currents.put(Thread.currentThread(), this);
+              }
+            catch (Exception ex)
+              {
+                // In some cases exception is thrown if the delegate is not set.
+              }
+            if (d instanceof ServantDelegateImpl)
+              {
+                // If the delegate is already set, check maybe we can
+                // reuse the existing instance.
+                if (((ServantDelegateImpl) d).object != this)
+                  {
+                    servant._set_delegate(new ServantDelegateImpl(servant, poa, Id));
+                  }
+              }
+            else
+              {
+                servant._set_delegate(new ServantDelegateImpl(servant, poa, Id));
+              }
+
+            try
+              {
+                switch (manager.get_state().value())
+                  {
+                    case State._ACTIVE :
+
+                      OutputStream rt;
+                      try
+                        {
+                          if (intercept)
+                            {
+                              interceptor.receive_request(info);
+                            }
+
+                          rt = handler._invoke(method, input, r_handler);
+
+                          if (intercept)
+                            {
+                              // Handler is casted into i_handler.
+                              if (i_handler.isExceptionReply())
+                                {
+                                  info.m_reply_header.reply_status =
+                                    ReplyHeader.USER_EXCEPTION;
+
+                                  // Make Any, holding the user exception.
+                                  Any a = orb.create_any();
+                                  OutputStream buf = i_handler.getBuffer();
+                                  InputStream in = buf.create_input_stream();
+                                  String uex_idl = "unknown";
+                                  try
+                                    {
+                                      in.mark(Integer.MAX_VALUE);
+                                      uex_idl = in.read_string();
+                                      in.reset();
+                                    }
+                                  catch (IOException e)
+                                    {
+                                      throw new Unexpected(e);
+                                    }
+
+                                  try
+                                    {
+                                      UserException exception =
+                                        ObjectCreator.readUserException(uex_idl,
+                                          in
+                                        );
+
+                                      ObjectCreator.insertWithHelper(a,
+                                        exception
+                                      );
+                                    }
+                                  catch (Exception e)
+                                    {
+                                      // Failed due any reason, insert without
+                                      // helper.
+                                      a.insert_Streamable(new StreamHolder(
+                                          buf.create_input_stream()
+                                        )
+                                      );
+
+                                      RecordTypeCode r =
+                                        new RecordTypeCode(TCKind.tk_except);
+                                      r.setId(uex_idl);
+                                      r.setName(ObjectCreator.getDefaultName(
+                                          uex_idl
+                                        )
+                                      );
+                                    }
+
+                                  info.m_usr_exception = a;
+                                  interceptor.send_exception(info);
+                                }
+                              else
+                                {
+                                  info.m_reply_header.reply_status =
+                                    ReplyHeader.NO_EXCEPTION;
+                                  interceptor.send_reply(info);
+                                }
+                            }
+                        }
+                      catch (SystemException sys_ex)
+                        {
+                          if (intercept)
+                            {
+                              info.m_reply_header.reply_status =
+                                ReplyHeader.SYSTEM_EXCEPTION;
+                              info.m_sys_exception = sys_ex;
+                              interceptor.send_exception(info);
+                            }
+                          throw sys_ex;
+                        }
+
+                      return rt;
+
+                    case State._HOLDING :
+
+                      // The holding mode is implemented
+                      // relying on the holding capabilites of the network
+                      // support (if any).
+                      // TODO FIXME in more recent CORBA applications, the
+                      // client
+                      // ORB can free the connection and wait for a server side
+                      // notification about the completed request. Implement
+                      // this
+                      // as soon as JDK specification would allow bidirectional
+                      // policy.
+                      int sleep = 5;
+                      int max = 500;
+
+                      // Wait till the state will be switched into some other
+                      // mode.
+                      while (manager.get_state().value() == State._HOLDING)
+                        {
+                          try
+                            {
+                              Thread.sleep(sleep);
+                              if (sleep < max)
+                                {
+                                  sleep = max;
+                                }
+                            }
+                          catch (InterruptedException ex)
+                            {
+                            }
+                        }
+
+                      // Handle another mode.
+                      return _invoke(method, input, r_handler);
+
+                    case State._DISCARDING :
+                      throw new TRANSIENT("Discarding mode", 0x535503e9,
+                        CompletionStatus.COMPLETED_NO
+                      );
+
+                    case State._INACTIVE :
+                      throw new OBJ_ADAPTER("POA deactivated", 0x535503ea,
+                        CompletionStatus.COMPLETED_NO
+                      );
+
+                    default :
+                      throw new InternalError(); // No more states.
+                  }
+              }
+            finally
+              {
+                if (poa.servant_locator != null)
+                  {
+                    poa.servant_locator.postinvoke(Id, poa, method,
+                      cookie.value, servant
+                    );
+                  }
+              }
+          }
+        finally
+          {
+            orb.currents.remove(Thread.currentThread());
+            if (noRetain)
+              servant = null;
+          }
+      }
+    catch (ForwardRequest fex)
+      {
+        // May be thrown by interceptor.
+        if (intercept)
+          {
+            Forwarding:
+            while (true)
+              {
+                info.m_reply_header.reply_status =
+                  ReplyHeader.LOCATION_FORWARD;
+                info.m_forward_reference = fex.forward;
+                try
+                  {
+                    interceptor.send_other(info);
+                    break Forwarding;
+                  }
+                catch (ForwardRequest fex2)
+                  {
+                    info.m_forward_reference = fex2.forward;
+                    fex.forward = info.m_forward_reference;
+                  }
+              }
+          }
+        throw new gnuForwardRequest(fex.forward);
+      }
+    catch (gnuForwardRequest fex)
+      {
+        // May be thrown during activation.
+        if (intercept)
+          {
+            Forwarding:
+            while (true)
+              {
+                info.m_reply_header.reply_status =
+                  ReplyHeader.LOCATION_FORWARD;
+                info.m_forward_reference = fex.forward_reference;
+                try
+                  {
+                    interceptor.send_other(info);
+                    break Forwarding;
+                  }
+                catch (ForwardRequest fex2)
+                  {
+                    info.m_forward_reference = fex2.forward;
+                    fex.forward_reference = (ObjectImpl) fex2.forward;
+                  }
+              }
+          }
+        throw fex;
+      }
+  }
+
+  /**
+   * Compare with another object for equality, comparing the object keys.
+   */
+  public boolean equals(java.lang.Object other)
+  {
+    if (other instanceof gnuServantObject)
+      {
+        gnuServantObject o = (gnuServantObject) other;
+
+        return Arrays.equals(o.Id, Id);
+      }
+    else
+      {
+        return false;
+      }
+  }
+
+  /**
+   * Get the hash code, based on the object key.
+   */
+  public int hashCode()
+  {
+    long s = 0;
+    int v = 1;
+    for (int i = 0; i < Id.length; i++)
+      {
+        s += Id [ i ] * v;
+        if (s > Integer.MAX_VALUE)
+          {
+            s = s % Integer.MAX_VALUE;
+            v = 1;
+          }
+        v = v * 8;
+      }
+    return (int) (s % Integer.MAX_VALUE);
+  }
+
+  /**
+   * Get the object id.
+   */
+  public byte[] get_object_id()
+  {
+    return Id;
+  }
+
+  /**
+   * Get POA.
+   */
+  public POA get_POA()
+  {
+    return poa;
+  }
+
+  /**
+   * Returns without action.
+   */
+  public void _release()
+  {
+  }
+
+  /**
+   * Returns without action.
+   */
+  public void _releaseReply(InputStream stream)
+  {
+  }
+
+  /**
+   * Checks if this object is equivalent to another instance. These objects are
+   * assumed equal if they are connected to the same orb and poa under the same
+   * Id, regardless of they delegates.
+   *
+   * @param other instance to check.
+   * @return
+   */
+  public boolean _is_equivalent(org.omg.CORBA.Object other)
+  {
+    if (other instanceof gnuServantObject)
+      {
+        gnuServantObject g = (gnuServantObject) other;
+        return orb == g.orb && poa == g.poa && Arrays.equals(Id, g.Id);
+      }
+    else if (other instanceof IorObject)
+      {
+        IorObject ir = ((IorObject) other);
+        try
+          {
+            IorDelegate ird = (IorDelegate) ir._get_delegate();
+            byte[] ior_id = poa.idFormIor(ird.getIor().key);
+            if (ior_id != null && Arrays.equals(ior_id, Id))
+              {
+                return true;
+              }
+            else
+              {
+                return false;
+              }
+          }
+        catch (Exception ex)
+          {
+            // Non - typical delegate or very specific subclass of
+            // IOR_constructed_object.
+            return super._is_equivalent(other);
+          }
+      }
+    return super._is_equivalent(other);
+  }
+}