Makefile.def: Remove libjava.

2016-09-30  Andrew Haley  <aph@redhat.com>

	* Makefile.def: Remove libjava.
	* Makefile.tpl: Likewise.
	* Makefile.in: Regenerate.
	* configure.ac: Likewise.
	* configure: Likewise.
	* gcc/java: Remove.
	* libjava: Likewise.

From-SVN: r240662

1 files changed, 0 insertions, 433 deletions

diff --git a/libjava/classpath/java/beans/Encoder.java b/libjava/classpath/java/beans/Encoder.java
deleted file mode 100644
index b3d232a..0000000
--- a/libjava/classpath/java/beans/Encoder.java
+++ /dev/null
@@ -1,433 +0,0 @@
-/* Encoder.java
- Copyright (C) 2005, 2006 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 java.beans;
-
-import gnu.java.beans.DefaultExceptionListener;
-import gnu.java.beans.encoder.ArrayPersistenceDelegate;
-import gnu.java.beans.encoder.ClassPersistenceDelegate;
-import gnu.java.beans.encoder.CollectionPersistenceDelegate;
-import gnu.java.beans.encoder.MapPersistenceDelegate;
-import gnu.java.beans.encoder.PrimitivePersistenceDelegate;
-
-import java.util.AbstractCollection;
-import java.util.HashMap;
-import java.util.IdentityHashMap;
-
-/**
- * @author Robert Schuster (robertschuster@fsfe.org)
- * @since 1.4
- */
-public class Encoder
-{
-
-  /**
-   * An internal DefaultPersistenceDelegate instance that is used for every
-   * class that does not a have a special special PersistenceDelegate.
-   */
-  private static PersistenceDelegate defaultPersistenceDelegate;
-
-  private static PersistenceDelegate fakePersistenceDelegate;
-
-  /**
-   * Stores the relation Class->PersistenceDelegate.
-   */
-  private static HashMap delegates = new HashMap();
-
-  /**
-   * Stores the relation oldInstance->newInstance
-   */
-  private IdentityHashMap candidates = new IdentityHashMap();
-
-  private ExceptionListener exceptionListener;
-
-  /**
-   * A simple number that is used to restrict the access to writeExpression and
-   * writeStatement. The rule is that both methods should only be used when an
-   * object is written to the stream (= writeObject). Therefore accessCounter is
-   * incremented just before the call to writeObject and decremented afterwards.
-   * Then writeStatement and writeExpression allow execution only if
-   * accessCounter is bigger than zero.
-   */
-  private int accessCounter = 0;
-
-  public Encoder()
-  {
-    setupDefaultPersistenceDelegates();
-
-    setExceptionListener(null);
-  }
-
-  /**
-   * Sets up a bunch of {@link PersistenceDelegate} instances which are needed
-   * for the basic working of a {@link Encoder}s.
-   */
-  private static void setupDefaultPersistenceDelegates()
-  {
-    synchronized (delegates)
-      {
-        if (defaultPersistenceDelegate != null)
-          return;
-
-        delegates.put(Class.class, new ClassPersistenceDelegate());
-
-        PersistenceDelegate pd = new PrimitivePersistenceDelegate();
-        delegates.put(Boolean.class, pd);
-        delegates.put(Byte.class, pd);
-        delegates.put(Short.class, pd);
-        delegates.put(Integer.class, pd);
-        delegates.put(Long.class, pd);
-        delegates.put(Float.class, pd);
-        delegates.put(Double.class, pd);
-
-        delegates.put(Object[].class, new ArrayPersistenceDelegate());
-
-        pd = new CollectionPersistenceDelegate();
-        delegates.put(AbstractCollection.class, pd);
-
-        pd = new MapPersistenceDelegate();
-        delegates.put(java.util.AbstractMap.class, pd);
-        delegates.put(java.util.Hashtable.class, pd);
-
-        defaultPersistenceDelegate = new DefaultPersistenceDelegate();
-        delegates.put(Object.class, defaultPersistenceDelegate);
-
-        // Creates a PersistenceDelegate implementation which is
-        // returned for 'null'. In practice this instance is
-        // not used in any way and is just here to be compatible
-        // with the reference implementation which returns a
-        // similar instance when calling getPersistenceDelegate(null) .
-        fakePersistenceDelegate = new PersistenceDelegate()
-        {
-          protected Expression instantiate(Object o, Encoder e)
-          {
-            return null;
-          }
-        };
-
-      }
-  }
-
-  protected void writeObject(Object o)
-  {
-    // 'null' has no PersistenceDelegate and will not
-    // create an Expression which has to be cloned.
-    // However subclasses should be aware that writeObject
-    // may be called with a 'null' argument and should
-    // write the proper representation of it.
-    if (o == null)
-      return;
-
-    PersistenceDelegate pd = getPersistenceDelegate(o.getClass());
-
-    accessCounter++;
-    pd.writeObject(o, this);
-    accessCounter--;
-
-  }
-
-  /**
-   * Sets the {@link ExceptionListener} instance to be used for reporting
-   * recorable exceptions in the instantiation and initialization sequence. If
-   * the argument is <code>null</code> a default instance will be used that
-   * prints the thrown exception to <code>System.err</code>.
-   */
-  public void setExceptionListener(ExceptionListener listener)
-  {
-    exceptionListener = (listener != null)
-        ? listener : DefaultExceptionListener.INSTANCE;
-  }
-
-  /**
-   * Returns the currently active {@link ExceptionListener} instance.
-   */
-  public ExceptionListener getExceptionListener()
-  {
-    return exceptionListener;
-  }
-
-  public PersistenceDelegate getPersistenceDelegate(Class<?> type)
-  {
-    // This is not specified but the JDK behaves like this.
-    if (type == null)
-      return fakePersistenceDelegate;
-
-    // Treats all array classes in the same way and assigns
-    // them a shared PersistenceDelegate implementation tailored
-    // for array instantation and initialization.
-    if (type.isArray())
-      return (PersistenceDelegate) delegates.get(Object[].class);
-
-    PersistenceDelegate pd = (PersistenceDelegate) delegates.get(type);
-
-    return (pd != null) ? pd : defaultPersistenceDelegate;
-  }
-
-  /**
-   * Sets the {@link PersistenceDelegate} instance for the given class.
-   * <p>
-   * Note: Throws a <code>NullPointerException</code> if the argument is
-   * <code>null</code>.
-   * </p>
-   * <p>
-   * Note: Silently ignores PersistenceDelegates for Array types and primitive
-   * wrapper classes.
-   * </p>
-   * <p>
-   * Note: Although this method is not declared <code>static</code> changes to
-   * the {@link PersistenceDelegate}s affect <strong>all</strong>
-   * {@link Encoder} instances. <strong>In this implementation</strong> the
-   * access is thread safe.
-   * </p>
-   */
-  public void setPersistenceDelegate(Class<?> type,
-                                     PersistenceDelegate delegate)
-  {
-    // If the argument is null this will cause a NullPointerException
-    // which is expected behavior.
-
-    // This makes custom PDs for array, primitive types and their wrappers
-    // impossible but this is how the JDK behaves.
-    if (type.isArray() || type.isPrimitive() || type == Boolean.class
-        || type == Byte.class || type == Short.class || type == Integer.class
-        || type == Long.class || type == Float.class || type == Double.class)
-      return;
-
-    synchronized (delegates)
-      {
-        delegates.put(type, delegate);
-      }
-
-  }
-
-  public Object remove(Object oldInstance)
-  {
-    return candidates.remove(oldInstance);
-  }
-
-  /**
-   * Returns the replacement object which has been created by the encoder during
-   * the instantiation sequence or <code>null</code> if the object has not
-   * been processed yet.
-   * <p>
-   * Note: The <code>String</code> class acts as an endpoint for the
-   * inherently recursive algorithm of the {@link Encoder}. Therefore instances
-   * of <code>String</code> will always be returned by this method. In other
-   * words the assertion: <code>
-   * assert (anyEncoder.get(anyString) == anyString)
-   * </code<
-   * will always hold.</p>
-   *
-   * <p>Note: If <code>null</code> is requested, the result will
-   * always be <code>null</code>.</p>
-   */
-  public Object get(Object oldInstance)
-  {
-    // String instances are handled in a special way.
-    // No one knows why this is not officially specified
-    // because this is a rather important design decision.
-    return (oldInstance == null) ? null :
-             (oldInstance.getClass() == String.class) ?
-               oldInstance : candidates.get(oldInstance);
-  }
-
-  /**
-   * <p>
-   * Note: If you call this method not from within an object instantiation and
-   * initialization sequence it will be silently ignored.
-   * </p>
-   */
-  public void writeStatement(Statement stmt)
-  {
-    // Silently ignore out of bounds calls.
-    if (accessCounter <= 0)
-      return;
-
-    Object target = stmt.getTarget();
-
-    Object newTarget = get(target);
-    if (newTarget == null)
-      {
-        writeObject(target);
-        newTarget = get(target);
-      }
-
-    Object[] args = stmt.getArguments();
-    Object[] newArgs = new Object[args.length];
-
-    for (int i = 0; i < args.length; i++)
-      {
-        newArgs[i] = get(args[i]);
-        if (newArgs[i] == null || isImmutableType(args[i].getClass()))
-          {
-            writeObject(args[i]);
-            newArgs[i] = get(args[i]);
-          }
-      }
-
-    Statement newStmt = new Statement(newTarget, stmt.getMethodName(), newArgs);
-
-    try
-      {
-        newStmt.execute();
-      }
-    catch (Exception e)
-      {
-        exceptionListener.exceptionThrown(e);
-      }
-
-  }
-
-  /**
-   * <p>
-   * Note: If you call this method not from within an object instantiation and
-   * initialization sequence it will be silently ignored.
-   * </p>
-   */
-  public void writeExpression(Expression expr)
-  {
-    // Silently ignore out of bounds calls.
-    if (accessCounter <= 0)
-      return;
-
-    Object target = expr.getTarget();
-    Object value = null;
-    Object newValue = null;
-
-    try
-      {
-        value = expr.getValue();
-      }
-    catch (Exception e)
-      {
-        exceptionListener.exceptionThrown(e);
-        return;
-      }
-
-
-    newValue = get(value);
-
-    if (newValue == null)
-      {
-        Object newTarget = get(target);
-        if (newTarget == null)
-          {
-            writeObject(target);
-            newTarget = get(target);
-
-            // May happen if exception was thrown.
-            if (newTarget == null)
-              {
-                return;
-              }
-          }
-
-        Object[] args = expr.getArguments();
-        Object[] newArgs = new Object[args.length];
-
-        for (int i = 0; i < args.length; i++)
-          {
-            newArgs[i] = get(args[i]);
-            if (newArgs[i] == null || isImmutableType(args[i].getClass()))
-              {
-                writeObject(args[i]);
-                newArgs[i] = get(args[i]);
-              }
-          }
-
-        Expression newExpr = new Expression(newTarget, expr.getMethodName(),
-                                            newArgs);
-
-        // Fakes the result of Class.forName(<primitiveType>) to make it possible
-        // to hand such a type to the encoding process.
-        if (value instanceof Class && ((Class) value).isPrimitive())
-          newExpr.setValue(value);
-
-        // Instantiates the new object.
-        try
-          {
-            newValue = newExpr.getValue();
-
-            candidates.put(value, newValue);
-          }
-        catch (Exception e)
-          {
-            exceptionListener.exceptionThrown(e);
-
-            return;
-          }
-
-        writeObject(value);
-
-      }
-    else if(value.getClass() == String.class || value.getClass() == Class.class)
-      {
-        writeObject(value);
-      }
-
-  }
-
-  /** Returns whether the given class is an immutable
-   * type which has to be handled differently when serializing it.
-   *
-   * <p>Immutable objects always have to be instantiated instead of
-   * modifying an existing instance.</p>
-   *
-   * @param type The class to test.
-   * @return Whether the first argument is an immutable type.
-   */
-  boolean isImmutableType(Class type)
-  {
-    return type == String.class || type == Class.class
-      || type == Integer.class || type == Boolean.class
-      || type == Byte.class || type == Short.class
-      || type == Long.class || type == Float.class
-      || type == Double.class;
-  }
-
-  /** Sets the stream candidate for a given object.
-   *
-   * @param oldObject The object given to the encoder.
-   * @param newObject The object the encoder generated.
-   */
-  void putCandidate(Object oldObject, Object newObject)
-  {
-    candidates.put(oldObject, newObject);
-  }
-
-}