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

diff --git a/libjava/java/lang/reflect/natField.cc b/libjava/java/lang/reflect/natField.cc
new file mode 100644
index 000000000..734f65316
--- /dev/null
+++ b/libjava/java/lang/reflect/natField.cc
@@ -0,0 +1,449 @@
+// natField.cc - Implementation of java.lang.reflect.Field native methods.
+
+/* Copyright (C) 1998, 1999, 2000, 2001, 2003, 2004, 2006  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 <java-stack.h>
+#include <java/lang/reflect/Field.h>
+#include <java/lang/reflect/Modifier.h>
+#include <java/lang/ArrayIndexOutOfBoundsException.h>
+#include <java/lang/IllegalArgumentException.h>
+#include <java/lang/IllegalAccessException.h>
+#include <java/lang/NullPointerException.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>
+
+typedef JArray< ::java::lang::annotation::Annotation * > * anno_a_t;
+
+jint
+java::lang::reflect::Field::getModifiersInternal ()
+{
+  return _Jv_FromReflectedField (this)->flags;
+}
+
+jstring
+java::lang::reflect::Field::getSignature()
+{
+  return declaringClass->getReflectionSignature (this);
+}
+
+anno_a_t
+java::lang::reflect::Field::getDeclaredAnnotationsInternal()
+{
+  return (anno_a_t) declaringClass->getDeclaredAnnotations(this);
+}
+
+jstring
+java::lang::reflect::Field::getName ()
+{
+  if (name == NULL)
+    name = _Jv_NewStringUtf8Const (_Jv_FromReflectedField (this)->name);
+  return name;
+}
+
+jclass
+java::lang::reflect::Field::getType ()
+{
+  if (type == NULL)
+    {
+      jfieldID fld = _Jv_FromReflectedField (this);
+      JvSynchronize sync (declaringClass);
+      _Jv_Linker::resolve_field (fld, declaringClass->getClassLoaderInternal ());
+      type = fld->type;
+    }
+  return type;
+}
+
+static void*
+getAddr (java::lang::reflect::Field* field, jclass caller, jobject obj,
+         jboolean checkFinal)
+{
+  using namespace java::lang::reflect;
+  
+  jfieldID fld = _Jv_FromReflectedField (field);
+  _Jv_ushort flags = fld->getModifiers();
+
+  // Setting a final field is usually not allowed.
+  if (checkFinal
+      // As of 1.5, you can set a non-static final field if it is
+      // accessible.
+      && (! field->isAccessible()
+	  || (field->getModifiers() & java::lang::reflect::Modifier::STATIC))
+      && (field->getModifiers() & java::lang::reflect::Modifier::FINAL))
+    throw new java::lang::IllegalAccessException(JvNewStringUTF 
+      ("Field is final"));
+  
+  // Check accessibility, if required.
+  if (! (Modifier::isPublic (flags) || field->isAccessible()))
+    {
+      if (! caller)
+	caller = _Jv_StackTrace::GetCallingClass (&Field::class$);
+      if (! _Jv_CheckAccess (caller, field->getDeclaringClass(), flags))
+	throw new java::lang::IllegalAccessException;
+    }
+
+  if (flags & Modifier::STATIC)
+    {
+      jclass fldClass = field->getDeclaringClass ();
+      JvInitClass(fldClass);
+      return fld->u.addr;
+    }
+  else
+    {
+      if (obj == NULL)
+	throw new java::lang::NullPointerException;
+      if (! _Jv_IsInstanceOf (obj, field->getDeclaringClass()))
+	throw new java::lang::IllegalArgumentException;
+      return (void*) ((char*) obj + fld->getOffset ());
+    }
+}
+
+static jboolean
+getBoolean (jclass cls, void* addr)
+{
+  if (cls == JvPrimClass (boolean))
+    return * (jboolean *) addr;
+  throw new java::lang::IllegalArgumentException;
+}
+
+static jchar
+getChar (jclass cls, void* addr)
+{
+  if (cls == JvPrimClass (char))
+    return * (jchar *) addr;
+  throw new java::lang::IllegalArgumentException;
+}
+
+static jbyte
+getByte (jclass cls, void* addr)
+{
+  if (cls == JvPrimClass (byte))
+    return * (jbyte *) addr;
+  throw new java::lang::IllegalArgumentException;
+}
+
+static jshort
+getShort (jclass cls, void* addr)
+{
+  if (cls == JvPrimClass (short))
+    return * (jshort *) addr;
+  if (cls == JvPrimClass (byte))
+    return * (jbyte *) addr;
+  throw new java::lang::IllegalArgumentException;
+}
+
+static jint
+getInt (jclass cls, void* addr)
+{
+  if (cls == JvPrimClass (int))
+    return * (jint *) addr;
+  if (cls == JvPrimClass (short))
+    return * (jshort *) addr;
+  if (cls == JvPrimClass (char))
+    return * (jchar *) addr;
+  if (cls == JvPrimClass (byte))
+    return * (jbyte *) addr;
+  throw new java::lang::IllegalArgumentException;
+}
+
+static jlong
+getLong (jclass cls, void* addr)
+{
+  if (cls == JvPrimClass (long))
+    return * (jlong *) addr;
+  return ::getInt(cls, addr);
+}
+
+static jfloat
+getFloat (jclass cls, void* addr)
+{
+  if (cls == JvPrimClass (float))
+    return * (jfloat *) addr;
+  if (cls == JvPrimClass (long))
+    return * (jlong *) addr;
+  return ::getInt(cls, addr);
+}
+
+static jdouble
+getDouble (jclass cls, void* addr)
+{
+  if (cls == JvPrimClass (double))
+    return * (jdouble *) addr;
+  if (cls == JvPrimClass (float))
+    return * (jfloat *) addr;
+  if (cls == JvPrimClass (long))
+    return * (jlong *) addr;
+  return ::getInt(cls, addr);
+}
+
+jboolean
+java::lang::reflect::Field::getBoolean (jclass caller, jobject obj)
+{
+  return ::getBoolean (this->getType(), getAddr (this, caller, obj, false));
+}
+
+jchar
+java::lang::reflect::Field::getChar (jclass caller, jobject obj)
+{
+  return ::getChar (this->getType(), getAddr (this, caller, obj, false));
+}
+
+jbyte
+java::lang::reflect::Field::getByte (jclass caller, jobject obj)
+{
+  return ::getByte (this->getType(), getAddr (this, caller, obj, false));
+}
+
+jshort
+java::lang::reflect::Field::getShort (jclass caller, jobject obj)
+{
+  return ::getShort (this->getType(), getAddr (this, caller, obj, false));
+}
+
+jint
+java::lang::reflect::Field::getInt (jclass caller, jobject obj)
+{
+  return ::getInt (this->getType(), getAddr (this, caller, obj, false));
+}
+
+jlong
+java::lang::reflect::Field::getLong (jclass caller, jobject obj)
+{
+  return ::getLong (this->getType(), getAddr (this, caller, obj, false));
+}
+
+jfloat
+java::lang::reflect::Field::getFloat (jclass caller, jobject obj)
+{
+  return ::getFloat (this->getType(), getAddr (this, caller, obj, false));
+}
+
+jdouble
+java::lang::reflect::Field::getDouble (jclass caller, jobject obj)
+{
+  return ::getDouble (this->getType(), getAddr (this, caller, obj, false));
+}
+
+jobject
+java::lang::reflect::Field::get (jclass caller, jobject obj)
+{
+  jclass type = this->getType();
+  void* addr = getAddr (this, caller, obj, false);
+  if (! type->isPrimitive ())
+    return * (jobject*) addr;
+  if (type == JvPrimClass (double))
+    return new java::lang::Double (* (jdouble*) addr);
+  if (type == JvPrimClass (float))
+    return new java::lang::Float (* (jfloat*) addr);
+  if (type == JvPrimClass (long))
+    return new java::lang::Long (* (jlong*) addr);
+  if (type == JvPrimClass (int))
+    return new java::lang::Integer (* (jint*) addr);
+  if (type == JvPrimClass (short))
+    return new java::lang::Short (* (jshort*) addr);
+  if (type == JvPrimClass (byte))
+    return new java::lang::Byte (* (jbyte*) addr);
+  if (type == JvPrimClass (char))
+    return new java::lang::Character (* (jchar*) addr);
+  if (type == JvPrimClass (boolean))
+    {
+      _Jv_InitClass (&java::lang::Boolean::class$);
+      if (* (jboolean*) addr)
+	return java::lang::Boolean::TRUE;
+      else
+	return java::lang::Boolean::FALSE;
+    }
+  throw new java::lang::IllegalArgumentException;
+}
+
+static void
+setBoolean (jclass type, void *addr, jboolean value)
+{
+  if (type == JvPrimClass (boolean))
+    * (jboolean *) addr = value;
+  else
+    throw new java::lang::IllegalArgumentException;
+}
+
+static void
+setChar (jclass type, void *addr, jchar value)
+{
+  if (type == JvPrimClass (char))
+    * (jchar *) addr = value;
+  else if (type == JvPrimClass (int))
+    * (jint *) addr = value;
+  else if (type == JvPrimClass (long))
+    * (jlong *) addr = value;
+  else if (type == JvPrimClass (float))
+    * (jfloat *) addr = value;
+  else if (type == JvPrimClass (double))
+    * (jdouble *) addr = value;
+  else
+    throw new java::lang::IllegalArgumentException;
+}
+
+static void
+setByte (jclass type, void *addr, jbyte value)
+{
+  if (type == JvPrimClass (byte))
+    * (jbyte *) addr = value;
+  else if (type == JvPrimClass (short))
+    * (jshort *) addr = value;
+  else if (type == JvPrimClass (int))
+    * (jint *) addr = value;
+  else if (type == JvPrimClass (long))
+    * (jlong *) addr = value;
+  else if (type == JvPrimClass (float))
+    * (jfloat *) addr = value;
+  else if (type == JvPrimClass (double))
+    * (jdouble *) addr = value;
+  else
+    throw new java::lang::IllegalArgumentException;
+}
+
+static void
+setShort (jclass type, void *addr, jshort value)
+{
+  if (type == JvPrimClass (short))
+    * (jshort *) addr = value;
+  else if (type == JvPrimClass (int))
+    * (jint *) addr = value;
+  else if (type == JvPrimClass (long))
+    * (jlong *) addr = value;
+  else if (type == JvPrimClass (float))
+    * (jfloat *) addr = value;
+  else if (type == JvPrimClass (double))
+    * (jdouble *) addr = value;
+  else
+    throw new java::lang::IllegalArgumentException;
+}
+
+static void
+setInt (jclass type, void *addr, jint value)
+{
+  if (type == JvPrimClass (int))
+    * (jint *) addr = value;
+  else if (type == JvPrimClass (long))
+    * (jlong *) addr = value;
+  else if (type == JvPrimClass (float))
+    * (jfloat *) addr = value;
+  else if (type == JvPrimClass (double))
+    * (jdouble *) addr = value;
+  else
+    throw new java::lang::IllegalArgumentException;
+}
+
+static void
+setLong (jclass type, void *addr, jlong value)
+{
+  if (type == JvPrimClass (long))
+    * (jlong *) addr = value;
+  else if (type == JvPrimClass (float))
+    * (jfloat *) addr = value;
+  else if (type == JvPrimClass (double))
+    * (jdouble *) addr = value;
+  else
+    throw new java::lang::IllegalArgumentException;
+}
+
+static void
+setFloat (jclass type, void *addr, jfloat value)
+{
+  if (type == JvPrimClass (float))
+    * (jfloat *) addr = value;
+  else if (type == JvPrimClass (double))
+    * (jdouble *) addr = value;
+  else
+    throw new java::lang::IllegalArgumentException;
+}
+
+static void
+setDouble (jclass type, void *addr, jdouble value)
+{
+  if (type == JvPrimClass (double))
+    * (jdouble *) addr = value;
+  else
+    throw new java::lang::IllegalArgumentException;
+}
+
+void
+java::lang::reflect::Field::setBoolean (jclass caller, jobject obj, jboolean b,
+					jboolean checkFinal)
+{
+  ::setBoolean (this->getType(), getAddr (this, caller, obj, checkFinal), b);
+}
+
+void
+java::lang::reflect::Field::setChar (jclass caller, jobject obj, jchar c,
+				     jboolean checkFinal)
+{
+  ::setChar (this->getType(), getAddr (this, caller, obj, checkFinal), c);
+}
+
+void
+java::lang::reflect::Field::setByte (jclass caller, jobject obj, jbyte b,
+				     jboolean checkFinal)
+{
+  ::setByte (this->getType(), getAddr (this, caller, obj, checkFinal), b);
+}
+
+void
+java::lang::reflect::Field::setShort (jclass caller, jobject obj, jshort s,
+				      jboolean checkFinal)
+{
+  ::setShort (this->getType(), getAddr (this, caller, obj, checkFinal), s);
+}
+
+void
+java::lang::reflect::Field::setInt (jclass caller, jobject obj, jint i,
+				    jboolean checkFinal)
+{
+  ::setInt (this->getType(), getAddr (this, caller, obj, checkFinal), i);
+}
+
+void
+java::lang::reflect::Field::setLong (jclass caller, jobject obj, jlong l,
+				     jboolean checkFinal)
+{
+  ::setLong (this->getType(), getAddr (this, caller, obj, checkFinal), l);
+}
+
+void
+java::lang::reflect::Field::setFloat (jclass caller, jobject obj, jfloat f,
+				      jboolean checkFinal)
+{
+  ::setFloat (this->getType(), getAddr (this, caller, obj, checkFinal), f);
+}
+
+void
+java::lang::reflect::Field::setDouble (jclass caller, jobject obj, jdouble d,
+				       jboolean checkFinal)
+{
+  ::setDouble (this->getType(), getAddr (this, caller, obj, checkFinal), d);
+}
+
+void
+java::lang::reflect::Field::set (jclass caller, jobject object, jobject value,
+				 jclass type, jboolean checkFinal)
+{
+  void* addr = getAddr (this, caller, object, checkFinal);
+  if (value != NULL && ! _Jv_IsInstanceOf (value, type))
+    throw new java::lang::IllegalArgumentException;
+  * (jobject*) addr = value;
+}