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

diff --git a/libjava/classpath/gnu/javax/management/Translator.java b/libjava/classpath/gnu/javax/management/Translator.java
new file mode 100644
index 000000000..38d575aca
--- /dev/null
+++ b/libjava/classpath/gnu/javax/management/Translator.java
@@ -0,0 +1,550 @@
+/* Translator.java -- Performs MXBean data type translation.
+   Copyright (C) 2007 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.javax.management;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Proxy;
+import java.lang.reflect.Type;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.SortedMap;
+import java.util.SortedSet;
+
+import javax.management.JMX;
+import javax.management.MBeanServerInvocationHandler;
+
+import javax.management.openmbean.ArrayType;
+import javax.management.openmbean.CompositeData;
+import javax.management.openmbean.CompositeDataSupport;
+import javax.management.openmbean.CompositeType;
+import javax.management.openmbean.OpenDataException;
+import javax.management.openmbean.OpenMBeanParameterInfo;
+import javax.management.openmbean.OpenMBeanParameterInfoSupport;
+import javax.management.openmbean.OpenType;
+import javax.management.openmbean.SimpleType;
+import javax.management.openmbean.TabularData;
+import javax.management.openmbean.TabularDataSupport;
+import javax.management.openmbean.TabularType;
+
+/**
+ * Translates Java data types to their equivalent
+ * open data type, and vice versa, according to the
+ * {@link javax.management.MXBean} rules.
+ *
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ */
+public final class Translator
+{
+
+  /**
+   * Translates the input Java data types to the equivalent
+   * open data types.
+   *
+   * @param jtypes the Java types supplied as parameters.
+   * @param method the method that was called.
+   * @return the equivalent open types required by the {@link MXBean}.
+   * @throws Throwable if an exception is thrown in performing the
+   *                   conversion.
+   */
+  public static final Object[] fromJava(Object[] jtypes, Method method)
+    throws Throwable
+  {
+    Type[] gtypes = method.getGenericParameterTypes();
+    Object[] otypes = new Object[jtypes.length];
+    for (int a = 0; a < jtypes.length; ++a)
+      otypes[a] = fromJava(jtypes[a], gtypes[a]);
+    return otypes;
+  }
+
+  /**
+   * Translates the input Java data type to the equivalent
+   * open data type.
+   *
+   * @param jtype the Java type supplied as a parameter.
+   * @param type the type of the parameter.
+   * @return the equivalent open type required by the {@link MXBean}.
+   * @throws Throwable if an exception is thrown in performing the
+   *                   conversion.
+   */
+  public static final Object fromJava(Object jtype, Type type)
+    throws Throwable
+  {
+    if (jtype == null)
+      return null;
+    Class<?> jclass = jtype.getClass();
+    if (OpenType.ALLOWED_CLASSNAMES_LIST.contains(jclass.getName()))
+      return jtype;
+    if (jclass.isArray())
+      {
+        Class<?> ctype = jclass.getComponentType();
+        if (ctype.isPrimitive())
+          return jtype;
+        if (OpenType.ALLOWED_CLASSNAMES_LIST.contains(ctype.getName()))
+          return jtype;
+        Object[] elems = (Object[]) jtype;
+        Object[] celems = new Object[elems.length];
+        for (int a = 0; a < elems.length; ++a)
+          celems[a] = fromJava(elems[a], elems[a].getClass());
+        return makeArraySpecific(celems);
+      }
+    String tName = getTypeName(type);
+    if (jtype instanceof List || jtype instanceof Set ||
+        jtype instanceof SortedSet)
+      {
+        if (jtype instanceof SortedSet)
+          {
+            ParameterizedType ptype = (ParameterizedType) type;
+            Class<?> elemClass = (Class<?>) ptype.getActualTypeArguments()[0];
+            if (!Comparable.class.isAssignableFrom(elemClass))
+              throw new IllegalArgumentException(jtype + " has a " +
+                                                 "non-comparable element " +
+                                                 "type, " + elemClass);
+            if (((SortedSet<?>) jtype).comparator() != null)
+              throw new IllegalArgumentException(jtype + " does not " +
+                                                 "use natural ordering.");
+          }
+        Collection<?> elems = (Collection<?>) jtype;
+        int numElems = elems.size();
+        Object[] celems = new Object[numElems];
+        Iterator<?> i = elems.iterator();
+        for (int a = 0; a < numElems; ++a)
+          {
+            Object elem = i.next();
+            celems[a] = fromJava(elem, elem.getClass());
+          }
+        return makeArraySpecific(celems);
+      }
+    if (jtype instanceof Enum)
+      return ((Enum<?>) jtype).name();
+    if (jtype instanceof Map || jtype instanceof SortedMap)
+      {
+        int lparam = tName.indexOf("<");
+        int comma = tName.indexOf(",", lparam);
+        int rparam = tName.indexOf(">", comma);
+        String key = tName.substring(lparam + 1, comma).trim();
+        String value = tName.substring(comma + 1, rparam).trim();
+        String typeName = null;
+        if (jtype instanceof Map)
+          typeName = "java.util.Map" + tName.substring(lparam);
+        else
+          {
+            Class<?> keyClass = Class.forName(key);
+            if (!Comparable.class.isAssignableFrom(keyClass))
+              throw new IllegalArgumentException(jtype + " has a " +
+                                                 "non-comparable element " +
+                                                 "type, " + keyClass);
+            if (((SortedMap<?,?>) jtype).comparator() != null)
+              throw new IllegalArgumentException(jtype + " does not " +
+                                                 "use natural ordering.");
+            typeName = "java.util.SortedMap" + tName.substring(lparam);
+          }
+        OpenType<?> k = translate(key).getOpenType();
+        OpenType<?> v = translate(value).getOpenType();
+        CompositeType rowType = new CompositeType(typeName, typeName,
+                                                  new String[] { "key", "value" },
+                                                  new String[] { "Map key", "Map value"},
+                                                  new OpenType[] {k,v});
+        TabularType tabType = new TabularType(typeName, typeName, rowType,
+                                              new String[]{"key"});
+        TabularData data = new TabularDataSupport(tabType);
+        for (Map.Entry<?,?> entry : ((Map<?,?>) jtype).entrySet())
+          {
+            try
+              {
+                data.put(new CompositeDataSupport(rowType,
+                                                  new String[] {
+                                                    "key",
+                                                    "value"
+                                                  },
+                                                  new Object[] {
+                                                    entry.getKey(),
+                                                    entry.getValue()
+                                                  }));
+              }
+            catch (OpenDataException e)
+              {
+                throw (InternalError) (new InternalError("A problem occurred " +
+                                                         "converting the map " +
+                                                         "to a composite data " +
+                                                         "structure.").initCause(e));
+              }
+          }
+        return data;
+      }
+    if (JMX.isMXBeanInterface(jclass))
+      {
+        try
+          {
+            MBeanServerInvocationHandler ih = (MBeanServerInvocationHandler)
+              Proxy.getInvocationHandler(jtype);
+            return ih.getObjectName();
+          }
+        catch (IllegalArgumentException e)
+          {
+            throw new IllegalArgumentException("For a MXBean to be translated " +
+                                               "to an open type, it must be a " +
+                                               "proxy.", e);
+          }
+        catch (ClassCastException e)
+          {
+            throw new IllegalArgumentException("For a MXBean to be translated " +
+                                               "to an open type, it must have a " +
+                                               "MBeanServerInvocationHandler.", e);
+          }
+      }
+    /* FIXME: Handle other types */
+    throw new IllegalArgumentException("The type, " + jtype +
+                                       ", is not convertible.");
+  }
+
+  /**
+   * Translates the returned open data type to the value
+   * required by the interface.
+   *
+   * @param otype the open type returned by the method call.
+   * @param method the method that was called.
+   * @return the equivalent return type required by the interface.
+   * @throws Throwable if an exception is thrown in performing the
+   *                   conversion.
+   */
+  public static final Object toJava(Object otype, Method method)
+    throws Throwable
+  {
+    Class<?> returnType = method.getReturnType();
+    if (returnType.isEnum())
+      {
+        String ename = (String) otype;
+        Enum<?>[] constants = (Enum[]) returnType.getEnumConstants();
+        for (Enum<?> c : constants)
+          if (c.name().equals(ename))
+            return c;
+      }
+    if (List.class.isAssignableFrom(returnType))
+      {
+        Object[] elems = (Object[]) otype;
+        List<Object> l = new ArrayList<Object>(elems.length);
+        for (Object elem : elems)
+          l.add(elem);
+        return l;
+      }
+    if (Map.class.isAssignableFrom(returnType))
+      {
+        TabularData data = (TabularData) otype;
+        Map<Object,Object> m = new HashMap<Object,Object>(data.size());
+        for (Object val : data.values())
+          {
+            CompositeData vals = (CompositeData) val;
+            m.put(vals.get("key"), vals.get("value"));
+          }
+        return m;
+      }
+    try
+      {
+        Method m = returnType.getMethod("from",
+                                        new Class[]
+          { CompositeData.class });
+        return m.invoke(null, (CompositeData) otype);
+      }
+    catch (NoSuchMethodException e)
+      {
+        /* Ignored; we expect this if this
+           isn't a from(CompositeData) class */
+      }
+    return otype;
+  }
+
+  /**
+   * Creates a new array which has the specific type
+   * used by the elements of the original {@link Object}
+   * array supplied.
+   *
+   * @param arr a series of elements in an {@link Object}
+   *            array.
+   * @return the same elements in a new array of the specific
+   *         type.
+   */
+  private static final Object[] makeArraySpecific(Object[] arr)
+  {
+    Object[] rcelems = (Object[]) Array.newInstance(arr[0].getClass(),
+                                                    arr.length);
+    System.arraycopy(arr, 0, rcelems, 0, arr.length);
+    return rcelems;
+  }
+
+  /**
+   * Translates the name of a type into an equivalent
+   * {@link javax.management.openmbean.OpenMBeanParameterInfo}
+   * that describes it.
+   *
+   * @param type the type to describe.
+   * @return an instance of
+   * {@link javax.management.openmbean.OpenMBeanParameterInfo},
+   * describing the translated type and limits of the given type.
+   * @throws OpenDataException if a type is not open.
+   */
+  public static final OpenMBeanParameterInfo translate(String type)
+    throws OpenDataException
+  {
+    if (type.equals("boolean") || type.equals(Boolean.class.getName()))
+      return new OpenMBeanParameterInfoSupport("TransParam",
+                                               "Translated parameter",
+                                               SimpleType.BOOLEAN,
+                                               null,
+                                               new Boolean[] {
+                                                 Boolean.TRUE,
+                                                 Boolean.FALSE
+                                               });
+    if (type.equals("byte") || type.equals(Byte.class.getName()))
+      return new OpenMBeanParameterInfoSupport("TransParam",
+                                               "Translated parameter",
+                                               SimpleType.BYTE,
+                                               null,
+                                               Byte.valueOf(Byte.MIN_VALUE),
+                                               Byte.valueOf(Byte.MAX_VALUE));
+    if (type.equals("char") || type.equals(Character.class.getName()))
+      return new OpenMBeanParameterInfoSupport("TransParam",
+                                               "Translated parameter",
+                                               SimpleType.CHARACTER,
+                                               null,
+                                               Character.valueOf(Character.MIN_VALUE),
+                                               Character.valueOf(Character.MAX_VALUE));
+    if (type.equals("double") || type.equals(Double.class.getName()))
+      return new OpenMBeanParameterInfoSupport("TransParam",
+                                               "Translated parameter",
+                                               SimpleType.DOUBLE,
+                                               null,
+                                               Double.valueOf(Double.MIN_VALUE),
+                                               Double.valueOf(Double.MAX_VALUE));
+    if (type.equals("float") || type.equals(Float.class.getName()))
+      return new OpenMBeanParameterInfoSupport("TransParam",
+                                               "Translated parameter",
+                                               SimpleType.FLOAT,
+                                               null,
+                                               Float.valueOf(Float.MIN_VALUE),
+                                               Float.valueOf(Float.MAX_VALUE));
+    if (type.equals("int") || type.equals(Integer.class.getName()))
+      return new OpenMBeanParameterInfoSupport("TransParam",
+                                               "Translated parameter",
+                                               SimpleType.INTEGER,
+                                               null,
+                                               Integer.valueOf(Integer.MIN_VALUE),
+                                               Integer.valueOf(Integer.MAX_VALUE));
+    if (type.equals("long") || type.equals(Long.class.getName()))
+      return new OpenMBeanParameterInfoSupport("TransParam",
+                                               "Translated parameter",
+                                               SimpleType.LONG,
+                                               null,
+                                               Long.valueOf(Long.MIN_VALUE),
+                                               Long.valueOf(Long.MAX_VALUE));
+    if (type.equals("short") || type.equals(Short.class.getName()))
+      return new OpenMBeanParameterInfoSupport("TransParam",
+                                               "Translated parameter",
+                                               SimpleType.SHORT,
+                                               null,
+                                               Short.valueOf(Short.MIN_VALUE),
+                                               Short.valueOf(Short.MAX_VALUE));
+    if (type.equals(String.class.getName()))
+      return new OpenMBeanParameterInfoSupport("TransParam",
+                                               "Translated parameter",
+                                               SimpleType.STRING);
+    if (type.equals("void"))
+      return new OpenMBeanParameterInfoSupport("TransParam",
+                                               "Translated parameter",
+                                               SimpleType.VOID);
+    if (type.startsWith("java.util.Map"))
+      {
+        int lparam = type.indexOf("<");
+        int comma = type.indexOf(",", lparam);
+        int rparam = type.indexOf(">", comma);
+        String key = type.substring(lparam + 1, comma).trim();
+        OpenType<?> k = translate(key).getOpenType();
+        OpenType<?> v = translate(type.substring(comma + 1, rparam).trim()).getOpenType();
+        CompositeType ctype = new CompositeType(Map.class.getName(), Map.class.getName(),
+                                                new String[] { "key", "value" },
+                                                new String[] { "Map key", "Map value"},
+                                                new OpenType[] { k, v});
+        TabularType ttype = new TabularType(key, key, ctype,
+                                            new String[] { "key" });
+        return new OpenMBeanParameterInfoSupport("TransParam",
+                                                 "Translated parameter",
+                                                 ttype);
+      }
+    if (type.startsWith("java.util.List"))
+      {
+        int lparam = type.indexOf("<");
+        int rparam = type.indexOf(">");
+        OpenType<?> e = translate(type.substring(lparam + 1, rparam).trim()).getOpenType();
+        return new OpenMBeanParameterInfoSupport("TransParam",
+                                                 "Translated parameter",
+                                                 new ArrayType<OpenType<?>>(1, e)
+                                                 );
+      }
+    Class<?> c;
+    try
+      {
+        c = Class.forName(type);
+      }
+    catch (ClassNotFoundException e)
+      {
+        throw (InternalError)
+          (new InternalError("The class for a type used in a management bean " +
+                             "could not be loaded.").initCause(e));
+      }
+    if (c.isEnum())
+      {
+        Object[] values = c.getEnumConstants();
+        String[] names = new String[values.length];
+        for (int a = 0; a < values.length; ++a)
+          names[a] = values[a].toString();
+        return new OpenMBeanParameterInfoSupport("TransParam",
+                                                 "Translated parameter",
+                                                 SimpleType.STRING,
+                                                 null, names);
+      }
+    if (c.isArray())
+      {
+        int depth;
+        for (depth = 0; c.getName().charAt(depth) == '['; ++depth)
+          ;
+        OpenType<?> ot = getTypeFromClass(c.getComponentType());
+        return new OpenMBeanParameterInfoSupport("TransParam",
+                                                 "Translated parameter",
+                                                 new ArrayType<OpenType<?>>(depth, ot)
+                                                 );
+      }
+    Method[] methods = c.getDeclaredMethods();
+    List<String> names = new ArrayList<String>();
+    List<OpenType<?>> types = new ArrayList<OpenType<?>>();
+    for (int a = 0; a < methods.length; ++a)
+      {
+        String name = methods[a].getName();
+        if (Modifier.isPublic(methods[a].getModifiers()))
+          {
+            if (name.startsWith("get"))
+              {
+                names.add(name.substring(3));
+                types.add(getTypeFromClass(methods[a].getReturnType()));
+              }
+            else if (name.startsWith("is"))
+              {
+                names.add(name.substring(2));
+                types.add(getTypeFromClass(methods[a].getReturnType()));
+              }
+          }
+      }
+    if (names.isEmpty())
+      throw new OpenDataException("The type used does not have an open type translation.");
+    String[] fields = names.toArray(new String[names.size()]);
+    CompositeType ctype = new CompositeType(c.getName(), c.getName(),
+                                            fields, fields,
+                                            types.toArray(new OpenType[types.size()]));
+    return new OpenMBeanParameterInfoSupport("TransParam",
+                                             "Translated parameter",
+                                             ctype);
+  }
+
+  /**
+   * Obtains the {@link javax.management.openmbean.OpenType}
+   * for a particular class.
+   *
+   * @param c the class to obtain the type for.
+   * @return the appropriate instance.
+   * @throws OpenDataException if the type is not open.
+   */
+  private static final OpenType<?> getTypeFromClass(Class<?> c)
+    throws OpenDataException
+  {
+    return Translator.translate(c.getName()).getOpenType();
+  }
+
+  /**
+   * <p>
+   * Returns the type name according to the rules described
+   * in {@link javax.management.MXBean}.  Namely, for a type,
+   * {@code T}, {@code typename(T)} is computed as follows:
+   * </p>
+   * <ul>
+   * <li>If T is non-generic and not an array, then the value
+   * of {@link java.lang.Class#getName()} is returned.</li>
+   * <li>If T is an array type, {@code{E[]}, then the type name
+   * is {@code typename(E)} followed by an occurrence
+   * of {@code '[]'} for each dimension.</li>
+   * <li>If T is a generic or parameterized type, the type name
+   * is composed of {@code typename(P)}, where {@code P} is the
+   * parameterized type name, followed by {@code '<'}, the resulting
+   * list of type names of the parameters after applying {@code typename}
+   * to each, separated by commas, and {@code '>'}.</li>
+   * </ul>
+   *
+   * @param type the type to return the type name of.
+   * @return the type name computed according to the rules above.
+   */
+  private static final String getTypeName(Type type)
+  {
+    if (type instanceof Class)
+      {
+        Class<?> c = (Class<?>) type;
+        if (c.isArray())
+          {
+            StringBuilder b =
+              new StringBuilder(c.getComponentType().getName());
+            String normName = c.getName();
+            for (int a = 0; a < normName.length(); ++a)
+              {
+                if (normName.charAt(a) == '[')
+                  b.append("[]");
+                else
+                  break;
+              }
+            return b.toString();
+          }
+        return c.getName();
+      }
+    return type.toString();
+  }
+
+}