summaryrefslogtreecommitdiff
path: root/libjava/sun
diff options
context:
space:
mode:
Diffstat (limited to 'libjava/sun')
-rw-r--r--libjava/sun/awt/CausedFocusEvent$Cause.h50
-rw-r--r--libjava/sun/awt/CausedFocusEvent.h41
-rw-r--r--libjava/sun/misc/Service.h30
-rw-r--r--libjava/sun/misc/ServiceConfigurationError.h30
-rw-r--r--libjava/sun/misc/Unsafe.h53
-rw-r--r--libjava/sun/misc/Unsafe.java328
-rw-r--r--libjava/sun/misc/natUnsafe.cc253
-rw-r--r--libjava/sun/reflect/Reflection.h30
-rw-r--r--libjava/sun/reflect/Reflection.java51
-rw-r--r--libjava/sun/reflect/annotation/AnnotationInvocationHandler.h55
-rw-r--r--libjava/sun/reflect/annotation/AnnotationInvocationHandler.java441
-rw-r--r--libjava/sun/reflect/annotation/AnnotationParser.h33
-rw-r--r--libjava/sun/reflect/annotation/AnnotationType.h33
-rw-r--r--libjava/sun/reflect/annotation/EnumConstantNotPresentExceptionProxy.h32
-rw-r--r--libjava/sun/reflect/annotation/ExceptionProxy.h32
-rw-r--r--libjava/sun/reflect/misc/ReflectUtil$MustBeNull.h32
-rw-r--r--libjava/sun/reflect/misc/ReflectUtil.h35
-rw-r--r--libjava/sun/reflect/misc/ReflectUtil.java113
18 files changed, 1672 insertions, 0 deletions
diff --git a/libjava/sun/awt/CausedFocusEvent$Cause.h b/libjava/sun/awt/CausedFocusEvent$Cause.h
new file mode 100644
index 000000000..d342fc6ee
--- /dev/null
+++ b/libjava/sun/awt/CausedFocusEvent$Cause.h
@@ -0,0 +1,50 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __sun_awt_CausedFocusEvent$Cause__
+#define __sun_awt_CausedFocusEvent$Cause__
+
+#pragma interface
+
+#include <java/lang/Enum.h>
+#include <gcj/array.h>
+
+extern "Java"
+{
+ namespace sun
+ {
+ namespace awt
+ {
+ class CausedFocusEvent$Cause;
+ }
+ }
+}
+
+class sun::awt::CausedFocusEvent$Cause : public ::java::lang::Enum
+{
+
+ CausedFocusEvent$Cause(::java::lang::String *, jint);
+public:
+ static JArray< ::sun::awt::CausedFocusEvent$Cause * > * values();
+ static ::sun::awt::CausedFocusEvent$Cause * valueOf(::java::lang::String *);
+ static ::sun::awt::CausedFocusEvent$Cause * UNKNOWN;
+ static ::sun::awt::CausedFocusEvent$Cause * MOUSE_EVENT;
+ static ::sun::awt::CausedFocusEvent$Cause * TRAVERSAL;
+ static ::sun::awt::CausedFocusEvent$Cause * TRAVERSAL_UP;
+ static ::sun::awt::CausedFocusEvent$Cause * TRAVERSAL_DOWN;
+ static ::sun::awt::CausedFocusEvent$Cause * TRAVERSAL_FORWARD;
+ static ::sun::awt::CausedFocusEvent$Cause * TRAVERSAL_BACKWARD;
+ static ::sun::awt::CausedFocusEvent$Cause * MANUAL_REQUEST;
+ static ::sun::awt::CausedFocusEvent$Cause * AUTOMATIC_TRAVERSE;
+ static ::sun::awt::CausedFocusEvent$Cause * ROLLBACK;
+ static ::sun::awt::CausedFocusEvent$Cause * NATIVE_SYSTEM;
+ static ::sun::awt::CausedFocusEvent$Cause * ACTIVATION;
+ static ::sun::awt::CausedFocusEvent$Cause * CLEAR_GLOBAL_FOCUS_OWNER;
+ static ::sun::awt::CausedFocusEvent$Cause * RETARGETED;
+private:
+ static JArray< ::sun::awt::CausedFocusEvent$Cause * > * ENUM$VALUES;
+public:
+ static ::java::lang::Class class$;
+};
+
+#endif // __sun_awt_CausedFocusEvent$Cause__
diff --git a/libjava/sun/awt/CausedFocusEvent.h b/libjava/sun/awt/CausedFocusEvent.h
new file mode 100644
index 000000000..b6575e7b3
--- /dev/null
+++ b/libjava/sun/awt/CausedFocusEvent.h
@@ -0,0 +1,41 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __sun_awt_CausedFocusEvent__
+#define __sun_awt_CausedFocusEvent__
+
+#pragma interface
+
+#include <java/awt/event/FocusEvent.h>
+extern "Java"
+{
+ namespace java
+ {
+ namespace awt
+ {
+ class Component;
+ }
+ }
+ namespace sun
+ {
+ namespace awt
+ {
+ class CausedFocusEvent;
+ class CausedFocusEvent$Cause;
+ }
+ }
+}
+
+class sun::awt::CausedFocusEvent : public ::java::awt::event::FocusEvent
+{
+
+public:
+ CausedFocusEvent(::java::awt::Component *, jint, jboolean, ::java::awt::Component *, ::sun::awt::CausedFocusEvent$Cause *);
+ virtual ::sun::awt::CausedFocusEvent$Cause * getCause();
+private:
+ ::sun::awt::CausedFocusEvent$Cause * __attribute__((aligned(__alignof__( ::java::awt::event::FocusEvent)))) cause;
+public:
+ static ::java::lang::Class class$;
+};
+
+#endif // __sun_awt_CausedFocusEvent__
diff --git a/libjava/sun/misc/Service.h b/libjava/sun/misc/Service.h
new file mode 100644
index 000000000..e698fed4b
--- /dev/null
+++ b/libjava/sun/misc/Service.h
@@ -0,0 +1,30 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __sun_misc_Service__
+#define __sun_misc_Service__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+extern "Java"
+{
+ namespace sun
+ {
+ namespace misc
+ {
+ class Service;
+ }
+ }
+}
+
+class sun::misc::Service : public ::java::lang::Object
+{
+
+public:
+ Service();
+ static ::java::util::Iterator * providers(::java::lang::Class *, ::java::lang::ClassLoader *);
+ static ::java::lang::Class class$;
+};
+
+#endif // __sun_misc_Service__
diff --git a/libjava/sun/misc/ServiceConfigurationError.h b/libjava/sun/misc/ServiceConfigurationError.h
new file mode 100644
index 000000000..aee51b347
--- /dev/null
+++ b/libjava/sun/misc/ServiceConfigurationError.h
@@ -0,0 +1,30 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __sun_misc_ServiceConfigurationError__
+#define __sun_misc_ServiceConfigurationError__
+
+#pragma interface
+
+#include <java/lang/Error.h>
+extern "Java"
+{
+ namespace sun
+ {
+ namespace misc
+ {
+ class ServiceConfigurationError;
+ }
+ }
+}
+
+class sun::misc::ServiceConfigurationError : public ::java::lang::Error
+{
+
+public:
+ ServiceConfigurationError();
+ ServiceConfigurationError(::java::lang::String *);
+ static ::java::lang::Class class$;
+};
+
+#endif // __sun_misc_ServiceConfigurationError__
diff --git a/libjava/sun/misc/Unsafe.h b/libjava/sun/misc/Unsafe.h
new file mode 100644
index 000000000..d50c3e050
--- /dev/null
+++ b/libjava/sun/misc/Unsafe.h
@@ -0,0 +1,53 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __sun_misc_Unsafe__
+#define __sun_misc_Unsafe__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+extern "Java"
+{
+ namespace sun
+ {
+ namespace misc
+ {
+ class Unsafe;
+ }
+ }
+}
+
+class sun::misc::Unsafe : public ::java::lang::Object
+{
+
+ Unsafe();
+public:
+ static ::sun::misc::Unsafe * getUnsafe();
+ virtual jlong objectFieldOffset(::java::lang::reflect::Field *);
+ virtual jboolean compareAndSwapInt(::java::lang::Object *, jlong, jint, jint);
+ virtual jboolean compareAndSwapLong(::java::lang::Object *, jlong, jlong, jlong);
+ virtual jboolean compareAndSwapObject(::java::lang::Object *, jlong, ::java::lang::Object *, ::java::lang::Object *);
+ virtual void putOrderedInt(::java::lang::Object *, jlong, jint);
+ virtual void putOrderedLong(::java::lang::Object *, jlong, jlong);
+ virtual void putOrderedObject(::java::lang::Object *, jlong, ::java::lang::Object *);
+ virtual void putIntVolatile(::java::lang::Object *, jlong, jint);
+ virtual jint getIntVolatile(::java::lang::Object *, jlong);
+ virtual void putLongVolatile(::java::lang::Object *, jlong, jlong);
+ virtual void putLong(::java::lang::Object *, jlong, jlong);
+ virtual jlong getLongVolatile(::java::lang::Object *, jlong);
+ virtual jlong getLong(::java::lang::Object *, jlong);
+ virtual void putObjectVolatile(::java::lang::Object *, jlong, ::java::lang::Object *);
+ virtual void putObject(::java::lang::Object *, jlong, ::java::lang::Object *);
+ virtual ::java::lang::Object * getObjectVolatile(::java::lang::Object *, jlong);
+ virtual jint arrayBaseOffset(::java::lang::Class *);
+ virtual jint arrayIndexScale(::java::lang::Class *);
+ virtual void unpark(::java::lang::Thread *);
+ virtual void park(jboolean, jlong);
+private:
+ static ::sun::misc::Unsafe * unsafe;
+public:
+ static ::java::lang::Class class$;
+};
+
+#endif // __sun_misc_Unsafe__
diff --git a/libjava/sun/misc/Unsafe.java b/libjava/sun/misc/Unsafe.java
new file mode 100644
index 000000000..fa199f83e
--- /dev/null
+++ b/libjava/sun/misc/Unsafe.java
@@ -0,0 +1,328 @@
+/* Unsafe.java - Unsafe operations needed for concurrency
+ Copyright (C) 2006 Free Software Foundation
+
+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 sun.misc;
+
+import java.lang.reflect.Field;
+
+/**
+ * This class should provide access to low-level operations and its
+ * use should be limited to trusted code. Fields can be accessed using
+ * memory addresses, with undefined behaviour occurring if invalid memory
+ * addresses are given.
+ *
+ * @author Tom Tromey (tromey@redhat.com)
+ * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
+ */
+public class Unsafe
+{
+ // Singleton class.
+ private static Unsafe unsafe = new Unsafe();
+
+ /**
+ * Private default constructor to prevent creation of an arbitrary
+ * number of instances.
+ */
+ private Unsafe()
+ {
+ }
+
+ /**
+ * Retrieve the singleton instance of <code>Unsafe</code>. The calling
+ * method should guard this instance from untrusted code, as it provides
+ * access to low-level operations such as direct memory access.
+ *
+ * @throws SecurityException if a security manager exists and prevents
+ * access to the system properties.
+ */
+ public static Unsafe getUnsafe()
+ {
+ SecurityManager sm = System.getSecurityManager();
+ if (sm != null)
+ sm.checkPropertiesAccess();
+ return unsafe;
+ }
+
+ /**
+ * Returns the memory address offset of the given static field.
+ * The offset is merely used as a means to access a particular field
+ * in the other methods of this class. The value is unique to the given
+ * field and the same value should be returned on each subsequent call.
+ *
+ * @param field the field whose offset should be returned.
+ * @return the offset of the given field.
+ */
+ public native long objectFieldOffset(Field field);
+
+ /**
+ * Compares the value of the integer field at the specified offset
+ * in the supplied object with the given expected value, and updates
+ * it if they match. The operation of this method should be atomic,
+ * thus providing an uninterruptible way of updating an integer field.
+ *
+ * @param obj the object containing the field to modify.
+ * @param offset the offset of the integer field within <code>obj</code>.
+ * @param expect the expected value of the field.
+ * @param update the new value of the field if it equals <code>expect</code>.
+ * @return true if the field was changed.
+ */
+ public native boolean compareAndSwapInt(Object obj, long offset,
+ int expect, int update);
+
+ /**
+ * Compares the value of the long field at the specified offset
+ * in the supplied object with the given expected value, and updates
+ * it if they match. The operation of this method should be atomic,
+ * thus providing an uninterruptible way of updating a long field.
+ *
+ * @param obj the object containing the field to modify.
+ * @param offset the offset of the long field within <code>obj</code>.
+ * @param expect the expected value of the field.
+ * @param update the new value of the field if it equals <code>expect</code>.
+ * @return true if the field was changed.
+ */
+ public native boolean compareAndSwapLong(Object obj, long offset,
+ long expect, long update);
+
+ /**
+ * Compares the value of the object field at the specified offset
+ * in the supplied object with the given expected value, and updates
+ * it if they match. The operation of this method should be atomic,
+ * thus providing an uninterruptible way of updating an object field.
+ *
+ * @param obj the object containing the field to modify.
+ * @param offset the offset of the object field within <code>obj</code>.
+ * @param expect the expected value of the field.
+ * @param update the new value of the field if it equals <code>expect</code>.
+ * @return true if the field was changed.
+ */
+ public native boolean compareAndSwapObject(Object obj, long offset,
+ Object expect, Object update);
+
+ /**
+ * Sets the value of the integer field at the specified offset in the
+ * supplied object to the given value. This is an ordered or lazy
+ * version of <code>putIntVolatile(Object,long,int)</code>, which
+ * doesn't guarantee the immediate visibility of the change to other
+ * threads. It is only really useful where the integer field is
+ * <code>volatile</code>, and is thus expected to change unexpectedly.
+ *
+ * @param obj the object containing the field to modify.
+ * @param offset the offset of the integer field within <code>obj</code>.
+ * @param value the new value of the field.
+ * @see #putIntVolatile(Object,long,int)
+ */
+ public native void putOrderedInt(Object obj, long offset, int value);
+
+ /**
+ * Sets the value of the long field at the specified offset in the
+ * supplied object to the given value. This is an ordered or lazy
+ * version of <code>putLongVolatile(Object,long,long)</code>, which
+ * doesn't guarantee the immediate visibility of the change to other
+ * threads. It is only really useful where the long field is
+ * <code>volatile</code>, and is thus expected to change unexpectedly.
+ *
+ * @param obj the object containing the field to modify.
+ * @param offset the offset of the long field within <code>obj</code>.
+ * @param value the new value of the field.
+ * @see #putLongVolatile(Object,long,long)
+ */
+ public native void putOrderedLong(Object obj, long offset, long value);
+
+ /**
+ * Sets the value of the object field at the specified offset in the
+ * supplied object to the given value. This is an ordered or lazy
+ * version of <code>putObjectVolatile(Object,long,Object)</code>, which
+ * doesn't guarantee the immediate visibility of the change to other
+ * threads. It is only really useful where the object field is
+ * <code>volatile</code>, and is thus expected to change unexpectedly.
+ *
+ * @param obj the object containing the field to modify.
+ * @param offset the offset of the object field within <code>obj</code>.
+ * @param value the new value of the field.
+ */
+ public native void putOrderedObject(Object obj, long offset, Object value);
+
+ /**
+ * Sets the value of the integer field at the specified offset in the
+ * supplied object to the given value, with volatile store semantics.
+ *
+ * @param obj the object containing the field to modify.
+ * @param offset the offset of the integer field within <code>obj</code>.
+ * @param value the new value of the field.
+ */
+ public native void putIntVolatile(Object obj, long offset, int value);
+
+ /**
+ * Retrieves the value of the integer field at the specified offset in the
+ * supplied object with volatile load semantics.
+ *
+ * @param obj the object containing the field to read.
+ * @param offset the offset of the integer field within <code>obj</code>.
+ */
+ public native int getIntVolatile(Object obj, long offset);
+
+ /**
+ * Sets the value of the long field at the specified offset in the
+ * supplied object to the given value, with volatile store semantics.
+ *
+ * @param obj the object containing the field to modify.
+ * @param offset the offset of the long field within <code>obj</code>.
+ * @param value the new value of the field.
+ * @see #putLong(Object,long,long)
+ */
+ public native void putLongVolatile(Object obj, long offset, long value);
+
+ /**
+ * Sets the value of the long field at the specified offset in the
+ * supplied object to the given value.
+ *
+ * @param obj the object containing the field to modify.
+ * @param offset the offset of the long field within <code>obj</code>.
+ * @param value the new value of the field.
+ * @see #putLongVolatile(Object,long,long)
+ */
+ public native void putLong(Object obj, long offset, long value);
+
+ /**
+ * Retrieves the value of the long field at the specified offset in the
+ * supplied object with volatile load semantics.
+ *
+ * @param obj the object containing the field to read.
+ * @param offset the offset of the long field within <code>obj</code>.
+ * @see #getLong(Object,long)
+ */
+ public native long getLongVolatile(Object obj, long offset);
+
+ /**
+ * Retrieves the value of the long field at the specified offset in the
+ * supplied object.
+ *
+ * @param obj the object containing the field to read.
+ * @param offset the offset of the long field within <code>obj</code>.
+ * @see #getLongVolatile(Object,long)
+ */
+ public native long getLong(Object obj, long offset);
+
+ /**
+ * Sets the value of the object field at the specified offset in the
+ * supplied object to the given value, with volatile store semantics.
+ *
+ * @param obj the object containing the field to modify.
+ * @param offset the offset of the object field within <code>obj</code>.
+ * @param value the new value of the field.
+ * @see #putObject(Object,long,Object)
+ */
+ public native void putObjectVolatile(Object obj, long offset, Object value);
+
+ /**
+ * Sets the value of the object field at the specified offset in the
+ * supplied object to the given value.
+ *
+ * @param obj the object containing the field to modify.
+ * @param offset the offset of the object field within <code>obj</code>.
+ * @param value the new value of the field.
+ * @see #putObjectVolatile(Object,long,Object)
+ */
+ public native void putObject(Object obj, long offset, Object value);
+
+ /**
+ * Retrieves the value of the object field at the specified offset in the
+ * supplied object with volatile load semantics.
+ *
+ * @param obj the object containing the field to read.
+ * @param offset the offset of the object field within <code>obj</code>.
+ */
+ public native Object getObjectVolatile(Object obj, long offset);
+
+ /**
+ * Returns the offset of the first element for a given array class.
+ * To access elements of the array class, this value may be used along
+ * with that returned by
+ * <a href="#arrayIndexScale"><code>arrayIndexScale</code></a>,
+ * if non-zero.
+ *
+ * @param arrayClass the class for which the first element's address should
+ * be obtained.
+ * @return the offset of the first element of the array class.
+ * @see arrayIndexScale(Class)
+ */
+ public native int arrayBaseOffset(Class arrayClass);
+
+ /**
+ * Returns the scale factor used for addressing elements of the supplied
+ * array class. Where a suitable scale factor can not be returned (e.g.
+ * for primitive types), zero should be returned. The returned value
+ * can be used with
+ * <a href="#arrayBaseOffset"><code>arrayBaseOffset</code></a>
+ * to access elements of the class.
+ *
+ * @param arrayClass the class whose scale factor should be returned.
+ * @return the scale factor, or zero if not supported for this array class.
+ */
+ public native int arrayIndexScale(Class arrayClass);
+
+ /**
+ * Releases the block on a thread created by
+ * <a href="#park"><code>park</code></a>. This method can also be used
+ * to terminate a blockage caused by a prior call to <code>park</code>.
+ * This operation is unsafe, as the thread must be guaranteed to be
+ * live. This is true of Java, but not native code.
+ *
+ * @param thread the thread to unblock.
+ */
+ public native void unpark(Thread thread);
+
+ /**
+ * Blocks the thread until a matching
+ * <a href="#unpark"><code>unpark</code></a> occurs, the thread is
+ * interrupted or the optional timeout expires. If an <code>unpark</code>
+ * call has already occurred, this also counts. A timeout value of zero
+ * is defined as no timeout. When <code>isAbsolute</code> is
+ * <code>true</code>, the timeout is in milliseconds relative to the
+ * epoch. Otherwise, the value is the number of nanoseconds which must
+ * occur before timeout. This call may also return spuriously (i.e.
+ * for no apparent reason).
+ *
+ * @param isAbsolute true if the timeout is specified in milliseconds from
+ * the epoch.
+ * @param time either the number of nanoseconds to wait, or a time in
+ * milliseconds from the epoch to wait for.
+ */
+ public native void park(boolean isAbsolute, long time);
+
+}
diff --git a/libjava/sun/misc/natUnsafe.cc b/libjava/sun/misc/natUnsafe.cc
new file mode 100644
index 000000000..0bd2d21ea
--- /dev/null
+++ b/libjava/sun/misc/natUnsafe.cc
@@ -0,0 +1,253 @@
+// natUnsafe.cc - Implementation of sun.misc.Unsafe native methods.
+
+/* Copyright (C) 2006, 2007
+ 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 <gcj/cni.h>
+#include <gcj/field.h>
+#include <gcj/javaprims.h>
+#include <jvm.h>
+#include <sun/misc/Unsafe.h>
+#include <java/lang/System.h>
+#include <java/lang/InterruptedException.h>
+
+#include <java/lang/Thread.h>
+#include <java/lang/Long.h>
+
+#include "sysdep/locks.h"
+
+// Use a spinlock for multi-word accesses
+class spinlock
+{
+ static volatile obj_addr_t lock;
+
+public:
+
+spinlock ()
+ {
+ while (! compare_and_swap (&lock, 0, 1))
+ _Jv_ThreadYield ();
+ }
+ ~spinlock ()
+ {
+ release_set (&lock, 0);
+ }
+};
+
+// This is a single lock that is used for all synchronized accesses if
+// the compiler can't generate inline compare-and-swap operations. In
+// most cases it'll never be used, but the i386 needs it for 64-bit
+// locked accesses and so does PPC32. It's worth building libgcj with
+// target=i486 (or above) to get the inlines.
+volatile obj_addr_t spinlock::lock;
+
+
+static inline bool
+compareAndSwap (volatile jint *addr, jint old, jint new_val)
+{
+ jboolean result = false;
+ spinlock lock;
+ if ((result = (*addr == old)))
+ *addr = new_val;
+ return result;
+}
+
+static inline bool
+compareAndSwap (volatile jlong *addr, jlong old, jlong new_val)
+{
+ jboolean result = false;
+ spinlock lock;
+ if ((result = (*addr == old)))
+ *addr = new_val;
+ return result;
+}
+
+static inline bool
+compareAndSwap (volatile jobject *addr, jobject old, jobject new_val)
+{
+ jboolean result = false;
+ spinlock lock;
+ if ((result = (*addr == old)))
+ *addr = new_val;
+ return result;
+}
+
+
+jlong
+sun::misc::Unsafe::objectFieldOffset (::java::lang::reflect::Field *field)
+{
+ _Jv_Field *fld = _Jv_FromReflectedField (field);
+ // FIXME: what if it is not an instance field?
+ return fld->getOffset();
+}
+
+jint
+sun::misc::Unsafe::arrayBaseOffset (jclass arrayClass)
+{
+ // FIXME: assert that arrayClass is array.
+ jclass eltClass = arrayClass->getComponentType();
+ return (jint)(jlong) _Jv_GetArrayElementFromElementType (NULL, eltClass);
+}
+
+jint
+sun::misc::Unsafe::arrayIndexScale (jclass arrayClass)
+{
+ // FIXME: assert that arrayClass is array.
+ jclass eltClass = arrayClass->getComponentType();
+ if (eltClass->isPrimitive())
+ return eltClass->size();
+ return sizeof (void *);
+}
+
+// These methods are used when the compiler fails to generate inline
+// versions of the compare-and-swap primitives.
+
+jboolean
+sun::misc::Unsafe::compareAndSwapInt (jobject obj, jlong offset,
+ jint expect, jint update)
+{
+ jint *addr = (jint *)((char *)obj + offset);
+ return compareAndSwap (addr, expect, update);
+}
+
+jboolean
+sun::misc::Unsafe::compareAndSwapLong (jobject obj, jlong offset,
+ jlong expect, jlong update)
+{
+ volatile jlong *addr = (jlong*)((char *) obj + offset);
+ return compareAndSwap (addr, expect, update);
+}
+
+jboolean
+sun::misc::Unsafe::compareAndSwapObject (jobject obj, jlong offset,
+ jobject expect, jobject update)
+{
+ jobject *addr = (jobject*)((char *) obj + offset);
+ return compareAndSwap (addr, expect, update);
+}
+
+void
+sun::misc::Unsafe::putOrderedInt (jobject obj, jlong offset, jint value)
+{
+ volatile jint *addr = (jint *) ((char *) obj + offset);
+ *addr = value;
+}
+
+void
+sun::misc::Unsafe::putOrderedLong (jobject obj, jlong offset, jlong value)
+{
+ volatile jlong *addr = (jlong *) ((char *) obj + offset);
+ spinlock lock;
+ *addr = value;
+}
+
+void
+sun::misc::Unsafe::putOrderedObject (jobject obj, jlong offset, jobject value)
+{
+ volatile jobject *addr = (jobject *) ((char *) obj + offset);
+ *addr = value;
+}
+
+void
+sun::misc::Unsafe::putIntVolatile (jobject obj, jlong offset, jint value)
+{
+ write_barrier ();
+ volatile jint *addr = (jint *) ((char *) obj + offset);
+ *addr = value;
+}
+
+void
+sun::misc::Unsafe::putLongVolatile (jobject obj, jlong offset, jlong value)
+{
+ volatile jlong *addr = (jlong *) ((char *) obj + offset);
+ spinlock lock;
+ *addr = value;
+}
+
+void
+sun::misc::Unsafe::putObjectVolatile (jobject obj, jlong offset, jobject value)
+{
+ write_barrier ();
+ volatile jobject *addr = (jobject *) ((char *) obj + offset);
+ *addr = value;
+}
+
+#if 0 // FIXME
+void
+sun::misc::Unsafe::putInt (jobject obj, jlong offset, jint value)
+{
+ jint *addr = (jint *) ((char *) obj + offset);
+ *addr = value;
+}
+#endif
+
+void
+sun::misc::Unsafe::putLong (jobject obj, jlong offset, jlong value)
+{
+ jlong *addr = (jlong *) ((char *) obj + offset);
+ spinlock lock;
+ *addr = value;
+}
+
+void
+sun::misc::Unsafe::putObject (jobject obj, jlong offset, jobject value)
+{
+ jobject *addr = (jobject *) ((char *) obj + offset);
+ *addr = value;
+}
+
+jint
+sun::misc::Unsafe::getIntVolatile (jobject obj, jlong offset)
+{
+ volatile jint *addr = (jint *) ((char *) obj + offset);
+ jint result = *addr;
+ read_barrier ();
+ return result;
+}
+
+jobject
+sun::misc::Unsafe::getObjectVolatile (jobject obj, jlong offset)
+{
+ volatile jobject *addr = (jobject *) ((char *) obj + offset);
+ jobject result = *addr;
+ read_barrier ();
+ return result;
+}
+
+jlong
+sun::misc::Unsafe::getLong (jobject obj, jlong offset)
+{
+ jlong *addr = (jlong *) ((char *) obj + offset);
+ spinlock lock;
+ return *addr;
+}
+
+jlong
+sun::misc::Unsafe::getLongVolatile (jobject obj, jlong offset)
+{
+ volatile jlong *addr = (jlong *) ((char *) obj + offset);
+ spinlock lock;
+ return *addr;
+}
+
+void
+sun::misc::Unsafe::unpark (::java::lang::Thread *thread)
+{
+ natThread *nt = (natThread *) thread->data;
+ nt->park_helper.unpark ();
+}
+
+void
+sun::misc::Unsafe::park (jboolean isAbsolute, jlong time)
+{
+ using namespace ::java::lang;
+ Thread *thread = Thread::currentThread();
+ natThread *nt = (natThread *) thread->data;
+ nt->park_helper.park (isAbsolute, time);
+}
diff --git a/libjava/sun/reflect/Reflection.h b/libjava/sun/reflect/Reflection.h
new file mode 100644
index 000000000..7f3c82fe7
--- /dev/null
+++ b/libjava/sun/reflect/Reflection.h
@@ -0,0 +1,30 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __sun_reflect_Reflection__
+#define __sun_reflect_Reflection__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+extern "Java"
+{
+ namespace sun
+ {
+ namespace reflect
+ {
+ class Reflection;
+ }
+ }
+}
+
+class sun::reflect::Reflection : public ::java::lang::Object
+{
+
+public:
+ Reflection();
+ static ::java::lang::Class * getCallerClass(jint);
+ static ::java::lang::Class class$;
+};
+
+#endif // __sun_reflect_Reflection__
diff --git a/libjava/sun/reflect/Reflection.java b/libjava/sun/reflect/Reflection.java
new file mode 100644
index 000000000..ef25ce71f
--- /dev/null
+++ b/libjava/sun/reflect/Reflection.java
@@ -0,0 +1,51 @@
+/* Reflection.java - JSR 166 reflection hooks
+ Copyright (C) 2006 Free Software Foundation
+
+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 sun.reflect;
+
+import gnu.classpath.VMStackWalker;
+
+public class Reflection
+{
+ /**
+ * A stack-walking wrapper method used by the JSR 166 RI.
+ */
+ public static Class getCallerClass(int depth)
+ {
+ return VMStackWalker.getClassContext()[depth];
+ }
+}
diff --git a/libjava/sun/reflect/annotation/AnnotationInvocationHandler.h b/libjava/sun/reflect/annotation/AnnotationInvocationHandler.h
new file mode 100644
index 000000000..356c8a029
--- /dev/null
+++ b/libjava/sun/reflect/annotation/AnnotationInvocationHandler.h
@@ -0,0 +1,55 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __sun_reflect_annotation_AnnotationInvocationHandler__
+#define __sun_reflect_annotation_AnnotationInvocationHandler__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+#include <gcj/array.h>
+
+extern "Java"
+{
+ namespace sun
+ {
+ namespace reflect
+ {
+ namespace annotation
+ {
+ class AnnotationInvocationHandler;
+ }
+ }
+ }
+}
+
+class sun::reflect::annotation::AnnotationInvocationHandler : public ::java::lang::Object
+{
+
+public:
+ AnnotationInvocationHandler(::java::lang::Class *, ::java::util::Map *);
+ static ::java::lang::annotation::Annotation * create(::java::lang::Class *, ::java::util::Map *);
+ jboolean equals(::java::lang::Object *, ::java::lang::Object *);
+private:
+ static jboolean deepEquals(::java::lang::Object *, ::java::lang::Object *);
+ static jint deepHashCode(::java::lang::Object *);
+public:
+ jint hashCode();
+private:
+ static ::java::lang::String * deepToString(::java::lang::Object *);
+public:
+ ::java::lang::String * toString();
+private:
+ static ::java::lang::Class * getBoxedReturnType(::java::lang::reflect::Method *);
+ ::java::lang::Object * coerce(::java::lang::Object *, ::java::lang::Class *);
+public:
+ ::java::lang::Object * invoke(::java::lang::Object *, ::java::lang::reflect::Method *, JArray< ::java::lang::Object * > *);
+private:
+ static const jlong serialVersionUID = 6182022883658399397LL;
+ ::java::lang::Class * __attribute__((aligned(__alignof__( ::java::lang::Object)))) type;
+ ::java::util::Map * memberValues;
+public:
+ static ::java::lang::Class class$;
+};
+
+#endif // __sun_reflect_annotation_AnnotationInvocationHandler__
diff --git a/libjava/sun/reflect/annotation/AnnotationInvocationHandler.java b/libjava/sun/reflect/annotation/AnnotationInvocationHandler.java
new file mode 100644
index 000000000..f883faa16
--- /dev/null
+++ b/libjava/sun/reflect/annotation/AnnotationInvocationHandler.java
@@ -0,0 +1,441 @@
+/* sun.reflect.annotation.AnnotationInvocationHandler
+ Copyright (C) 2006, 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 sun.reflect.annotation;
+
+import java.io.Serializable;
+import java.lang.annotation.Annotation;
+import java.lang.annotation.AnnotationTypeMismatchException;
+import java.lang.annotation.IncompleteAnnotationException;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.lang.reflect.Array;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.Map;
+
+/**
+ * This class exists for serialization compatibility with the JDK.
+ * VMs can choose to implement annotations by constructing proxies
+ * with this invocation handler, but that is not required.
+ * If a different strategy for proxy objects is chosen, they can
+ * have a writeReplace method to substitute a Proxy based on this
+ * invocation handler is used for serialization.
+ */
+public final class AnnotationInvocationHandler
+ implements InvocationHandler, Serializable
+{
+ private static final long serialVersionUID = 6182022883658399397L;
+ private final Class<? extends Annotation> type;
+ private final Map<String, ?> memberValues;
+
+ /**
+ * Construct a new invocation handler for an annotation proxy.
+ * Note that the VM is responsible for filling the memberValues map
+ * with the default values of all the annotation members.
+ */
+ public AnnotationInvocationHandler(Class<? extends Annotation> type, Map memberValues)
+ {
+ this.type = type;
+ this.memberValues = (Map<String, ?>)memberValues;
+ }
+
+ public static Annotation create(Class<? extends Annotation> type, Map memberValues)
+ {
+ for (Method m : type.getDeclaredMethods())
+ {
+ String name = m.getName();
+ if (! memberValues.containsKey(name))
+ {
+ // FIXME: what to do about exceptions here?
+ memberValues.put(name, m.getDefaultValue());
+ }
+ }
+ AnnotationInvocationHandler handler
+ = new AnnotationInvocationHandler(type, memberValues);
+ return (Annotation) Proxy.newProxyInstance(type.getClassLoader(),
+ new Class[] { type },
+ handler);
+ }
+
+ /**
+ * Compare an instance of AnnotationInvocationHandler with another object.
+ * Note that the other object does not have to be an
+ * AnnotationInvocationHandler, any implementation of the annotation
+ * interface is allowed to be compared for equality.
+ * Note that this makes the equals method asymmetric, but this behavior
+ * is specified by Annotation.equals and identical to the JDK.
+ *
+ * This method is public for use by other parts of the VM. Some VMs
+ * (can) use different representations of annotations that reuse this
+ * method.
+ */
+ public boolean equals(Object proxy, Object other)
+ {
+ if (type.isInstance(other))
+ {
+ try
+ {
+ Method[] methods = type.getDeclaredMethods();
+ if (methods.length == memberValues.size())
+ {
+ for (int i = 0; i < methods.length; i++)
+ {
+ String key = methods[i].getName();
+ Object val = methods[i].invoke(other, (Object[])null);
+ Object thisVal
+ = invoke(proxy,
+ methods[i],
+ (Object[])null);
+ if (! deepEquals(thisVal, val))
+ {
+ return false;
+ }
+ }
+ return true;
+ }
+ }
+ catch (Throwable _)
+ {
+ // Ignore exception, like the JDK
+ }
+ }
+ return false;
+ }
+
+ private static boolean deepEquals(Object o1, Object o2)
+ {
+ if (o1 == o2)
+ return true;
+
+ if (o1 == null || o2 == null)
+ return false;
+
+ if (o1 instanceof boolean[] && o2 instanceof boolean[])
+ return Arrays.equals((boolean[]) o1, (boolean[]) o2);
+
+ if (o1 instanceof byte[] && o2 instanceof byte[])
+ return Arrays.equals((byte[]) o1, (byte[]) o2);
+
+ if (o1 instanceof char[] && o2 instanceof char[])
+ return Arrays.equals((char[]) o1, (char[]) o2);
+
+ if (o1 instanceof short[] && o2 instanceof short[])
+ return Arrays.equals((short[]) o1, (short[]) o2);
+
+ if (o1 instanceof int[] && o2 instanceof int[])
+ return Arrays.equals((int[]) o1, (int[]) o2);
+
+ if (o1 instanceof float[] && o2 instanceof float[])
+ return Arrays.equals((float[]) o1, (float[]) o2);
+
+ if (o1 instanceof long[] && o2 instanceof long[])
+ return Arrays.equals((long[]) o1, (long[]) o2);
+
+ if (o1 instanceof double[] && o2 instanceof double[])
+ return Arrays.equals((double[]) o1, (double[]) o2);
+
+ if (o1 instanceof Object[] && o2 instanceof Object[])
+ return Arrays.equals((Object[]) o1, (Object[]) o2);
+
+ return o1.equals(o2);
+ }
+
+ private static int deepHashCode(Object obj)
+ {
+ if (obj instanceof boolean[])
+ return Arrays.hashCode((boolean[]) obj);
+
+ if (obj instanceof byte[])
+ return Arrays.hashCode((byte[]) obj);
+
+ if (obj instanceof char[])
+ return Arrays.hashCode((char[]) obj);
+
+ if (obj instanceof short[])
+ return Arrays.hashCode((short[]) obj);
+
+ if (obj instanceof int[])
+ return Arrays.hashCode((int[]) obj);
+
+ if (obj instanceof float[])
+ return Arrays.hashCode((float[]) obj);
+
+ if (obj instanceof long[])
+ return Arrays.hashCode((long[]) obj);
+
+ if (obj instanceof double[])
+ return Arrays.hashCode((double[]) obj);
+
+ if (obj instanceof Object[])
+ return Arrays.hashCode((Object[]) obj);
+
+ return obj.hashCode();
+ }
+
+ /**
+ * Compute the hashCode for an annotation. Note that the algorithm is
+ * specified by Annotation.hashCode.
+ *
+ * This method is public for use by other parts of the VM. Some VMs
+ * (can) use different representations of annotations that reuse this
+ * method.
+ */
+ public int hashCode()
+ {
+ int h = 0;
+ Iterator iter = memberValues.keySet().iterator();
+ while (iter.hasNext())
+ {
+ Object key = iter.next();
+ try
+ {
+ Object val
+ = invoke(null,
+ type.getDeclaredMethod((String)key, (Class[])null),
+ (Object[])null);
+ h += deepHashCode(val) ^ 127 * key.hashCode();
+ }
+ catch (Throwable _)
+ {
+ }
+ }
+ return h;
+ }
+
+ private static String deepToString(Object obj)
+ {
+ if (obj instanceof Object[])
+ return Arrays.toString((Object[]) obj);
+
+ return obj.toString();
+ }
+
+ /**
+ * This method is public for use by other parts of the VM. Some VMs
+ * (can) use different representations of annotations that reuse this
+ * method.
+ */
+ public String toString()
+ {
+ StringBuffer sb = new StringBuffer();
+ sb.append('@').append(type.getName()).append('(');
+ String sep = "";
+ Iterator iter = memberValues.keySet().iterator();
+ while (iter.hasNext())
+ {
+ Object key = iter.next();
+ Object val = memberValues.get(key);
+ sb.append(sep).append(key).append('=').append(deepToString(val));
+ sep = ", ";
+ }
+ sb.append(')');
+ return sb.toString();
+ }
+
+
+ private static Class getBoxedReturnType(Method method)
+ {
+ Class returnType = method.getReturnType();
+
+ if (returnType == boolean.class)
+ return Boolean.class;
+
+ if (returnType == byte.class)
+ return Byte.class;
+
+ if (returnType == char.class)
+ return Character.class;
+
+ if (returnType == short.class)
+ return Short.class;
+
+ if (returnType == int.class)
+ return Integer.class;
+
+ if (returnType == float.class)
+ return Float.class;
+
+ if (returnType == long.class)
+ return Long.class;
+
+ if (returnType == double.class)
+ return Double.class;
+
+ return returnType;
+ }
+
+ // This is slightly awkward. When the value of an annotation is an
+ // array, libgcj constructs an Object[], but the value() method
+ // returns an arrays of the appropriate primitive type. We should
+ // perhaps save the resulting array rather than the Object[].
+
+ private Object coerce(Object val, Class dstType)
+ throws ArrayStoreException
+ {
+ if (! val.getClass().isArray())
+ return val;
+
+ Object[] srcArray = (Object[])val;
+ final int len = srcArray.length;
+
+ if (dstType.getComponentType().isPrimitive())
+ {
+ if (dstType == boolean[].class)
+ {
+ boolean[] dst = new boolean[len];
+ for (int i = 0; i < len; i++)
+ dst[i] = (Boolean)srcArray[i];
+ return dst;
+ }
+
+ if (dstType == byte[].class)
+ {
+ byte[] dst = new byte[len];
+ for (int i = 0; i < len; i++)
+ dst[i] = (Byte)srcArray[i];
+ return dst;
+ }
+
+ if (dstType == char[].class)
+ {
+ char[] dst = new char[len];
+ for (int i = 0; i < len; i++)
+ dst[i] = (Character)srcArray[i];
+ return dst;
+ }
+
+ if (dstType == short[].class)
+ {
+ short[] dst = new short[len];
+ for (int i = 0; i < len; i++)
+ dst[i] = (Short)srcArray[i];
+ return dst;
+ }
+
+ if (dstType == int[].class)
+ {
+ int[] dst = new int[len];
+ for (int i = 0; i < len; i++)
+ dst[i] = (Integer)srcArray[i];
+ return dst;
+ }
+
+ if (dstType == long[].class)
+ {
+ long[] dst = new long[len];
+ for (int i = 0; i < len; i++)
+ dst[i] = (Long)srcArray[i];
+ return dst;
+ }
+
+ if (dstType == float[].class)
+ {
+ float[] dst = new float[len];
+ for (int i = 0; i < len; i++)
+ dst[i] = (Float)srcArray[i];
+ return dst;
+ }
+
+ if (dstType == double[].class)
+ {
+ double[] dst = new double[len];
+ for (int i = 0; i < len; i++)
+ dst[i] = (Double)srcArray[i];
+ return dst;
+ }
+ }
+
+ Object dst = Array.newInstance(dstType.getComponentType(), len);
+ System.arraycopy((Object)srcArray, 0, dst, 0, len);
+ return dst;
+ }
+
+ public Object invoke(Object proxy, Method method, Object[] args)
+ throws Throwable
+ {
+ String methodName = method.getName().intern();
+
+ if (args == null || args.length == 0)
+ {
+ if (methodName == "toString")
+ {
+ return toString();
+ }
+ else if (methodName == "hashCode")
+ {
+ return Integer.valueOf(hashCode());
+ }
+ else if (methodName == "annotationType")
+ {
+ return type;
+ }
+ else
+ {
+ Object val = memberValues.get(methodName);
+ if (val == null)
+ {
+ throw new IncompleteAnnotationException(type, methodName);
+ }
+ try
+ {
+ if (val.getClass().isArray())
+ val = coerce((Object[])val, method.getReturnType());
+ }
+ catch (ArrayStoreException _)
+ {
+ throw new AnnotationTypeMismatchException
+ (method, val.getClass().getName());
+ }
+ if (! getBoxedReturnType(method).isInstance(val))
+ throw (new AnnotationTypeMismatchException
+ (method, val.getClass().getName()));
+ return val;
+ }
+ }
+ else if (args.length == 1)
+ {
+ if (methodName == "equals")
+ {
+ return Boolean.valueOf(equals(proxy, args[0]));
+ }
+ }
+ throw new InternalError("Invalid annotation proxy");
+ }
+}
diff --git a/libjava/sun/reflect/annotation/AnnotationParser.h b/libjava/sun/reflect/annotation/AnnotationParser.h
new file mode 100644
index 000000000..d5ca9737a
--- /dev/null
+++ b/libjava/sun/reflect/annotation/AnnotationParser.h
@@ -0,0 +1,33 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __sun_reflect_annotation_AnnotationParser__
+#define __sun_reflect_annotation_AnnotationParser__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+extern "Java"
+{
+ namespace sun
+ {
+ namespace reflect
+ {
+ namespace annotation
+ {
+ class AnnotationParser;
+ }
+ }
+ }
+}
+
+class sun::reflect::annotation::AnnotationParser : public ::java::lang::Object
+{
+
+public:
+ AnnotationParser();
+ static ::java::lang::annotation::Annotation * annotationForMap(::java::lang::Class *, ::java::util::Map *);
+ static ::java::lang::Class class$;
+};
+
+#endif // __sun_reflect_annotation_AnnotationParser__
diff --git a/libjava/sun/reflect/annotation/AnnotationType.h b/libjava/sun/reflect/annotation/AnnotationType.h
new file mode 100644
index 000000000..3d21e0f14
--- /dev/null
+++ b/libjava/sun/reflect/annotation/AnnotationType.h
@@ -0,0 +1,33 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __sun_reflect_annotation_AnnotationType__
+#define __sun_reflect_annotation_AnnotationType__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+extern "Java"
+{
+ namespace sun
+ {
+ namespace reflect
+ {
+ namespace annotation
+ {
+ class AnnotationType;
+ }
+ }
+ }
+}
+
+class sun::reflect::annotation::AnnotationType : public ::java::lang::Object
+{
+
+public:
+ AnnotationType();
+ static ::java::lang::Class * invocationHandlerReturnType(::java::lang::Class *);
+ static ::java::lang::Class class$;
+};
+
+#endif // __sun_reflect_annotation_AnnotationType__
diff --git a/libjava/sun/reflect/annotation/EnumConstantNotPresentExceptionProxy.h b/libjava/sun/reflect/annotation/EnumConstantNotPresentExceptionProxy.h
new file mode 100644
index 000000000..63d853b5d
--- /dev/null
+++ b/libjava/sun/reflect/annotation/EnumConstantNotPresentExceptionProxy.h
@@ -0,0 +1,32 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __sun_reflect_annotation_EnumConstantNotPresentExceptionProxy__
+#define __sun_reflect_annotation_EnumConstantNotPresentExceptionProxy__
+
+#pragma interface
+
+#include <sun/reflect/annotation/ExceptionProxy.h>
+extern "Java"
+{
+ namespace sun
+ {
+ namespace reflect
+ {
+ namespace annotation
+ {
+ class EnumConstantNotPresentExceptionProxy;
+ }
+ }
+ }
+}
+
+class sun::reflect::annotation::EnumConstantNotPresentExceptionProxy : public ::sun::reflect::annotation::ExceptionProxy
+{
+
+public:
+ EnumConstantNotPresentExceptionProxy(::java::lang::Class *, ::java::lang::String *);
+ static ::java::lang::Class class$;
+};
+
+#endif // __sun_reflect_annotation_EnumConstantNotPresentExceptionProxy__
diff --git a/libjava/sun/reflect/annotation/ExceptionProxy.h b/libjava/sun/reflect/annotation/ExceptionProxy.h
new file mode 100644
index 000000000..ca6a3cd69
--- /dev/null
+++ b/libjava/sun/reflect/annotation/ExceptionProxy.h
@@ -0,0 +1,32 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __sun_reflect_annotation_ExceptionProxy__
+#define __sun_reflect_annotation_ExceptionProxy__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+extern "Java"
+{
+ namespace sun
+ {
+ namespace reflect
+ {
+ namespace annotation
+ {
+ class ExceptionProxy;
+ }
+ }
+ }
+}
+
+class sun::reflect::annotation::ExceptionProxy : public ::java::lang::Object
+{
+
+public:
+ ExceptionProxy();
+ static ::java::lang::Class class$;
+};
+
+#endif // __sun_reflect_annotation_ExceptionProxy__
diff --git a/libjava/sun/reflect/misc/ReflectUtil$MustBeNull.h b/libjava/sun/reflect/misc/ReflectUtil$MustBeNull.h
new file mode 100644
index 000000000..a2e7494d8
--- /dev/null
+++ b/libjava/sun/reflect/misc/ReflectUtil$MustBeNull.h
@@ -0,0 +1,32 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __sun_reflect_misc_ReflectUtil$MustBeNull__
+#define __sun_reflect_misc_ReflectUtil$MustBeNull__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+extern "Java"
+{
+ namespace sun
+ {
+ namespace reflect
+ {
+ namespace misc
+ {
+ class ReflectUtil$MustBeNull;
+ }
+ }
+ }
+}
+
+class sun::reflect::misc::ReflectUtil$MustBeNull : public ::java::lang::Object
+{
+
+ ReflectUtil$MustBeNull();
+public:
+ static ::java::lang::Class class$;
+};
+
+#endif // __sun_reflect_misc_ReflectUtil$MustBeNull__
diff --git a/libjava/sun/reflect/misc/ReflectUtil.h b/libjava/sun/reflect/misc/ReflectUtil.h
new file mode 100644
index 000000000..91c0b64b2
--- /dev/null
+++ b/libjava/sun/reflect/misc/ReflectUtil.h
@@ -0,0 +1,35 @@
+
+// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-
+
+#ifndef __sun_reflect_misc_ReflectUtil__
+#define __sun_reflect_misc_ReflectUtil__
+
+#pragma interface
+
+#include <java/lang/Object.h>
+extern "Java"
+{
+ namespace sun
+ {
+ namespace reflect
+ {
+ namespace misc
+ {
+ class ReflectUtil;
+ class ReflectUtil$MustBeNull;
+ }
+ }
+ }
+}
+
+class sun::reflect::misc::ReflectUtil : public ::java::lang::Object
+{
+
+public:
+ ReflectUtil();
+ static void checkPackageAccess(::java::lang::Class *);
+ static void ensureMemberAccess(::java::lang::Class *, ::java::lang::Class *, ::sun::reflect::misc::ReflectUtil$MustBeNull *, jint);
+ static ::java::lang::Class class$;
+};
+
+#endif // __sun_reflect_misc_ReflectUtil__
diff --git a/libjava/sun/reflect/misc/ReflectUtil.java b/libjava/sun/reflect/misc/ReflectUtil.java
new file mode 100644
index 000000000..88a6f2515
--- /dev/null
+++ b/libjava/sun/reflect/misc/ReflectUtil.java
@@ -0,0 +1,113 @@
+/* ReflectUtil.java - JSR 166 reflection hooks
+ Copyright (C) 2006 Free Software Foundation
+
+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 sun.reflect.misc;
+
+import java.lang.reflect.Modifier;
+
+public class ReflectUtil
+{
+ // We use this inaccessible inner class as an argument type
+ // in verifyMemberAccess. All current users of this method
+ // in the JSR 166 RI pass 'null' for this argument, and
+ // consequently we don't know what it means. Using a funny
+ // type like this for the argument means that if the RI changes,
+ // we will see a compilation error.
+ private static class MustBeNull
+ {
+ }
+
+ /**
+ * Check if the current thread is allowed to access the package of
+ * the declaringClass.
+ *
+ * @param declaringClass class name to check access to
+ * @throws SecurityException if permission is denied
+ * @throws NullPointerException if declaringClass is null
+ */
+ public static void checkPackageAccess(Class declaringClass)
+ {
+ SecurityManager sm;
+ if ((sm = System.getSecurityManager()) != null)
+ {
+ while (declaringClass.isArray())
+ declaringClass = declaringClass.getComponentType();
+ String name = declaringClass.getName();
+ int i = name.lastIndexOf('.');
+ if (i != -1) // if declaringClass is a member of a package
+ {
+ name = name.substring(0, i);
+ sm.checkPackageAccess(name);
+ }
+ }
+ }
+
+ /**
+ * Perform access checks on a member of a class. This API is
+ * derived from the public domain code in the JSR 166 reference
+ * implementation.
+ * @param caller the class requesting access to the member
+ * @param declarer the declaring class of the member
+ * @param ignored unknown parameter; always null
+ * @param modifiers the modifiers on the member
+ * @return true if access is granted, false otherwise
+ */
+ public static void ensureMemberAccess(Class caller,
+ Class declarer,
+ MustBeNull ignored,
+ int modifiers)
+ {
+ // Same class, always ok.
+ if (caller == declarer)
+ return;
+ // Public access is ok.
+ if ((modifiers & Modifier.PUBLIC) != 0)
+ return;
+ // Protected access and request comes from
+ // a subclass of the declarer -- ok.
+ if ((modifiers & Modifier.PROTECTED) != 0
+ && declarer.isAssignableFrom(caller))
+ return;
+ // Package-private access, or protected access,
+ // and the packages are the same --ok.
+ if ((modifiers & Modifier.PRIVATE) == 0
+ && caller.getPackage() == declarer.getPackage())
+ return;
+ // Otherwise, no.
+ throw new IllegalAccessError();
+ }
+}