FreeChainXenon/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

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

29
libjava/classpath/java/lang/reflect/AccessibleObject.java
View file

@ -1,5 +1,5 @@
/* java.lang.reflect.AccessibleObject
Copyright (C) 2001, 2005 Free Software Foundation, Inc.
Copyright (C) 2001, 2005, 2006 Free Software Foundation, Inc.
This file is part of GNU Classpath.
@ -38,6 +38,8 @@ exception statement from your version. */
package java.lang.reflect;
import java.lang.annotation.Annotation;
/**
* This class is the superclass of various reflection classes, and
* allows sufficiently trusted code to bypass normal restrictions to
@ -53,9 +55,10 @@ package java.lang.reflect;
* @see Method
* @see ReflectPermission
* @since 1.2
* @status updated to 1.4
* @status updated to 1.5
*/
public class AccessibleObject
implements AnnotatedElement
{
/**
* True if this object is marked accessible, which means the reflected
@ -156,4 +159,26 @@ public class AccessibleObject
throw new SecurityException("Cannot make object accessible: " + this);
this.flag = flag;
}
/* FIXME[GENERICS]: <T extends Annotation> T getAnnotation(Class <T>) */
public Annotation getAnnotation(Class annotationClass)
{
throw new AssertionError("Subclass must override this method");
}
public Annotation[] getAnnotations()
{
return getDeclaredAnnotations();
}
public Annotation[] getDeclaredAnnotations()
{
throw new AssertionError("Subclass must override this method");
}
/* FIXME[GENERICS]: Signature is Class<? extends Annotation> */
public boolean isAnnotationPresent(Class annotationClass)
{
return getAnnotation(annotationClass) != null;
}
}

117
libjava/classpath/java/lang/reflect/AnnotatedElement.java Normal file
View file

@ -0,0 +1,117 @@
/* AnnotatedElement.java
Copyright (C) 2004, 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 java.lang.annotation.Annotation;
/**
* <p>
* Represents an element that can be annotated. The methods of this interface
* provide reflection-based access to the annotations associated with a
* particular element, such as a class, field, method or package. Each
* annotation returned by these methods is both immutable and serializable.
* The returned arrays may be freely modified, without any effect on the
* arrays returned to future callers.
* </p>
* <p>
* If an annotation refers to a type or enumeration constant that is
* inaccessible, then a <code>TypeNotPresentException</code> or
* <code>EnumConstantNotPresentException</code> will be thrown. Likewise,
* invalid annotations will produce either a
* <code>AnnotationTypeMismatchException</code> or
* <code>IncompleteAnnotationException</code>.
* </p>
*
* @author Tom Tromey (tromey@redhat.com)
* @author Andrew John Hughes (gnu_andrew@member.fsf.org)
* @since 1.5
*/
public interface AnnotatedElement
{
/**
* Returns the element's annotation for the specified annotation type,
* or <code>null</code> if no such annotation exists.
*
* @param annotationClass the type of annotation to look for.
* @return this element's annotation for the specified type, or
* <code>null</code> if no such annotation exists.
* @throws NullPointerException if the annotation class is <code>null</code>.
*/
/* FIXME[GENERICS]: <T extends Annotation> T getAnnotation(Class <T>) */
Annotation getAnnotation(Class annotationClass);
/**
* Returns all annotations associated with the element. If there are
* no annotations associated with the element, 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 the
* element, and hence no effect on the return value of this method for
* future callers.
*
* @return this element's annotations.
*/
Annotation[] getAnnotations();
/**
* Returns all annotations directly defined by the element. If there are
* no annotations directly associated with the element, 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.
*
* @return the annotations directly defined by the element.
* @since 1.5
*/
Annotation[] getDeclaredAnnotations();
/**
* Returns true if an annotation for the specified type is associated
* with the element. This is primarily a short-hand for using marker
* annotations.
*
* @param annotationClass the type of annotation to look for.
* @return true if an annotation exists for the specified type.
* @since 1.5
*/
/* FIXME[GENERICS]: Signature is Class<? extends Annotation> */
boolean isAnnotationPresent(Class annotationClass);
}

23
libjava/classpath/java/lang/reflect/Array.java
View file

@ -38,8 +38,6 @@ exception statement from your version. */
package java.lang.reflect;
import gnu.classpath.Configuration;
/**
* Array holds static helper functions that allow you to create and
* manipulate arrays by reflection. Operations know how to perform widening
@ -78,13 +76,6 @@ import gnu.classpath.Configuration;
*/
public final class Array
{
static
{
if (Configuration.INIT_LOAD_LIBRARY)
{
System.loadLibrary("javalangreflect");
}
}
/**
* This class is uninstantiable.
@ -107,7 +98,7 @@ public final class Array
public static Object newInstance(Class componentType, int length)
{
if (! componentType.isPrimitive())
return createObjectArray(componentType, length);
return VMArray.createObjectArray(componentType, length);
if (componentType == boolean.class)
return new boolean[length];
if (componentType == byte.class)
@ -653,7 +644,7 @@ public final class Array
Object toAdd = createMultiArray(type, dimensions, index - 1);
Class thisType = toAdd.getClass();
Object[] retval
= (Object[]) createObjectArray(thisType, dimensions[index]);
= (Object[]) VMArray.createObjectArray(thisType, dimensions[index]);
if (dimensions[index] > 0)
retval[0] = toAdd;
int i = dimensions[index];
@ -662,14 +653,4 @@ public final class Array
return retval;
}
/**
* 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
*/
private static native Object createObjectArray(Class type, int dim);
}

63
libjava/classpath/java/lang/reflect/GenericDeclaration.java Normal file
View file

@ -0,0 +1,63 @@
/* GenericDeclaration.java
Copyright (C) 2004 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;
/**
* Represents an entity that declares one or more type parameters.
* This includes classes and methods (including constructors).
*
* @author Tom Tromey (tromey@redhat.com)
* @author Andrew John Hughes (gnu_andrew@member.fsf.org)
* @since 1.5
*/
public interface GenericDeclaration
{
/**
* Returns a <code>TypeVariable</code> object for each type variable
* declared by this entity, in order of declaration. An empty array
* is returned if no type variables are declared.
*
* @return an array of <code>TypeVariable</code> objects.
* @throws GenericSignatureFormatError if the signature format within the
* class file does not conform to that specified in the 3rd edition
* of the Java Virtual Machine Specification.
*/
/* FIXME[GENERICS]: Should be TypeVariable<?>[] */
TypeVariable[] getTypeParameters();
}

1
libjava/classpath/java/lang/reflect/GenericSignatureFormatError.java
View file

@ -51,6 +51,7 @@ package java.lang.reflect;
public class GenericSignatureFormatError
extends ClassFormatError
{
private static final long serialVersionUID = 6709919147137911034L;
/**
* Constructs a new <code>GenericSignatureFormatError</code>.

60
libjava/classpath/java/lang/reflect/MalformedParameterizedTypeException.java Normal file
View file

@ -0,0 +1,60 @@
/* MalformedParameterizedTypeException.java
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 java.lang.reflect;
/**
* This exception class is thrown when one of the reflection
* methods encountered an invalid parameterized type within
* the metadata of a class. One possible reason for this
* exception being thrown is the specification of too few or
* too many type variables.
*
* @author Tom Tromey (tromey@redhat.com)
* @author Andrew John Hughes (gnu_andrew@member.fsf.org)
* @since 1.5
*/
public class MalformedParameterizedTypeException
extends RuntimeException
{
private static final long serialVersionUID = -5696557788586220964L;
public MalformedParameterizedTypeException()
{
}
}

9
libjava/classpath/java/lang/reflect/Member.java
View file

@ -97,4 +97,13 @@ public interface Member
* @see Modifier
*/
int getModifiers();
/**
* Return true if this member is synthetic, meaning that it was
* created by the compiler and does not appear in the user's
* source code.
* @return true if the member is synthetic
* @since 1.5
*/
boolean isSynthetic();
}

34
libjava/classpath/java/lang/reflect/Modifier.java
View file

@ -157,6 +157,26 @@ public class Modifier
*/
static final int ALL_FLAGS = 0xfff;
/**
* Flag indicating a bridge method.
*/
static final int BRIDGE = 0x40;
/**
* Flag indicating a varargs method.
*/
static final int VARARGS = 0x80;
/**
* Flag indicating a synthetic member.
*/
static final int SYNTHETIC = 0x1000;
/**
* Flag indicating an enum constant or an enum class.
*/
static final int ENUM = 0x4000;
/**
* Check whether the given modifier is abstract.
* @param mod the modifier.
@ -288,7 +308,19 @@ public class Modifier
*/
public static String toString(int mod)
{
return toString(mod, new StringBuffer()).toString();
return toString(mod, new StringBuilder()).toString();
}
/**
* Package helper method that can take a StringBuilder.
* @param mod the modifier
* @param r the StringBuilder to which the String representation is appended
* @return r, with information appended
*/
static StringBuilder toString(int mod, StringBuilder r)
{
r.append(toString(mod, new StringBuffer()));
return r;
}
/**

2
libjava/classpath/java/lang/reflect/ParameterizedType.java
View file

@ -63,7 +63,7 @@ package java.lang.reflect;
*
* @author Tom Tromey (tromey@redhat.com)
* @author Andrew John Hughes (gnu_andrew@member.fsf.org)
* @see GenericTypeDeclaration
* @see GenericDeclaration
* @see TypeVariable
* @since 1.5
*/

99
libjava/classpath/java/lang/reflect/TypeVariable.java Normal file
View file

@ -0,0 +1,99 @@
/* TypeVariable.java
Copyright (C) 2004 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;
/**
* <p>
* This is a common interface for all type variables provided by
* the Java language. Instances are created the first time a type
* variable is needed by one of the reflective methods declared in
* this package.
* </p>
* <p>
* Creating a type variable requires resolving the appropriate type.
* This may involve resolving other classes as a side effect (e.g.
* if the type is nested inside other classes). Creation should not
* involve resolving the bounds. Repeated creation has no effect; an
* equivalent instance is returned. Caching is not required, but all
* instances must be <code>equal()</code> to each other.
* </p>
*
* @author Tom Tromey (tromey@redhat.com)
* @author Andrew John Hughes (gnu_andrew@member.fsf.org)
* @since 1.5
*/
/* FIXME[GENERICS]: Should be TypeVariable<T extends GenericDeclaration> */
public interface TypeVariable
extends Type
{
/**
* Returns an array of <code>Type</code> objects which represent the upper
* bounds of this type variable. There is always a default bound of
* <code>Object</code>. Any <code>ParameterizedType</code>s will be
* created as necessary, and other types resolved.
*
* @return an array of <code>Type</code> objects representing the upper
* bounds.
* @throws TypeNotPresentException if any of the bounds refer to a
* non-existant type.
* @throws MalformedParameterizedTypeException if the creation of a
* <code>ParameterizedType</code> fails.
*/
Type[] getBounds();
/**
* Returns a representation of the declaration used to declare this
* type variable.
*
* @return the <code>GenericDeclaration</code> object for this type
* variable.
*/
/* FIXME[GENERICS]: Should return type T */
GenericDeclaration getGenericDeclaration();
/**
* Returns the name of the type variable, as written in the source
* code.
*
* @return the name of the type variable.
*/
String getName();
}