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

diff --git a/libjava/java/lang/reflect/natArray.cc b/libjava/java/lang/reflect/natArray.cc
new file mode 100644
index 000000000..b7bc8beff
--- /dev/null
+++ b/libjava/java/lang/reflect/natArray.cc
@@ -0,0 +1,360 @@
+// natField.cc - Implementation of java.lang.reflect.Field native methods.
+
+/* Copyright (C) 1999, 2000, 2001, 2003  Free Software Foundation
+
+   This file is part of libgcj.
+
+This software is copyrighted work licensed under the terms of the
+Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
+details.  */
+
+#include <config.h>
+
+#include <stdlib.h>
+
+#include <jvm.h>
+#include <gcj/cni.h>
+#include <java-stack.h>
+#include <java/lang/reflect/Array.h>
+#include <java/lang/ArrayIndexOutOfBoundsException.h>
+#include <java/lang/IllegalArgumentException.h>
+#include <java/lang/Byte.h>
+#include <java/lang/Short.h>
+#include <java/lang/Integer.h>
+#include <java/lang/Long.h>
+#include <java/lang/Float.h>
+#include <java/lang/Double.h>
+#include <java/lang/Boolean.h>
+#include <java/lang/Character.h>
+
+jobject
+java::lang::reflect::Array::newInstance (jclass componentType, jint length)
+{
+  if (componentType->isPrimitive())
+    {
+      // We could check for this in _Jv_NewPrimArray, but that seems
+      // like needless overhead when the only real route to this
+      // problem is here.
+      if (componentType == JvPrimClass (void))
+	throw new java::lang::IllegalArgumentException ();
+      return _Jv_NewPrimArray (componentType, length);
+    }
+  else
+    // FIXME: class loader?
+    return JvNewObjectArray (length, componentType, NULL);
+}
+
+jobject
+java::lang::reflect::Array::newInstance (jclass componentType,
+					 jintArray dimensions)
+{
+  jint ndims = dimensions->length;
+  if (ndims == 0)
+    throw new java::lang::IllegalArgumentException ();
+  jint* dims = elements (dimensions);
+  if (ndims == 1)
+    return newInstance (componentType, dims[0]);
+
+  Class *caller = _Jv_StackTrace::GetCallingClass (&Array::class$);
+  ClassLoader *caller_loader = NULL;
+  if (caller)
+    caller_loader = caller->getClassLoaderInternal();
+
+  jclass arrayType = componentType;
+  for (int i = 0;  i < ndims;  i++)
+    arrayType = _Jv_GetArrayClass (arrayType, caller_loader);
+
+  return _Jv_NewMultiArray (arrayType, ndims, dims);
+}
+
+jint
+java::lang::reflect::Array::getLength (jobject array)
+{
+  jclass arrayType = array->getClass();
+  if (! arrayType->isArray ())
+    throw new java::lang::IllegalArgumentException;
+  return ((__JArray*) array)->length;
+}
+
+jclass
+java::lang::reflect::Array::getElementType (jobject array, jint index)
+{
+  jclass arrayType = array->getClass();
+  if (! arrayType->isArray ())
+    throw new java::lang::IllegalArgumentException;
+  jint length = ((__JArray*) array)->length;
+  if ((_Jv_uint) index >= (_Jv_uint) length)
+    _Jv_ThrowBadArrayIndex(index);
+  return arrayType->getComponentType ();
+}
+
+jboolean
+java::lang::reflect::Array::getBoolean (jobject array, jint index)
+{
+  jclass elementType = getElementType (array, index);
+  if (elementType == JvPrimClass (boolean))
+    return elements ((jbooleanArray) array) [index];
+  throw new java::lang::IllegalArgumentException;
+}
+
+jchar
+java::lang::reflect::Array::getChar (jobject array, jint index)
+{
+  jclass elementType = getElementType (array, index);
+  if (elementType == JvPrimClass (char))
+    return elements ((jcharArray) array) [index];
+  throw new java::lang::IllegalArgumentException;
+}
+
+jbyte
+java::lang::reflect::Array::getByte (jobject array, jint index)
+{
+  jclass elementType = getElementType (array, index);
+  if (elementType == JvPrimClass (byte))
+    return elements ((jbyteArray) array) [index];
+  throw new java::lang::IllegalArgumentException;
+}
+
+jshort
+java::lang::reflect::Array::getShort (jobject array, jint index)
+{
+  jclass elementType = getElementType (array, index);
+  if (elementType == JvPrimClass (short))
+    return elements ((jshortArray) array) [index];
+  if (elementType == JvPrimClass (byte))
+    return elements ((jbyteArray) array) [index];
+  throw new java::lang::IllegalArgumentException;
+}
+
+jint
+java::lang::reflect::Array::getInt (jobject array, jint index)
+{
+  jclass elementType = getElementType (array, index);
+  if (elementType == JvPrimClass (int))
+    return elements ((jintArray) array) [index];
+  if (elementType == JvPrimClass (short))
+    return elements ((jshortArray) array) [index];
+  if (elementType == JvPrimClass (byte))
+    return elements ((jbyteArray) array) [index];
+  if (elementType == JvPrimClass (char))
+    return elements ((jcharArray) array) [index];
+  throw new java::lang::IllegalArgumentException;
+}
+
+jlong
+java::lang::reflect::Array::getLong (jobject array, jint index)
+{
+  jclass elementType = getElementType (array, index);
+  if (elementType == JvPrimClass (long))
+    return elements ((jlongArray) array) [index];
+  if (elementType == JvPrimClass (int))
+    return elements ((jintArray) array) [index];
+  if (elementType == JvPrimClass (short))
+    return elements ((jshortArray) array) [index];
+  if (elementType == JvPrimClass (byte))
+    return elements ((jbyteArray) array) [index];
+  if (elementType == JvPrimClass (char))
+    return elements ((jcharArray) array) [index];
+  throw new java::lang::IllegalArgumentException;
+}
+
+jfloat
+java::lang::reflect::Array::getFloat (jobject array, jint index)
+{
+  jclass elementType = getElementType (array, index);
+  if (elementType == JvPrimClass (float))
+    return elements ((jfloatArray) array) [index];
+  if (elementType == JvPrimClass (long))
+    return elements ((jlongArray) array) [index];
+  if (elementType == JvPrimClass (int))
+    return elements ((jintArray) array) [index];
+  if (elementType == JvPrimClass (short))
+    return elements ((jshortArray) array) [index];
+  if (elementType == JvPrimClass (byte))
+    return elements ((jbyteArray) array) [index];
+  if (elementType == JvPrimClass (char))
+    return elements ((jcharArray) array) [index];
+  throw new java::lang::IllegalArgumentException;
+}
+
+jdouble
+java::lang::reflect::Array::getDouble (jobject array, jint index)
+{
+  jclass elementType = getElementType (array, index);
+  if (elementType == JvPrimClass (double))
+    return elements ((jdoubleArray) array) [index];
+  if (elementType == JvPrimClass (float))
+    return elements ((jfloatArray) array) [index];
+  if (elementType == JvPrimClass (long))
+    return elements ((jlongArray) array) [index];
+  if (elementType == JvPrimClass (int))
+    return elements ((jintArray) array) [index];
+  if (elementType == JvPrimClass (short))
+    return elements ((jshortArray) array) [index];
+  if (elementType == JvPrimClass (byte))
+    return elements ((jbyteArray) array) [index];
+  if (elementType == JvPrimClass (char))
+    return elements ((jcharArray) array) [index];
+  throw new java::lang::IllegalArgumentException;
+}
+
+jobject
+java::lang::reflect::Array::get (jobject array, jint index)
+{
+  jclass elementType = getElementType (array, index);
+  if (! elementType->isPrimitive ())
+    return elements ((jobjectArray) array) [index];
+  if (elementType == JvPrimClass (double))
+    return new java::lang::Double (elements ((jdoubleArray) array) [index]);
+  if (elementType == JvPrimClass (float))
+    return new java::lang::Float (elements ((jfloatArray) array) [index]);
+  if (elementType == JvPrimClass (long))
+    return new java::lang::Long (elements ((jlongArray) array) [index]);
+  if (elementType == JvPrimClass (int))
+    return new java::lang::Integer (elements ((jintArray) array) [index]);
+  if (elementType == JvPrimClass (short))
+    return new java::lang::Short (elements ((jshortArray) array) [index]);
+  if (elementType == JvPrimClass (byte))
+    return new java::lang::Byte (elements ((jbyteArray) array) [index]);
+  if (elementType == JvPrimClass (char))
+    return new java::lang::Character (elements ((jcharArray) array) [index]);
+  if (elementType == JvPrimClass (boolean))
+    {
+      _Jv_InitClass (&java::lang::Boolean::class$);
+      if (elements ((jbooleanArray) array) [index])
+	return java::lang::Boolean::TRUE;
+      else
+	return java::lang::Boolean::FALSE;
+    }
+  throw new java::lang::IllegalArgumentException;
+}
+
+void
+java::lang::reflect::Array::setChar (jobject array, jint index, jchar value)
+{
+  jclass elementType = getElementType (array, index);
+  if (elementType == JvPrimClass (char))
+    elements ((jcharArray) array) [index] = value;
+  else if (elementType == JvPrimClass (int))
+    elements ((jintArray) array) [index] = value;
+  else if (elementType == JvPrimClass (long))
+    elements ((jlongArray) array) [index] = value;
+  else if (elementType == JvPrimClass (float))
+    elements ((jfloatArray) array) [index] = value;
+  else if (elementType == JvPrimClass (double))
+    elements ((jdoubleArray) array) [index] = value;
+  else
+    throw new java::lang::IllegalArgumentException;
+}
+
+void
+java::lang::reflect::Array::setByte (jobject array, jint index, jbyte value)
+{
+  jclass elementType = getElementType (array, index);
+  if (elementType == JvPrimClass (byte))
+    elements ((jbyteArray) array) [index] = value;
+  else if (elementType == JvPrimClass (short))
+    elements ((jshortArray) array) [index] = value;
+  else if (elementType == JvPrimClass (int))
+    elements ((jintArray) array) [index] = value;
+  else if (elementType == JvPrimClass (long))
+    elements ((jlongArray) array) [index] = value;
+  else if (elementType == JvPrimClass (float))
+    elements ((jfloatArray) array) [index] = value;
+  else if (elementType == JvPrimClass (double))
+    elements ((jdoubleArray) array) [index] = value;
+  else
+    throw new java::lang::IllegalArgumentException;
+}
+
+void
+java::lang::reflect::Array::setShort (jobject array, jint index, jshort value)
+{
+  jclass elementType = getElementType (array, index);
+  if (elementType == JvPrimClass (short))
+    elements ((jshortArray) array) [index] = value;
+  else if (elementType == JvPrimClass (int))
+    elements ((jintArray) array) [index] = value;
+  else if (elementType == JvPrimClass (long))
+    elements ((jlongArray) array) [index] = value;
+  else if (elementType == JvPrimClass (float))
+    elements ((jfloatArray) array) [index] = value;
+  else if (elementType == JvPrimClass (double))
+    elements ((jdoubleArray) array) [index] = value;
+  else
+    throw new java::lang::IllegalArgumentException;
+}
+
+void
+java::lang::reflect::Array::setInt (jobject array, jint index, jint value)
+{
+  jclass elementType = getElementType (array, index);
+  if (elementType == JvPrimClass (int))
+    elements ((jintArray) array) [index] = value;
+  else if (elementType == JvPrimClass (long))
+    elements ((jlongArray) array) [index] = value;
+  else if (elementType == JvPrimClass (float))
+    elements ((jfloatArray) array) [index] = value;
+  else if (elementType == JvPrimClass (double))
+    elements ((jdoubleArray) array) [index] = value;
+  else
+    throw new java::lang::IllegalArgumentException;
+}
+
+void
+java::lang::reflect::Array::setLong (jobject array, jint index, jlong value)
+{
+  jclass elementType = getElementType (array, index);
+  if (elementType == JvPrimClass (long))
+    elements ((jlongArray) array) [index] = value;
+  else if (elementType == JvPrimClass (float))
+    elements ((jfloatArray) array) [index] = value;
+  else if (elementType == JvPrimClass (double))
+    elements ((jdoubleArray) array) [index] = value;
+  else
+    throw new java::lang::IllegalArgumentException;
+}
+
+void
+java::lang::reflect::Array::setFloat (jobject array, jint index, jfloat value)
+{
+  jclass elementType = getElementType (array, index);
+  if (elementType == JvPrimClass (float))
+    elements ((jfloatArray) array) [index] = value;
+  else if (elementType == JvPrimClass (double))
+    elements ((jdoubleArray) array) [index] = value;
+  else
+    throw new java::lang::IllegalArgumentException;
+}
+
+void
+java::lang::reflect::Array::setDouble (jobject array, jint index, jdouble value)
+{
+  jclass elementType = getElementType (array, index);
+  if (elementType == JvPrimClass (double))
+    elements ((jdoubleArray) array) [index] = value;
+  else
+    throw new java::lang::IllegalArgumentException;
+}
+
+void
+java::lang::reflect::Array::setBoolean (jobject array,
+					jint index, jboolean value)
+{
+  jclass elementType = getElementType (array, index);
+  if (elementType == JvPrimClass (boolean))
+    elements ((jbooleanArray) array) [index] = value;
+  else
+    throw new java::lang::IllegalArgumentException;
+}
+
+void
+java::lang::reflect::Array::set (jobject array, jint index,
+				 jobject value, jclass elType)
+{
+  // We don't have to call getElementType here, or check INDEX,
+  // because it was already done in the Java wrapper.
+  if (value != NULL && ! _Jv_IsInstanceOf (value, elType))
+    throw new java::lang::IllegalArgumentException;
+  elements ((jobjectArray) array) [index] = value;
+}