diff options
Diffstat (limited to 'libjava/classpath/vm/reference')
15 files changed, 1604 insertions, 136 deletions
diff --git a/libjava/classpath/vm/reference/gnu/classpath/Unsafe.java b/libjava/classpath/vm/reference/gnu/classpath/Unsafe.java new file mode 100644 index 0000000..6e4ec98 --- /dev/null +++ b/libjava/classpath/vm/reference/gnu/classpath/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 gnu.classpath; + +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 final 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/classpath/vm/reference/gnu/classpath/jdwp/VMIdManager.java b/libjava/classpath/vm/reference/gnu/classpath/jdwp/VMIdManager.java index 6a8be10..8d423e9 100644 --- a/libjava/classpath/vm/reference/gnu/classpath/jdwp/VMIdManager.java +++ b/libjava/classpath/vm/reference/gnu/classpath/jdwp/VMIdManager.java @@ -48,11 +48,9 @@ import gnu.classpath.jdwp.id.*; import java.lang.ref.Reference; import java.lang.ref.ReferenceQueue; import java.lang.ref.SoftReference; -import java.io.IOException; import java.nio.ByteBuffer; import java.util.HashMap; import java.util.Hashtable; -import java.util.Iterator; /** * This class manages objects and referencetypes that are reported @@ -111,7 +109,7 @@ public class VMIdManager /** * Returns a new id for the given object * - * @param object the object for which an id is desired + * @param obj SoftReference of the object for which an id is desired * @returns a suitable object id */ public static ObjectId newObjectId (SoftReference obj) @@ -171,7 +169,7 @@ public class VMIdManager /** * Returns a new reference type id for the given class * - * @param clazz the <code>Class</code> for which an id is desired + * @param ref SoftReference to the desired type * @returns a suitable reference type id or null when the * reference is cleared. */ diff --git a/libjava/classpath/vm/reference/gnu/classpath/jdwp/VMMethod.java b/libjava/classpath/vm/reference/gnu/classpath/jdwp/VMMethod.java new file mode 100644 index 0000000..d345bc1 --- /dev/null +++ b/libjava/classpath/vm/reference/gnu/classpath/jdwp/VMMethod.java @@ -0,0 +1,178 @@ +/* VMMethod.java -- a method in a virtual machine + Copyright (C) 2006 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +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.classpath.jdwp; + +import java.io.DataOutputStream; +import java.io.IOException; +import java.nio.ByteBuffer; + +import gnu.classpath.jdwp.exception.JdwpException; +import gnu.classpath.jdwp.util.LineTable; +import gnu.classpath.jdwp.util.VariableTable; + +/** + * This class is really an amalgamation of two classes: one class + * represents a virtual machine method and the other represents + * the JDWP back-end's ID for the method. + * + * @author Keith Seitz (keiths@redhat.com) + */ +public class VMMethod +{ + /** + * Returns the size of a JDWP method ID + * @see gnu.classpath.jdwp.id.JdwpId#SIZE + */ + public static final int SIZE = 8; + + // The class in which this method is declared + private Class _class; + + // The method's ID + private long _methodId; + + /** + * Constructs a new VMMethod object. This constructor is protected + * so that only the factory methods of VMVirtualMachine can be used + * to create VMMethods. + * + * @param klass the method's containing class + * @param id method identifier, e.g., jmethodID + * @see gnu.classpath.jdwp.VMVirtualMachine#getAllClassMethods + * @see gnu.classpath.jdwp.VMVirtualMachine#getClassMethod + */ + protected VMMethod(Class klass, long id) + { + _class = klass; + _methodId = id; + } + + /** + * Returns the internal method ID for this method + */ + public long getId() + { + return _methodId; + } + + /** + * Returns the method's declaring class + */ + public Class getDeclaringClass() + { + return _class; + } + + /** + * Returns the name of this method + */ + public native String getName(); + + /** + * Returns the signature of this method + */ + public native String getSignature(); + + /** + * Returns the method's modifier flags + */ + public native int getModifiers(); + + /** + * "Returns line number information for the method, if present. The line + * table maps source line numbers to the initial code index of the line. + * The line table is ordered by code index (from lowest to highest). The + * line number information is constant unless a new class definition is + * installed using RedefineClasses." + * + * @return the line table + * @throws JdwpException + */ + public native LineTable getLineTable() + throws JdwpException; + + /** + * "Returns variable information for the method. The variable table + * includes arguments and locals declared within the method. For instance + * methods, the "this" reference is included in the table. Also, synthetic + * variables may be present." + * + * @return the variable table + * @throws JdwpException + */ + public native VariableTable getVariableTable() + throws JdwpException; + + /** + * Returns a string representation of this method (not + * required but nice for debugging). + */ + public String toString() + { + return getDeclaringClass().getName() + "." + getName(); + } + + /** + * Writes the method's ID to the output stream + * + * @param ostream the output stream to which to write + * @throws IOException for any errors writing to the stream + * @see gnu.classpath.jdwp.id.JdwpId#write + */ + public void writeId(DataOutputStream ostream) + throws IOException + { + ostream.writeLong(getId()); + } + + /** + * Returns a VMMethod from the ID in the byte buffer + * + * @param klass the method's declaring class + * @param bb a ByteBuffer containing the method's ID + * @throws JdwpException for any errors creating the method + * @throws IOException for any errors reading from the buffer + */ + public static VMMethod readId(Class klass, ByteBuffer bb) + throws JdwpException, IOException + { + return VMVirtualMachine.getClassMethod(klass, bb.getLong()); + } +} diff --git a/libjava/classpath/vm/reference/gnu/classpath/jdwp/VMVirtualMachine.java b/libjava/classpath/vm/reference/gnu/classpath/jdwp/VMVirtualMachine.java index aa285cb..d861606 100644 --- a/libjava/classpath/vm/reference/gnu/classpath/jdwp/VMVirtualMachine.java +++ b/libjava/classpath/vm/reference/gnu/classpath/jdwp/VMVirtualMachine.java @@ -1,7 +1,7 @@ /* VMVirtualMachine.java -- A reference implementation of a JDWP virtual machine - Copyright (C) 2005 Free Software Foundation + Copyright (C) 2005, 2006 Free Software Foundation This file is part of GNU Classpath. @@ -42,16 +42,9 @@ exception statement from your version. */ package gnu.classpath.jdwp; import gnu.classpath.jdwp.event.EventRequest; +import gnu.classpath.jdwp.exception.InvalidMethodException; import gnu.classpath.jdwp.exception.JdwpException; -import gnu.classpath.jdwp.exception.InvalidClassException; -import gnu.classpath.jdwp.exception.InvalidObjectException; -import gnu.classpath.jdwp.id.ObjectId; -import gnu.classpath.jdwp.id.ReferenceTypeId; -import gnu.classpath.jdwp.util.LineTable; import gnu.classpath.jdwp.util.MethodResult; -import gnu.classpath.jdwp.util.VariableTable; - -import java.io.IOException; import java.lang.reflect.Method; import java.nio.ByteBuffer; import java.util.ArrayList; @@ -80,7 +73,7 @@ public class VMVirtualMachine { // Our JDWP thread group -- don't suspend any of those threads Thread current = Thread.currentThread (); - ThreadGroup jdwpGroup = current.getThreadGroup (); + ThreadGroup jdwpGroup = Jdwp.getDefault().getJdwpThreadGroup(); // Find the root ThreadGroup ThreadGroup group = jdwpGroup; @@ -112,7 +105,8 @@ public class VMVirtualMachine } // Now suspend the current thread - suspendThread (current); + if (current.getThreadGroup() != jdwpGroup) + suspendThread (current); } /** @@ -197,6 +191,29 @@ public class VMVirtualMachine public static native int getClassStatus (Class clazz) throws JdwpException; + /** + * Returns all of the methods defined in the given class. This + * includes all methods, constructors, and class initializers. + * + * @param klass the class whose methods are desired + * @return an array of virtual machine methods + */ + public static native VMMethod[] getAllClassMethods (Class klass) + { return null; } + + /** + * A factory method for getting valid virtual machine methods + * which may be passed to/from the debugger. + * + * @param klass the class in which the method is defined + * @param id the ID of the desired method + * @return the desired internal representation of the method + * @throws InvalidMethodException if the method is not defined + * in the class + * @throws JdwpException for any other error + */ + public static native VMMethod getClassMethod(Class klass, long id) + { return null; } /** * Returns the thread's call stack @@ -206,7 +223,7 @@ public class VMVirtualMachine * @param length number of frames to return (-1 for all frames) * @return a list of frames */ - public static native ArrayList getFrames (Thread thread, int strart, + public static native ArrayList getFrames (Thread thread, int start, int length) throws JdwpException; @@ -272,33 +289,6 @@ public class VMVirtualMachine throws JdwpException; /** - * "Returns variable information for the method. The variable table - * includes arguments and locals declared within the method. For instance - * methods, the "this" reference is included in the table. Also, synthetic - * variables may be present." - * - * @param clazz the class in which the method is defined - * @param method the method for which variable information is desired - * @return a result object containing the information - */ - public static native VariableTable getVarTable (Class clazz, Method method) - throws JdwpException; - - /** - * "Returns line number information for the method, if present. The line - * table maps source line numbers to the initial code index of the line. - * The line table is ordered by code index (from lowest to highest). The - * line number information is constant unless a new class definition is - * installed using RedefineClasses." - * - * @param clazz the class in which the method is defined - * @param method the method whose line table is desired - * @return a result object containing the line table - */ - public static native LineTable getLineTable (Class clazz, Method method) - throws JdwpException; - - /** * "Returns the name of source file in which a reference type was declared" * * @param clazz the class for which to return a source file diff --git a/libjava/classpath/vm/reference/gnu/java/lang/VMInstrumentationImpl.java b/libjava/classpath/vm/reference/gnu/java/lang/VMInstrumentationImpl.java new file mode 100644 index 0000000..eee9470 --- /dev/null +++ b/libjava/classpath/vm/reference/gnu/java/lang/VMInstrumentationImpl.java @@ -0,0 +1,108 @@ +/* VMInstrumentationImpl.java -- interface for the GNU implementation + of InstrumentationImpl + Copyright (C) 2005 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.java.lang; + +import java.lang.instrument.ClassDefinition; +import java.lang.instrument.Instrumentation; + +/** + * @author Nicolas Geoffray (nicolas.geoffray@menlina.com) + * @since 1.5 + */ +final class VMInstrumentationImpl +{ + + /** + * Returns if the current JVM supports class redefinition + * + * @return true if the current JVM supports class redefinition + */ + static native boolean isRedefineClassesSupported(); + + /** + * Redefines classes given as parameters. The method has to call + * the callTransformers from InstrumentationImpl + * + * @param inst an instrumentation object + * @param definitions an array of bytecode<->class correspondance + * + * @throws ClassNotFoundException if a class cannot be found + * @throws UnmodifiableClassException if a class cannot be modified + * @throws UnsupportedOperationException if the JVM does not support + * redefinition or the redefinition made unsupported changes + * @throws ClassFormatError if a class file is not valid + * @throws NoClassDefFoundError if a class name is not equal to the name + * in the class file specified + * @throws UnsupportedClassVersionError if the class file version numbers + * are unsupported + * @throws ClassCircularityError if circularity occured with the new + * classes + * @throws LinkageError if a linkage error occurs + */ + static native void redefineClasses(Instrumentation inst, + ClassDefinition[] definitions); + + /** + * Get all the classes loaded by the JVM. + * + * @return an array containing all the classes loaded by the JVM. The array + * is empty if no class is loaded. + */ + static native Class[] getAllLoadedClasses(); + + /** + * Get all the classes loaded by a given class loader + * + * @param loader the loader + * + * @return an array containing all the classes loaded by the given loader. + * The array is empty if no class was loaded by the loader. + */ + static native Class[] getInitiatedClasses(ClassLoader loader); + + /** + * Get the size of an object. The object is not null + * + * @param objectToSize the object + * @return the size of the object + */ + static native long getObjectSize(Object objectToSize); + +} diff --git a/libjava/classpath/vm/reference/java/lang/VMClass.java b/libjava/classpath/vm/reference/java/lang/VMClass.java index 1b4c13e..2596506 100644 --- a/libjava/classpath/vm/reference/java/lang/VMClass.java +++ b/libjava/classpath/vm/reference/java/lang/VMClass.java @@ -1,5 +1,5 @@ /* VMClass.java -- VM Specific Class methods - Copyright (C) 2003, 2004 Free Software Foundation + Copyright (C) 2003, 2004, 2005, 2006 Free Software Foundation This file is part of GNU Classpath. @@ -37,11 +37,14 @@ exception statement from your version. */ package java.lang; +import java.lang.annotation.Annotation; import java.lang.reflect.Array; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.lang.reflect.Modifier; +import java.lang.reflect.Type; +import java.lang.reflect.TypeVariable; /* * This class is a reference version, mainly for compiling a class library @@ -51,9 +54,11 @@ import java.lang.reflect.Modifier; /** * - * @author Etienne Gagnon <etienne.gagnon@uqam.ca> - * @author Archie Cobbs <archie@dellroad.org> - * @author C. Brian Jones <cbj@gnu.org> + * @author Etienne Gagnon (etienne.gagnon@uqam.ca) + * @author Archie Cobbs (archie@dellroad.org) + * @author C. Brian Jones (cbj@gnu.org) + * @author Tom Tromey (tromey@cygnus.com) + * @author Andrew John Hughes (gnu_andrew@member.fsf.org) */ final class VMClass { @@ -278,4 +283,172 @@ final class VMClass */ static native void throwException(Throwable t); + /** + * Returns the simple name for the specified class, as used in the source + * code. For normal classes, this is the content returned by + * <code>getName()</code> which follows the last ".". Anonymous + * classes have no name, and so the result of calling this method is + * "". The simple name of an array consists of the simple name of + * its component type, followed by "[]". Thus, an array with the + * component type of an anonymous class has a simple name of simply + * "[]". + * + * @param klass the class whose simple name should be returned. + * @return the simple name for this class. + */ + static String getSimpleName(Class klass) + { + if (isArray(klass)) + { + return getComponentType(klass).getSimpleName() + "[]"; + } + String fullName = getName(klass); + return fullName.substring(fullName.lastIndexOf(".") + 1); + } + + /** + * Returns all annotations directly defined by the specified class. If + * there are no annotations associated with this class, then a zero-length + * array will be returned. The returned array may be modified by the client + * code, but this will have no effect on the annotation content of this + * class, and hence no effect on the return value of this method for + * future callers. + * + * @param klass the class whose annotations should be returned. + * @return the annotations directly defined by the specified class. + * @since 1.5 + */ + static native Annotation[] getDeclaredAnnotations(Class klass); + + /** + * <p> + * Returns the canonical name of the specified class, as defined by section + * 6.7 of the Java language specification. Each package, top-level class, + * top-level interface and primitive type has a canonical name. A member + * class has a canonical name, if its parent class has one. Likewise, + * an array type has a canonical name, if its component type does. + * Local or anonymous classes do not have canonical names. + * </p> + * <p> + * The canonical name for top-level classes, top-level interfaces and + * primitive types is always the same as the fully-qualified name. + * For array types, the canonical name is the canonical name of its + * component type with `[]' appended. + * </p> + * <p> + * The canonical name of a member class always refers to the place where + * the class was defined, and is composed of the canonical name of the + * defining class and the simple name of the member class, joined by `.'. + * For example, if a <code>Person</code> class has an inner class, + * <code>M</code>, then both its fully-qualified name and canonical name + * is <code>Person.M</code>. A subclass, <code>Staff</code>, of + * <code>Person</code> refers to the same inner class by the fully-qualified + * name of <code>Staff.M</code>, but its canonical name is still + * <code>Person.M</code>. + * </p> + * <p> + * Where no canonical name is present, <code>null</code> is returned. + * </p> + * + * @param klass the class whose canonical name should be retrieved. + * @return the canonical name of the class, or <code>null</code> if the + * class doesn't have a canonical name. + * @since 1.5 + */ + static String getCanonicalName(Class klass) + { + if (isArray(klass)) + { + String componentName = getComponentType(klass).getCanonicalName(); + if (componentName != null) + return componentName + "[]"; + } + if (isMemberClass(klass)) + { + String memberName = getDeclaringClass(klass).getCanonicalName(); + if (memberName != null) + return memberName + "." + getSimpleName(klass); + } + if (isLocalClass(klass) || isAnonymousClass(klass)) + return null; + return getName(klass); + } + + /** + * Returns the class which immediately encloses the specified class. If + * the class is a top-level class, this method returns <code>null</code>. + * + * @param klass the class whose enclosing class should be returned. + * @return the immediate enclosing class, or <code>null</code> if this is + * a top-level class. + * @since 1.5 + */ + static native Class getEnclosingClass(Class klass); + + /** + * Returns the constructor which immediately encloses the specified class. + * If the class is a top-level class, or a local or anonymous class + * immediately enclosed by a type definition, instance initializer + * or static initializer, then <code>null</code> is returned. + * + * @param klass the class whose enclosing constructor should be returned. + * @return the immediate enclosing constructor if the specified class is + * declared within a constructor. Otherwise, <code>null</code> + * is returned. + * @since 1.5 + */ + static native Constructor getEnclosingConstructor(Class klass); + + /** + * Returns the method which immediately encloses the specified class. If + * the class is a top-level class, or a local or anonymous class + * immediately enclosed by a type definition, instance initializer + * or static initializer, then <code>null</code> is returned. + * + * @param klass the class whose enclosing method should be returned. + * @return the immediate enclosing method if the specified class is + * declared within a method. Otherwise, <code>null</code> + * is returned. + * @since 1.5 + */ + static native Method getEnclosingMethod(Class klass); + + /** + * Returns the class signature as specified in Class File Format + * chapter in the VM specification, or null if the class is not + * generic. + * + * @param klass the klass to test. + * @return a ClassSignature string. + * @since 1.5 + */ + static native String getClassSignature(Class klass); + + /** + * Returns true if the specified class represents an anonymous class. + * + * @param klass the klass to test. + * @return true if the specified class represents an anonymous class. + * @since 1.5 + */ + static native boolean isAnonymousClass(Class klass); + + /** + * Returns true if the specified class represents an local class. + * + * @param klass the klass to test. + * @return true if the specified class represents an local class. + * @since 1.5 + */ + static native boolean isLocalClass(Class klass); + + /** + * Returns true if the specified class represents an member class. + * + * @param klass the klass to test. + * @return true if the specified class represents an member class. + * @since 1.5 + */ + static native boolean isMemberClass(Class klass); + } // class VMClass diff --git a/libjava/classpath/vm/reference/java/lang/VMClassLoader.java b/libjava/classpath/vm/reference/java/lang/VMClassLoader.java index 7412afe..4caa58c 100644 --- a/libjava/classpath/vm/reference/java/lang/VMClassLoader.java +++ b/libjava/classpath/vm/reference/java/lang/VMClassLoader.java @@ -1,6 +1,6 @@ /* VMClassLoader.java -- Reference implementation of native interface required by ClassLoader - Copyright (C) 1998, 2001, 2002, 2004, 2005 Free Software Foundation + Copyright (C) 1998, 2001, 2002, 2004, 2005, 2006 Free Software Foundation This file is part of GNU Classpath. @@ -39,17 +39,23 @@ exception statement from your version. */ package java.lang; -import gnu.classpath.SystemProperties; import gnu.classpath.Configuration; +import gnu.classpath.SystemProperties; +import gnu.java.lang.InstrumentationImpl; +import java.io.BufferedReader; import java.io.File; import java.io.IOException; +import java.io.InputStreamReader; +import java.lang.instrument.Instrumentation; import java.net.MalformedURLException; import java.net.URL; import java.security.ProtectionDomain; import java.util.Enumeration; import java.util.HashMap; +import java.util.HashSet; import java.util.Map; +import java.util.Set; import java.util.StringTokenizer; import java.util.Vector; import java.util.zip.ZipFile; @@ -98,6 +104,7 @@ final class VMClassLoader "GNU Classpath", "GNU", Configuration.CLASSPATH_VERSION, + null, null); definedPackages.put(packages[i], p); @@ -235,12 +242,46 @@ final class VMClassLoader /** * Returns a String[] of native package names. The default - * implementation returns an empty array, or you may decide - * this needs native help. + * implementation tries to load a list of package from + * the META-INF/INDEX.LIST file in the boot jar file. + * If not found or if any exception is raised, it returns + * an empty array. You may decide this needs native help. */ private static String[] getBootPackages() { - return new String[0]; + URL indexList = getResource("META-INF/INDEX.LIST"); + if (indexList != null) + { + try + { + Set packageSet = new HashSet(); + String line; + int lineToSkip = 3; + BufferedReader reader = new BufferedReader( + new InputStreamReader( + indexList.openStream())); + while ((line = reader.readLine()) != null) + { + if (lineToSkip == 0) + { + if (line.length() == 0) + lineToSkip = 1; + else + packageSet.add(line.replace('/', '.')); + } + else + lineToSkip--; + } + reader.close(); + return (String[]) packageSet.toArray(new String[packageSet.size()]); + } + catch (IOException e) + { + return new String[0]; + } + } + else + return new String[0]; } @@ -345,4 +386,45 @@ final class VMClassLoader * for this class. */ static native Class findLoadedClass(ClassLoader cl, String name); + + /** + * The Instrumentation object created by the vm when agents are defined. + */ + static final Instrumentation instrumenter = null; + + /** + * Call the transformers of the possible Instrumentation object. This + * implementation assumes the instrumenter is a + * <code>InstrumentationImpl</code> object. VM implementors would + * have to redefine this method if they provide their own implementation + * of the <code>Instrumentation</code> interface. + * + * @param loader the initiating loader + * @param name the name of the class + * @param data the data representing the classfile, in classfile format + * @param offset the offset into the data where the classfile starts + * @param len the length of the classfile data in the array + * @param pd the protection domain + * @return the new data representing the classfile + */ + static final Class defineClassWithTransformers(ClassLoader loader, + String name, byte[] data, int offset, int len, ProtectionDomain pd) + { + + if (instrumenter != null) + { + byte[] modifiedData = new byte[len]; + System.arraycopy(data, offset, modifiedData, 0, len); + modifiedData = + ((InstrumentationImpl)instrumenter).callTransformers(loader, name, + null, pd, modifiedData); + + return defineClass(loader, name, modifiedData, 0, modifiedData.length, + pd); + } + else + { + return defineClass(loader, name, data, offset, len, pd); + } + } } diff --git a/libjava/classpath/vm/reference/java/lang/VMProcess.java b/libjava/classpath/vm/reference/java/lang/VMProcess.java index 26cfcc9..076e599 100644 --- a/libjava/classpath/vm/reference/java/lang/VMProcess.java +++ b/libjava/classpath/vm/reference/java/lang/VMProcess.java @@ -42,7 +42,10 @@ import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.util.HashMap; +import java.util.Iterator; import java.util.LinkedList; +import java.util.List; +import java.util.Map; /** * Represents one external process. Each instance of this class is in @@ -92,6 +95,7 @@ final class VMProcess extends Process InputStream stdout; // process output stream InputStream stderr; // process error stream int exitValue; // process exit value + boolean redirect; // redirect stderr -> stdout // // Dedicated thread that does all the fork()'ing and wait()'ing @@ -196,7 +200,8 @@ final class VMProcess extends Process { try { - process.nativeSpawn(process.cmd, process.env, process.dir); + process.nativeSpawn(process.cmd, process.env, process.dir, + process.redirect); process.state = RUNNING; activeMap.put(new Long(process.pid), process); } @@ -215,7 +220,8 @@ final class VMProcess extends Process } // Constructor - private VMProcess(String[] cmd, String[] env, File dir) throws IOException + private VMProcess(String[] cmd, String[] env, File dir, boolean redirect) + throws IOException { // Initialize this process @@ -223,6 +229,7 @@ final class VMProcess extends Process this.cmd = cmd; this.env = env; this.dir = dir; + this.redirect = redirect; // Add process to the new process work list and wakeup processThread synchronized (workList) @@ -275,11 +282,20 @@ final class VMProcess extends Process // Invoked by native code (from nativeSpawn()) to record process info. private void setProcessInfo(OutputStream stdin, - InputStream stdout, InputStream stderr, long pid) + InputStream stdout, InputStream stderr, long pid) { this.stdin = stdin; this.stdout = stdout; - this.stderr = stderr; + if (stderr == null) + this.stderr = new InputStream() + { + public int read() throws IOException + { + return -1; + } + }; + else + this.stderr = stderr; this.pid = pid; } @@ -288,7 +304,24 @@ final class VMProcess extends Process */ static Process exec(String[] cmd, String[] env, File dir) throws IOException { - return new VMProcess(cmd, env, dir); + return new VMProcess(cmd, env, dir, false); + } + + static Process exec(List cmd, Map env, + File dir, boolean redirect) throws IOException + { + String[] acmd = (String[]) cmd.toArray(new String[cmd.size()]); + String[] aenv = new String[env.size()]; + + int i = 0; + Iterator iter = env.entrySet().iterator(); + while (iter.hasNext()) + { + Map.Entry entry = (Map.Entry) iter.next(); + aenv[i++] = entry.getKey() + "=" + entry.getValue(); + } + + return new VMProcess(acmd, aenv, dir, redirect); } public OutputStream getOutputStream() @@ -347,7 +380,8 @@ final class VMProcess extends Process * * @throws IOException if the O/S process could not be created. */ - native void nativeSpawn(String[] cmd, String[] env, File dir) + native void nativeSpawn(String[] cmd, String[] env, File dir, + boolean redirect) throws IOException; /** diff --git a/libjava/classpath/vm/reference/java/lang/VMSystem.java b/libjava/classpath/vm/reference/java/lang/VMSystem.java index 8a83cad..f96986d 100644 --- a/libjava/classpath/vm/reference/java/lang/VMSystem.java +++ b/libjava/classpath/vm/reference/java/lang/VMSystem.java @@ -37,6 +37,8 @@ exception statement from your version. */ package java.lang; +import java.util.List; + import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.FileDescriptor; @@ -50,6 +52,7 @@ import java.io.PrintStream; * VM must implement. * * @author John Keiser + * @author Andrew John Hughes (gnu_andrew@member.fsf.org) */ final class VMSystem { @@ -135,40 +138,76 @@ final class VMSystem public static native long currentTimeMillis(); /** + * <p> + * Returns the current value of a nanosecond-precise system timer. + * The value of the timer is an offset relative to some arbitrary fixed + * time, which may be in the future (making the value negative). This + * method is useful for timing events where nanosecond precision is + * required. This is achieved by calling this method before and after the + * event, and taking the difference betweent the two times: + * </p> + * <p> + * <code>long startTime = System.nanoTime();</code><br /> + * <code>... <emph>event code</emph> ...</code><br /> + * <code>long endTime = System.nanoTime();</code><br /> + * <code>long duration = endTime - startTime;</code><br /> + * </p> + * <p> + * Note that the value is only nanosecond-precise, and not accurate; there + * is no guarantee that the difference between two values is really a + * nanosecond. Also, the value is prone to overflow if the offset + * exceeds 2^63. + * </p> + * + * @return the time of a system timer in nanoseconds. + * @since 1.5 + */ + public static long nanoTime() + { + return currentTimeMillis() * 1000; + } + + /** + * Returns a list of 'name=value' pairs representing the current environment + * variables. + * + * @return a list of 'name=value' pairs. + */ + static native List environ(); + + /** * Helper method which creates the standard input stream. * VM implementors may choose to construct these streams differently. * This method can also return null if the stream is created somewhere * else in the VM startup sequence. */ - - static InputStream makeStandardInputStream() - { - return new BufferedInputStream(new FileInputStream(FileDescriptor.in)); - } - + static InputStream makeStandardInputStream() + { + return new BufferedInputStream(new FileInputStream(FileDescriptor.in)); + } + /** * Helper method which creates the standard output stream. * VM implementors may choose to construct these streams differently. * This method can also return null if the stream is created somewhere * else in the VM startup sequence. */ + static PrintStream makeStandardOutputStream() + { + return new PrintStream(new BufferedOutputStream(new FileOutputStream(FileDescriptor.out)), true); + } - static PrintStream makeStandardOutputStream() - { - return new PrintStream(new BufferedOutputStream(new FileOutputStream(FileDescriptor.out)), true); - } /** * Helper method which creates the standard error stream. * VM implementors may choose to construct these streams differently. * This method can also return null if the stream is created somewhere * else in the VM startup sequence. */ - - static PrintStream makeStandardErrorStream() - { - return new PrintStream(new BufferedOutputStream(new FileOutputStream(FileDescriptor.err)), true); - } - + static PrintStream makeStandardErrorStream() + { + return new PrintStream(new BufferedOutputStream(new FileOutputStream(FileDescriptor.err)), true); + } + /** * Gets the value of an environment variable. * Always returning null is a valid (but not very useful) implementation. diff --git a/libjava/classpath/vm/reference/java/lang/VMThread.java b/libjava/classpath/vm/reference/java/lang/VMThread.java index aa0b834..302de6c 100644 --- a/libjava/classpath/vm/reference/java/lang/VMThread.java +++ b/libjava/classpath/vm/reference/java/lang/VMThread.java @@ -1,5 +1,5 @@ /* VMThread -- VM interface for Thread of executable code - Copyright (C) 2003, 2004, 2005 Free Software Foundation + Copyright (C) 2003, 2004, 2005, 2006 Free Software Foundation This file is part of GNU Classpath. @@ -123,7 +123,9 @@ final class VMThread { try { - thread.group.uncaughtException(thread, t); + Thread.UncaughtExceptionHandler handler; + handler = thread.getUncaughtExceptionHandler(); + handler.uncaughtException(thread, t); } catch(Throwable ignore) { diff --git a/libjava/classpath/vm/reference/java/lang/reflect/Constructor.java b/libjava/classpath/vm/reference/java/lang/reflect/Constructor.java index cb633db..521190b 100644 --- a/libjava/classpath/vm/reference/java/lang/reflect/Constructor.java +++ b/libjava/classpath/vm/reference/java/lang/reflect/Constructor.java @@ -1,5 +1,5 @@ /* java.lang.reflect.Constructor - reflection of Java constructors - Copyright (C) 1998, 2001 Free Software Foundation, Inc. + Copyright (C) 1998, 2001, 2004, 2005 Free Software Foundation, Inc. This file is part of GNU Classpath. @@ -38,6 +38,10 @@ exception statement from your version. */ package java.lang.reflect; +import gnu.java.lang.ClassHelper; + +import gnu.java.lang.reflect.MethodSignatureParser; + import java.util.Arrays; /** @@ -74,11 +78,15 @@ import java.util.Arrays; * @status updated to 1.4 */ public final class Constructor -extends AccessibleObject implements Member + extends AccessibleObject + implements GenericDeclaration, Member { private Class clazz; private int slot; + private static final int CONSTRUCTOR_MODIFIERS + = Modifier.PRIVATE | Modifier.PROTECTED | Modifier.PUBLIC; + /** * This class is uninstantiable except from native code. */ @@ -112,6 +120,13 @@ extends AccessibleObject implements Member } /** + * Return the raw modifiers for this constructor. In particular + * this will include the synthetic and varargs bits. + * @return the constructor's modifiers + */ + private native int getModifiersInternal(); + + /** * Gets the modifiers this constructor uses. Use the <code>Modifier</code> * class to interpret the values. A constructor can only have a subset of the * following modifiers: public, private, protected. @@ -119,7 +134,31 @@ extends AccessibleObject implements Member * @return an integer representing the modifiers to this Member * @see Modifier */ - public native int getModifiers(); + public int getModifiers() + { + return getModifiersInternal() & CONSTRUCTOR_MODIFIERS; + } + + /** + * Return true if this constructor is synthetic, false otherwise. + * A synthetic member is one which is created by the compiler, + * and which does not appear in the user's source code. + * @since 1.5 + */ + public boolean isSynthetic() + { + return (getModifiersInternal() & Modifier.SYNTHETIC) != 0; + } + + /** + * Return true if this is a varargs constructor, that is if + * the constructor takes a variable number of arguments. + * @since 1.5 + */ + public boolean isVarArgs() + { + return (getModifiersInternal() & Modifier.VARARGS) != 0; + } /** * Get the parameter list for this constructor, in declaration order. If the @@ -184,15 +223,15 @@ extends AccessibleObject implements Member public String toString() { // 128 is a reasonable buffer initial size for constructor - StringBuffer sb = new StringBuffer(128); + StringBuilder sb = new StringBuilder(128); Modifier.toString(getModifiers(), sb).append(' '); sb.append(getDeclaringClass().getName()).append('('); Class[] c = getParameterTypes(); if (c.length > 0) { - sb.append(c[0].getName()); + sb.append(ClassHelper.getUserName(c[0])); for (int i = 1; i < c.length; i++) - sb.append(',').append(c[i].getName()); + sb.append(',').append(ClassHelper.getUserName(c[i])); } sb.append(')'); c = getExceptionTypes(); @@ -204,7 +243,46 @@ extends AccessibleObject implements Member } return sb.toString(); } - + + /* FIXME[GENERICS]: Add X extends GenericDeclaration and TypeVariable<X> */ + static void addTypeParameters(StringBuilder sb, TypeVariable[] typeArgs) + { + if (typeArgs.length == 0) + return; + sb.append('<'); + for (int i = 0; i < typeArgs.length; ++i) + { + if (i > 0) + sb.append(','); + sb.append(typeArgs[i]); + } + sb.append("> "); + } + + public String toGenericString() + { + StringBuilder sb = new StringBuilder(128); + Modifier.toString(getModifiers(), sb).append(' '); + addTypeParameters(sb, getTypeParameters()); + sb.append(getDeclaringClass().getName()).append('('); + Type[] types = getGenericParameterTypes(); + if (types.length > 0) + { + sb.append(types[0]); + for (int i = 1; i < types.length; ++i) + sb.append(',').append(types[i]); + } + sb.append(')'); + types = getGenericExceptionTypes(); + if (types.length > 0) + { + sb.append(" throws ").append(types[0]); + for (int i = 1; i < types.length; i++) + sb.append(',').append(types[i]); + } + return sb.toString(); + } + /** * Create a new instance by invoking the constructor. Arguments are * automatically unwrapped and widened, if needed.<p> @@ -246,4 +324,75 @@ extends AccessibleObject implements Member int slot) throws InstantiationException, IllegalAccessException, InvocationTargetException; + + /** + * Returns an array of <code>TypeVariable</code> objects that represents + * the type variables declared by this constructor, in declaration order. + * An array of size zero is returned if this constructor has no type + * variables. + * + * @return the type variables associated with this constructor. + * @throws GenericSignatureFormatError if the generic signature does + * not conform to the format specified in the Virtual Machine + * specification, version 3. + * @since 1.5 + */ + /* FIXME[GENERICS]: Add <Constructor<T>> */ + public TypeVariable[] getTypeParameters() + { + String sig = getSignature(); + if (sig == null) + return new TypeVariable[0]; + MethodSignatureParser p = new MethodSignatureParser(this, sig); + return p.getTypeParameters(); + } + + /** + * Return the String in the Signature attribute for this constructor. If there + * is no Signature attribute, return null. + */ + private native String getSignature(); + + /** + * Returns an array of <code>Type</code> objects that represents + * the exception types declared by this constructor, in declaration order. + * An array of size zero is returned if this constructor declares no + * exceptions. + * + * @return the exception types declared by this constructor. + * @throws GenericSignatureFormatError if the generic signature does + * not conform to the format specified in the Virtual Machine + * specification, version 3. + * @since 1.5 + */ + public Type[] getGenericExceptionTypes() + { + String sig = getSignature(); + if (sig == null) + return getExceptionTypes(); + MethodSignatureParser p = new MethodSignatureParser(this, sig); + return p.getGenericExceptionTypes(); + } + + /** + * Returns an array of <code>Type</code> objects that represents + * the parameter list for this constructor, in declaration order. + * An array of size zero is returned if this constructor takes no + * parameters. + * + * @return a list of the types of the constructor's parameters + * @throws GenericSignatureFormatError if the generic signature does + * not conform to the format specified in the Virtual Machine + * specification, version 3. + * @since 1.5 + */ + public Type[] getGenericParameterTypes() + { + String sig = getSignature(); + if (sig == null) + return getParameterTypes(); + MethodSignatureParser p = new MethodSignatureParser(this, sig); + return p.getGenericParameterTypes(); + } } + diff --git a/libjava/classpath/vm/reference/java/lang/reflect/Field.java b/libjava/classpath/vm/reference/java/lang/reflect/Field.java index 85e76d6..5121700 100644 --- a/libjava/classpath/vm/reference/java/lang/reflect/Field.java +++ b/libjava/classpath/vm/reference/java/lang/reflect/Field.java @@ -1,5 +1,5 @@ /* java.lang.reflect.Field - reflection of Java fields - Copyright (C) 1998, 2001 Free Software Foundation, Inc. + Copyright (C) 1998, 2001, 2005 Free Software Foundation, Inc. This file is part of GNU Classpath. @@ -38,6 +38,10 @@ exception statement from your version. */ package java.lang.reflect; +import gnu.java.lang.ClassHelper; + +import gnu.java.lang.reflect.FieldSignatureParser; + /** * The Field class represents a member variable of a class. It also allows * dynamic access to a member, via reflection. This works for both @@ -78,6 +82,11 @@ extends AccessibleObject implements Member private String name; private int slot; + private static final int FIELD_MODIFIERS + = Modifier.FINAL | Modifier.PRIVATE | Modifier.PROTECTED + | Modifier.PUBLIC | Modifier.STATIC | Modifier.TRANSIENT + | Modifier.VOLATILE; + /** * This class is uninstantiable except natively. */ @@ -108,6 +117,12 @@ extends AccessibleObject implements Member } /** + * Return the raw modifiers for this field. + * @return the field's modifiers + */ + private native int getModifiersInternal(); + + /** * Gets the modifiers this field uses. Use the <code>Modifier</code> * class to interpret the values. A field can only have a subset of the * following modifiers: public, private, protected, static, final, @@ -116,7 +131,29 @@ extends AccessibleObject implements Member * @return an integer representing the modifiers to this Member * @see Modifier */ - public native int getModifiers(); + public int getModifiers() + { + return getModifiersInternal() & FIELD_MODIFIERS; + } + + /** + * Return true if this field is synthetic, false otherwise. + * @since 1.5 + */ + public boolean isSynthetic() + { + return (getModifiersInternal() & Modifier.SYNTHETIC) != 0; + } + + /** + * Return true if this field represents an enum constant, + * false otherwise. + * @since 1.5 + */ + public boolean isEnumConstant() + { + return (getModifiersInternal() & Modifier.ENUM) != 0; + } /** * Gets the type of this field. @@ -169,14 +206,24 @@ extends AccessibleObject implements Member public String toString() { // 64 is a reasonable buffer initial size for field - StringBuffer sb = new StringBuffer(64); + StringBuilder sb = new StringBuilder(64); Modifier.toString(getModifiers(), sb).append(' '); - sb.append(getType().getName()).append(' '); + sb.append(ClassHelper.getUserName(getType())).append(' '); sb.append(getDeclaringClass().getName()).append('.'); sb.append(getName()); return sb.toString(); } + public String toGenericString() + { + StringBuilder sb = new StringBuilder(64); + Modifier.toString(getModifiers(), sb).append(' '); + sb.append(getGenericType()).append(' '); + sb.append(getDeclaringClass().getName()).append('.'); + sb.append(getName()); + return sb.toString(); + } + /** * Get the value of this Field. If it is primitive, it will be wrapped * in the appropriate wrapper type (boolean = java.lang.Boolean).<p> @@ -586,4 +633,30 @@ extends AccessibleObject implements Member */ public native void setDouble(Object o, double value) throws IllegalAccessException; + + /** + * Return the generic type of the field. If the field type is not a generic + * type, the method returns the same as <code>getType()</code>. + * + * @throws GenericSignatureFormatError if the generic signature does + * not conform to the format specified in the Virtual Machine + * specification, version 3. + * @since 1.5 + */ + public Type getGenericType() + { + String signature = getSignature(); + if (signature == null) + return getType(); + FieldSignatureParser p = new FieldSignatureParser(getDeclaringClass(), + signature); + return p.getFieldType(); + } + + /** + * Return the String in the Signature attribute for this field. If there + * is no Signature attribute, return null. + */ + private native String getSignature(); + } diff --git a/libjava/classpath/vm/reference/java/lang/reflect/Method.java b/libjava/classpath/vm/reference/java/lang/reflect/Method.java index 2725677..a992024 100644 --- a/libjava/classpath/vm/reference/java/lang/reflect/Method.java +++ b/libjava/classpath/vm/reference/java/lang/reflect/Method.java @@ -1,5 +1,5 @@ /* java.lang.reflect.Method - reflection of Java methods - Copyright (C) 1998, 2001, 2002 Free Software Foundation, Inc. + Copyright (C) 1998, 2001, 2002, 2005 Free Software Foundation, Inc. This file is part of GNU Classpath. @@ -38,6 +38,10 @@ exception statement from your version. */ package java.lang.reflect; +import gnu.java.lang.ClassHelper; + +import gnu.java.lang.reflect.MethodSignatureParser; + import java.util.Arrays; /** @@ -74,12 +78,17 @@ import java.util.Arrays; * @status updated to 1.4 */ public final class Method -extends AccessibleObject implements Member +extends AccessibleObject implements Member, GenericDeclaration { Class declaringClass; String name; int slot; + private static final int METHOD_MODIFIERS + = Modifier.ABSTRACT | Modifier.FINAL | Modifier.NATIVE + | Modifier.PRIVATE | Modifier.PROTECTED | Modifier.PUBLIC + | Modifier.STATIC | Modifier.STRICT | Modifier.SYNCHRONIZED; + /** * This class is uninstantiable. */ @@ -110,6 +119,12 @@ extends AccessibleObject implements Member } /** + * Return the raw modifiers for this method. + * @return the method's modifiers + */ + private native int getModifiersInternal(); + + /** * Gets the modifiers this method uses. Use the <code>Modifier</code> * class to interpret the values. A method can only have a subset of the * following modifiers: public, private, protected, abstract, static, @@ -118,7 +133,40 @@ extends AccessibleObject implements Member * @return an integer representing the modifiers to this Member * @see Modifier */ - public native int getModifiers(); + public int getModifiers() + { + return getModifiersInternal() & METHOD_MODIFIERS; + } + + /** + * Return true if this method is a bridge method. A bridge method + * is generated by the compiler in some situations involving + * generics and inheritance. + * @since 1.5 + */ + public boolean isBridge() + { + return (getModifiersInternal() & Modifier.BRIDGE) != 0; + } + + /** + * Return true if this method is synthetic, false otherwise. + * @since 1.5 + */ + public boolean isSynthetic() + { + return (getModifiersInternal() & Modifier.SYNTHETIC) != 0; + } + + /** + * Return true if this is a varargs method, that is if + * the method takes a variable number of arguments. + * @since 1.5 + */ + public boolean isVarArgs() + { + return (getModifiersInternal() & Modifier.VARARGS) != 0; + } /** * Gets the return type of this method. @@ -210,17 +258,17 @@ extends AccessibleObject implements Member public String toString() { // 128 is a reasonable buffer initial size for constructor - StringBuffer sb = new StringBuffer(128); + StringBuilder sb = new StringBuilder(128); Modifier.toString(getModifiers(), sb).append(' '); - sb.append(getUserTypeName(getReturnType().getName())).append(' '); + sb.append(ClassHelper.getUserName(getReturnType())).append(' '); sb.append(getDeclaringClass().getName()).append('.'); sb.append(getName()).append('('); Class[] c = getParameterTypes(); if (c.length > 0) { - sb.append(getUserTypeName(c[0].getName())); + sb.append(ClassHelper.getUserName(c[0])); for (int i = 1; i < c.length; i++) - sb.append(',').append(getUserTypeName(c[i].getName())); + sb.append(',').append(ClassHelper.getUserName(c[i])); } sb.append(')'); c = getExceptionTypes(); @@ -233,53 +281,31 @@ extends AccessibleObject implements Member return sb.toString(); } - private static String getUserTypeName(String typeSpec) + public String toGenericString() { - int pos = 0; - String typeName = ""; - String arrayPart = ""; - - while (typeSpec.charAt(pos) == '[') + // 128 is a reasonable buffer initial size for constructor + StringBuilder sb = new StringBuilder(128); + Modifier.toString(getModifiers(), sb).append(' '); + Constructor.addTypeParameters(sb, getTypeParameters()); + sb.append(getGenericReturnType()).append(' '); + sb.append(getDeclaringClass().getName()).append('.'); + sb.append(getName()).append('('); + Type[] types = getGenericParameterTypes(); + if (types.length > 0) { - arrayPart += "[]"; - ++pos; + sb.append(types[0]); + for (int i = 1; i < types.length; i++) + sb.append(',').append(types[i]); } - - switch (typeSpec.charAt(pos)) + sb.append(')'); + types = getGenericExceptionTypes(); + if (types.length > 0) { - case 'Z': - typeName = "boolean"; - break; - case 'B': - typeName = "byte"; - break; - case 'C': - typeName = "char"; - break; - case 'D': - typeName = "double"; - break; - case 'F': - typeName = "float"; - break; - case 'I': - typeName = "int"; - break; - case 'J': - typeName = "long"; - break; - case 'S': - typeName = "short"; - break; - case 'L': - typeName = typeSpec.substring(pos + 1, typeSpec.length() - 1); - break; - default: - typeName = typeSpec; - break; + sb.append(" throws ").append(types[0]); + for (int i = 1; i < types.length; i++) + sb.append(',').append(types[i]); } - - return typeName + arrayPart; + return sb.toString(); } /** @@ -336,4 +362,93 @@ extends AccessibleObject implements Member private native Object invokeNative(Object o, Object[] args, Class declaringClass, int slot) throws IllegalAccessException, InvocationTargetException; + + /** + * Returns an array of <code>TypeVariable</code> objects that represents + * the type variables declared by this constructor, in declaration order. + * An array of size zero is returned if this class has no type + * variables. + * + * @return the type variables associated with this class. + * @throws GenericSignatureFormatError if the generic signature does + * not conform to the format specified in the Virtual Machine + * specification, version 3. + * @since 1.5 + */ + /* FIXME[GENERICS]: Should be TypeVariable<Method>[] */ + public TypeVariable[] getTypeParameters() + { + String sig = getSignature(); + if (sig == null) + return new TypeVariable[0]; + MethodSignatureParser p = new MethodSignatureParser(this, sig); + return p.getTypeParameters(); + } + + /** + * Return the String in the Signature attribute for this method. If there + * is no Signature attribute, return null. + */ + private native String getSignature(); + + /** + * Returns an array of <code>Type</code> objects that represents + * the exception types declared by this method, in declaration order. + * An array of size zero is returned if this method declares no + * exceptions. + * + * @return the exception types declared by this method. + * @throws GenericSignatureFormatError if the generic signature does + * not conform to the format specified in the Virtual Machine + * specification, version 3. + * @since 1.5 + */ + public Type[] getGenericExceptionTypes() + { + String sig = getSignature(); + if (sig == null) + return getExceptionTypes(); + MethodSignatureParser p = new MethodSignatureParser(this, sig); + return p.getGenericExceptionTypes(); + } + + /** + * Returns an array of <code>Type</code> objects that represents + * the parameter list for this method, in declaration order. + * An array of size zero is returned if this method takes no + * parameters. + * + * @return a list of the types of the method's parameters + * @throws GenericSignatureFormatError if the generic signature does + * not conform to the format specified in the Virtual Machine + * specification, version 3. + * @since 1.5 + */ + public Type[] getGenericParameterTypes() + { + String sig = getSignature(); + if (sig == null) + return getParameterTypes(); + MethodSignatureParser p = new MethodSignatureParser(this, sig); + return p.getGenericParameterTypes(); + } + + /** + * Returns the return type of this method. + * + * @return the return type of this method + * @throws GenericSignatureFormatError if the generic signature does + * not conform to the format specified in the Virtual Machine + * specification, version 3. + * @since 1.5 + */ + public Type getGenericReturnType() + { + String sig = getSignature(); + if (sig == null) + return getReturnType(); + MethodSignatureParser p = new MethodSignatureParser(this, sig); + return p.getGenericReturnType(); + } } + diff --git a/libjava/classpath/vm/reference/java/lang/reflect/VMArray.java b/libjava/classpath/vm/reference/java/lang/reflect/VMArray.java new file mode 100644 index 0000000..d6277ae --- /dev/null +++ b/libjava/classpath/vm/reference/java/lang/reflect/VMArray.java @@ -0,0 +1,65 @@ +/* java.lang.reflect.VMArray - VM class for array manipulation by reflection. + Copyright (C) 1998, 1999, 2001, 2003, 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +package java.lang.reflect; + +import gnu.classpath.Configuration; + +class VMArray +{ + + static + { + if (Configuration.INIT_LOAD_LIBRARY) + { + System.loadLibrary("javalangreflect"); + } + } + + /** + * Dynamically create an array of objects. + * + * @param type guaranteed to be a valid object type + * @param dim the length of the array + * @return the new array + * @throws NegativeArraySizeException if dim is negative + * @throws OutOfMemoryError if memory allocation fails + */ + static native Object createObjectArray(Class type, int dim); + +} diff --git a/libjava/classpath/vm/reference/java/security/VMSecureRandom.java b/libjava/classpath/vm/reference/java/security/VMSecureRandom.java new file mode 100644 index 0000000..dc67d87 --- /dev/null +++ b/libjava/classpath/vm/reference/java/security/VMSecureRandom.java @@ -0,0 +1,134 @@ +/* VMSecureRandom.java -- random seed generator. + Copyright (C) 2006 Free Software Foundation, Inc. + +This file is a 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 of the License, 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; if not, write to the Free Software +Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 +USA + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +package java.security; + +import gnu.classpath.SystemProperties; +import gnu.java.security.action.GetSecurityPropertyAction; + +import java.net.URL; + +/** + * VM-specific methods for generating real (or almost real) random + * seeds. VM implementors should write a version of this class that + * reads random bytes from some system source. + * + * <p>The default implementation of this class runs eight threads that + * increment counters in a tight loop, and XORs each counter to + * produce one byte of seed data. This is not very efficient, and is + * not guaranteed to be random (the thread scheduler is probably + * deterministic, after all). If possible, VM implementors should + * reimplement this class so it obtains a random seed from a system + * facility, such as a system entropy gathering device or hardware + * random number generator. + */ +final class VMSecureRandom +{ + + /** + * Generate a random seed. Implementations are free to generate + * fewer random bytes than are requested, and leave the remaining + * bytes of the destination buffer as zeros. Implementations SHOULD, + * however, make a best-effort attempt to satisfy the request. + * + * @param buffer The destination buffer. + * @param offset The offset in the buffer to start putting bytes. + * @param length The number of random bytes to generate. + */ + static int generateSeed(byte[] buffer, int offset, int length) + { + if (length < 0) + throw new IllegalArgumentException("length must be nonnegative"); + if (offset < 0 || offset + length > buffer.length) + throw new IndexOutOfBoundsException(); + + Spinner[] spinners = new Spinner[8]; + int n = 0x1; + for (int i = 0; i < spinners.length; i++) + { + spinners[i] = new Spinner((byte) n); + Thread t = new Thread(spinners[i]); + t.start(); + n <<= 1; + } + + // Wait until at least one spinner has started. + while (!(spinners[0].running || spinners[1].running || spinners[2].running + || spinners[3].running || spinners[4].running || spinners[5].running + || spinners[6].running || spinners[7].running)) + { + Thread.yield(); + } + + for (int i = offset; i < length; i++) + { + buffer[i] = (byte) (spinners[0].value ^ spinners[1].value ^ spinners[2].value + ^ spinners[3].value ^ spinners[4].value ^ spinners[5].value + ^ spinners[6].value ^ spinners[7].value); + Thread.yield(); + } + + for (int i = 0; i < spinners.length; i++) + spinners[i].stop(); + + return length; + } + + static class Spinner implements Runnable + { + volatile byte value; + volatile boolean running; + + Spinner(final byte initial) + { + value = initial; + } + + public void run() + { + running = true; + while (running) + value++; + } + + private void stop() + { + running = false; + } + } +}
\ No newline at end of file |