yggdrasil/gcc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Imported GNU Classpath 0.90

Browse Source 
Imported GNU Classpath 0.90
       * scripts/makemake.tcl: LocaleData.java moved to gnu/java/locale.

       * sources.am: Regenerated.
       * gcj/javaprims.h: Regenerated.
       * Makefile.in: Regenerated.
       * gcj/Makefile.in: Regenerated.
       * include/Makefile.in: Regenerated.
       * testsuite/Makefile.in: Regenerated.

       * gnu/java/lang/VMInstrumentationImpl.java: New override.
       * gnu/java/net/local/LocalSocketImpl.java: Likewise.
       * gnu/classpath/jdwp/VMMethod.java: Likewise.
       * gnu/classpath/jdwp/VMVirtualMachine.java: Update to latest
       interface.
       * java/lang/Thread.java: Add UncaughtExceptionHandler.
       * java/lang/reflect/Method.java: Implements GenericDeclaration and
       isSynthetic(),
       * java/lang/reflect/Field.java: Likewise.
       * java/lang/reflect/Constructor.java
       * java/lang/Class.java: Implements Type, GenericDeclaration,
       getSimpleName() and getEnclosing*() methods.
       * java/lang/Class.h: Add new public methods.
       * java/lang/Math.java: Add signum(), ulp() and log10().
       * java/lang/natMath.cc (log10): New function.
       * java/security/VMSecureRandom.java: New override.
       * java/util/logging/Logger.java: Updated to latest classpath
       version.
       * java/util/logging/LogManager.java: New override.

From-SVN: r113887
This commit is contained in:
Mark Wielaard
2006-05-18 17:29:21 +00:00
parent eaec4980e1
commit 4f9533c772
1640 changed files with 126485 additions and 104808 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libjava/classpath/vm/reference/gnu/classpath/Unsafe.java
+328
View File
@@ -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);
}
libjava/classpath/vm/reference/gnu/classpath/jdwp/VMIdManager.java
+2 -4
View File
@@ -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.
*/
libjava/classpath/vm/reference/gnu/classpath/jdwp/VMMethod.java
+178
View File
@@ -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());
}
}
libjava/classpath/vm/reference/gnu/classpath/jdwp/VMVirtualMachine.java
+29 -39
View File
@@ -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;
@@ -271,33 +288,6 @@ public class VMVirtualMachine
boolean nonVirtual)
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"
*
libjava/classpath/vm/reference/gnu/java/lang/VMInstrumentationImpl.java
+108
View File
@@ -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);
}
libjava/classpath/vm/reference/java/lang/VMClass.java
+177 -4
View File
@@ -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
libjava/classpath/vm/reference/java/lang/VMClassLoader.java
+87 -5
View File
@@ -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);
}
}
}
libjava/classpath/vm/reference/java/lang/VMProcess.java
+40 -6
View File
@@ -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;
/**
libjava/classpath/vm/reference/java/lang/VMSystem.java
+55 -16
View File
@@ -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
{
@@ -134,41 +137,77 @@ 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.
libjava/classpath/vm/reference/java/lang/VMThread.java
+4 -2
View File
@@ -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)
{
libjava/classpath/vm/reference/java/lang/reflect/Constructor.java
+156 -7
View File
@@ -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.
*/
@@ -111,6 +119,13 @@ extends AccessibleObject implements Member
return getDeclaringClass().getName();
}
/**
* 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
@@ -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();
}
}
libjava/classpath/vm/reference/java/lang/reflect/Field.java
+77 -4
View File
@@ -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.
*/
@@ -107,6 +116,12 @@ extends AccessibleObject implements Member
return name;
}
/**
* 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
@@ -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();
}
libjava/classpath/vm/reference/java/lang/reflect/Method.java
+164 -49
View File
@@ -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.
*/
@@ -109,6 +118,12 @@ extends AccessibleObject implements Member
return name;
}
/**
* 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
@@ -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();
}
}
libjava/classpath/vm/reference/java/lang/reflect/VMArray.java
+65
View File
@@ -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);
}
libjava/classpath/vm/reference/java/security/VMSecureRandom.java
+134
View File
@@ -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;
}
}
}