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

28
libjava/classpath/gnu/java/lang/ClassHelper.java
View file

@ -81,6 +81,34 @@ public class ClassHelper
return name.substring(lastInd + 1);
}
/**
* Return the name of the class as written by the user.
* This is used by the various reflection toString methods.
* It differs from {@link Class#getName()} in that it prints
* arrays with trailing "[]"s. Note that it does not treat
* member classes specially, so a dollar sign may still appear
* in the result. This is intentional.
* @param klass the class
* @return a pretty form of the class' name
*/
public static String getUserName(Class klass)
{
int arrayCount = 0;
while (klass.isArray())
{
++arrayCount;
klass = klass.getComponentType();
}
String name = klass.getName();
if (arrayCount == 0)
return name;
StringBuilder b = new StringBuilder(name.length() + 2 * arrayCount);
b.append(name);
for (int i = 0; i < arrayCount; ++i)
b.append("[]");
return b.toString();
}
/** Cache of methods found in getAllMethods(). */
private static Map allMethods = new HashMap();

243
libjava/classpath/gnu/java/lang/InstrumentationImpl.java Normal file
View file

@ -0,0 +1,243 @@
/* InstrumentationImpl.java -- GNU implementation of
java.lang.instrument.Instrumentation
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.Instrumentation;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.ClassDefinition;
import java.lang.instrument.UnmodifiableClassException;
import java.lang.instrument.IllegalClassFormatException;
import java.security.ProtectionDomain;
import java.util.ArrayList;
import java.util.Iterator;
/**
* An Instrumentation object has transformers that will
* be called each time a class is defined or redefined.
* The object is given to a <code>premain</code> function
* that is called before the <code>main</code> function.
*
* @author Nicolas Geoffray (nicolas.geoffray@menlina.com)
* @since 1.5
*/
public final class InstrumentationImpl implements Instrumentation
{
/* List of transformers */
/* FIXME[GENERICS]: Should be ClassFileTransformer list */
private ArrayList transformers = new ArrayList();
private InstrumentationImpl()
{
}
/**
* Adds a <code>ClassFileTransformer</class> object
* to the instrumentation. Each time a class is defined
* or redefined, the <code>transform</code> method of the
* <code>transformer</code> object is called.
*
* @param transformer the transformer to add
* @throws NullPointerException if transformer is null
*/
public void addTransformer(ClassFileTransformer transformer)
{
if (transformer == null)
throw new NullPointerException();
synchronized(transformers)
{
transformers.add(transformer);
}
}
/**
* Removes the given transformer from the set of transformers
* this Instrumentation object has.
*
* @param transformer the transformer to remove
* @return true if the transformer was found and removed, false if
* the transformer was not found
* @throws NullPointerException if transformer is null
*/
public boolean removeTransformer(ClassFileTransformer transformer)
{
if (transformer == null)
throw new NullPointerException();
boolean result;
synchronized (transformers)
{
result = transformers.remove(transformer);
}
return result;
}
/**
* Returns if the current JVM supports class redefinition
*
* @return true if the current JVM supports class redefinition
*/
public boolean isRedefineClassesSupported()
{
return VMInstrumentationImpl.isRedefineClassesSupported();
}
/**
* Redefine classes present in the definitions array, with
* the corresponding class files.
*
* @param definitions an array of classes to redefine
*
* @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
* @throws NullPointerException if the definitions array is null, or any
* of its element
*
* @see isRedefineClassesSupported()
* @see addTransformer(java.lang.instrument.ClassFileTransformer)
* @see ClassFileTransformer
*/
public void redefineClasses(ClassDefinition[] definitions)
throws ClassNotFoundException,
UnmodifiableClassException
{
if (!isRedefineClassesSupported())
throw new UnsupportedOperationException();
VMInstrumentationImpl.redefineClasses(this, 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.
*/
public Class[] getAllLoadedClasses()
{
return VMInstrumentationImpl.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.
*/
public Class[] getInitiatedClasses(ClassLoader loader)
{
return VMInstrumentationImpl.getInitiatedClasses(loader);
}
/**
* Get the size of an object.
*
* @param objectToSize the object
* @return the size of the object
* @throws NullPointerException if objectToSize is null.
*/
public long getObjectSize(Object objectToSize)
{
// We alleviate the VM work
if (objectToSize == null)
throw new NullPointerException();
return VMInstrumentationImpl.getObjectSize(objectToSize);
}
/**
* Called by the VM or redefineClasses to call each transformer
*
* @param loader the loader of the class
* @param className the name of the class with packages separated with "/"
* @param classBeingRedefined the class being redefined if it's the case,
* null otherwise
* @param protectionDomain the protection domain of the class being defined
* or redefined
* @param classfileBuffer the input byte buffer in class file format
*
* @return the new class file
*/
/* FIXME[GENERICS]: Should be Class<?> */
public byte[] callTransformers(ClassLoader loader, String className,
Class classBeingRedefined, ProtectionDomain protectionDomain,
byte[] classfileBuffer)
{
byte[] newBuffer = null;
byte[] oldBuffer = classfileBuffer;
ClassFileTransformer current;
synchronized (transformers)
{
Iterator i = transformers.iterator();
while (i.hasNext())
{
/* FIXME[GENERICS]: Remove cast */
current = (ClassFileTransformer) i.next();
try
{
newBuffer = current.transform(loader, className,
classBeingRedefined, protectionDomain, oldBuffer);
}
catch (IllegalClassFormatException ignored)
{
//IGNORED
}
if (newBuffer != null)
oldBuffer = newBuffer;
}
}
return oldBuffer;
}
}

92
libjava/classpath/gnu/java/lang/reflect/ClassSignatureParser.java Normal file
View file

@ -0,0 +1,92 @@
/* ClassSignatureParser.java
Copyright (C) 2005
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.java.lang.reflect;
import java.lang.reflect.*;
import java.util.ArrayList;
public class ClassSignatureParser extends GenericSignatureParser
{
private TypeVariable[] typeParameters;
private Type superclassType;
private Type[] interfaceTypes;
public ClassSignatureParser(Class c, String signature)
{
super(c, c.getClassLoader(), signature);
if (peekChar() == '<')
{
typeParameters = readFormalTypeParameters();
}
else
{
typeParameters = new TypeVariable[0];
}
// SuperclassSignature
superclassType = readClassTypeSignature();
ArrayList interfaces = new ArrayList();
while (peekChar() == 'L')
{
// SuperinterfaceSignature
interfaces.add(readClassTypeSignature());
}
interfaceTypes = new Type[interfaces.size()];
interfaces.toArray(interfaceTypes);
end();
}
public TypeVariable[] getTypeParameters()
{
TypeImpl.resolve(typeParameters);
return typeParameters;
}
public Type getSuperclassType()
{
superclassType = TypeImpl.resolve(superclassType);
return superclassType;
}
public Type[] getInterfaceTypes()
{
TypeImpl.resolve(interfaceTypes);
return interfaceTypes;
}
}

103
libjava/classpath/gnu/java/lang/reflect/FieldSignatureParser.java Normal file
View file

@ -0,0 +1,103 @@
/* FieldSignatureParser.java
Copyright (C) 2005
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.java.lang.reflect;
import java.lang.reflect.GenericSignatureFormatError;
import java.lang.reflect.Type;
public final class FieldSignatureParser extends GenericSignatureParser
{
private Type type;
public FieldSignatureParser(Class container, String signature)
{
super(container, container.getClassLoader(), signature);
switch (peekChar())
{
case 'L':
case '[':
case 'T':
type = readFieldTypeSignature();
break;
case 'Z':
consume('Z');
type = boolean.class;
break;
case 'B':
consume('B');
type = byte.class;
break;
case 'S':
consume('S');
type = short.class;
break;
case 'C':
consume('C');
type = char.class;
break;
case 'I':
consume('I');
type = int.class;
break;
case 'F':
consume('F');
type = float.class;
break;
case 'J':
consume('J');
type = long.class;
break;
case 'D':
consume('D');
type = double.class;
break;
default:
throw new GenericSignatureFormatError();
}
end();
}
public Type getFieldType()
{
type = TypeImpl.resolve(type);
return type;
}
}

622
libjava/classpath/gnu/java/lang/reflect/GenericSignatureParser.java Normal file
View file

@ -0,0 +1,622 @@
/* GenericSignatureParser.java
Copyright (C) 2005
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.java.lang.reflect;
import java.lang.reflect.*;
import java.util.ArrayList;
import java.util.Arrays;
final class TypeVariableImpl extends TypeImpl implements TypeVariable
{
private GenericDeclaration decl;
private Type[] bounds;
private String name;
TypeVariableImpl(GenericDeclaration decl, Type[] bounds, String name)
{
this.decl = decl;
this.bounds = bounds;
this.name = name;
}
Type resolve()
{
return this;
}
/* FIXME[GENERICS]: Remove cast */
public Type[] getBounds()
{
resolve(bounds);
return (Type[]) bounds.clone();
}
public GenericDeclaration getGenericDeclaration()
{
return decl;
}
public String getName()
{
return name;
}
public boolean equals(Object obj)
{
if (obj instanceof TypeVariableImpl)
{
TypeVariableImpl other = (TypeVariableImpl)obj;
return decl.equals(other.decl) && name.equals(other.name);
}
return false;
}
public int hashCode()
{
return 0x5f4d5156 ^ decl.hashCode() ^ name.hashCode();
}
public String toString()
{
return name;
}
}
final class ParameterizedTypeImpl extends TypeImpl implements ParameterizedType
{
private String rawTypeName;
private ClassLoader loader;
private Class rawType;
private Type owner;
private Type[] typeArgs;
ParameterizedTypeImpl(String rawTypeName, ClassLoader loader, Type owner,
Type[] typeArgs)
{
this.rawTypeName = rawTypeName;
this.loader = loader;
this.owner = owner;
this.typeArgs = typeArgs;
}
Type resolve()
{
if (rawType == null)
{
try
{
rawType = Class.forName(rawTypeName, false, loader);
}
catch (ClassNotFoundException x)
{
throw new TypeNotPresentException(rawTypeName, x);
}
}
if (typeArgs == null)
{
if (owner == null)
{
return rawType;
}
typeArgs = new Type[0];
}
resolve(typeArgs);
owner = resolve(owner);
return this;
}
/* FIXME[GENERICS]: Remove cast */
public Type[] getActualTypeArguments()
{
return (Type[]) typeArgs.clone();
}
public Type getRawType()
{
return rawType;
}
public Type getOwnerType()
{
return owner;
}
public boolean equals(Object obj)
{
if (obj instanceof ParameterizedTypeImpl)
{
ParameterizedTypeImpl other = (ParameterizedTypeImpl)obj;
return rawType.equals(other.rawType)
&& ((owner == null && other.owner == null)
|| owner.equals(other.owner))
&& Arrays.deepEquals(typeArgs, other.typeArgs);
}
return false;
}
public int hashCode()
{
int h = 0x58158970 ^ rawType.hashCode();
if (owner != null)
{
h ^= Integer.reverse(owner.hashCode());
}
for (int i = 0; i < typeArgs.length; i++)
{
h ^= Integer.rotateLeft(typeArgs[i].hashCode(), i);
}
return h;
}
public String toString()
{
StringBuilder sb = new StringBuilder();
if (owner != null)
{
sb.append(owner);
sb.append('.');
sb.append(rawType.getSimpleName());
}
else
{
sb.append(rawTypeName);
}
if (typeArgs.length > 0)
{
sb.append('<');
for (int i = 0; i < typeArgs.length; i++)
{
if (i > 0)
sb.append(", ");
if (typeArgs[i] instanceof Class)
{
sb.append(((Class)typeArgs[i]).getName());
}
else
{
sb.append(typeArgs[i]);
}
}
sb.append('>');
}
return sb.toString();
}
}
final class GenericArrayTypeImpl extends TypeImpl implements GenericArrayType
{
private Type componentType;
GenericArrayTypeImpl(Type componentType)
{
this.componentType = componentType;
}
Type resolve()
{
componentType = resolve(componentType);
return this;
}
public Type getGenericComponentType()
{
return componentType;
}
public boolean equals(Object obj)
{
if (obj instanceof GenericArrayTypeImpl)
{
GenericArrayTypeImpl other = (GenericArrayTypeImpl)obj;
return componentType.equals(other.componentType);
}
return false;
}
public int hashCode()
{
return 0x4be37a7f ^ componentType.hashCode();
}
public String toString()
{
return componentType + "[]";
}
}
final class UnresolvedTypeVariable extends TypeImpl implements Type
{
private GenericDeclaration decl;
private String name;
UnresolvedTypeVariable(GenericDeclaration decl, String name)
{
this.decl = decl;
this.name = name;
}
Type resolve()
{
GenericDeclaration d = decl;
while (d != null)
{
TypeVariable[] vars = d.getTypeParameters();
for (int a = 0; a < vars.length ; ++a)
{
if (vars[a].getName().equals(name))
{
return vars[a];
}
}
d = getParent(d);
}
throw new MalformedParameterizedTypeException();
}
private static GenericDeclaration getParent(GenericDeclaration d)
{
if (d instanceof Class)
{
Method m = ((Class)d).getEnclosingMethod();
if (m != null)
{
return m;
}
Constructor c = ((Class)d).getEnclosingConstructor();
if (c != null)
{
return c;
}
return ((Class)d).getEnclosingClass();
}
else if (d instanceof Method)
{
return ((Method)d).getDeclaringClass();
}
else if (d instanceof Constructor)
{
return ((Constructor)d).getDeclaringClass();
}
else
{
// TODO figure out what this represents
throw new Error();
}
}
}
final class WildcardTypeImpl extends TypeImpl implements WildcardType
{
private Type lower;
private Type upper;
WildcardTypeImpl(Type lower, Type upper)
{
this.lower = lower;
this.upper = upper;
}
Type resolve()
{
upper = resolve(upper);
lower = resolve(lower);
return this;
}
public Type[] getUpperBounds()
{
if (upper == null)
{
return new Type[0];
}
return new Type[] { upper };
}
public Type[] getLowerBounds()
{
if (lower == null)
{
return new Type[0];
}
return new Type[] { lower };
}
public boolean equals(Object obj)
{
if (obj instanceof WildcardTypeImpl)
{
WildcardTypeImpl other = (WildcardTypeImpl)obj;
return Arrays.deepEquals(getUpperBounds(), other.getUpperBounds())
&& Arrays.deepEquals(getLowerBounds(), other.getLowerBounds());
}
return false;
}
public int hashCode()
{
int h = 0x75d074fd;
if (upper != null)
{
h ^= upper.hashCode();
}
if (lower != null)
{
h ^= lower.hashCode();
}
return h;
}
public String toString()
{
if (lower != null)
{
return "? super " + lower;
}
if (upper == java.lang.Object.class)
{
return "?";
}
return "? extends " + upper;
}
}
class GenericSignatureParser
{
private ClassLoader loader;
private GenericDeclaration container;
private String signature;
private int pos;
GenericSignatureParser(GenericDeclaration container, ClassLoader loader,
String signature)
{
this.container = container;
this.loader = loader;
this.signature = signature;
}
TypeVariable[] readFormalTypeParameters()
{
consume('<');
ArrayList params = new ArrayList();
do
{
// TODO should we handle name clashes?
params.add(readFormalTypeParameter());
} while (peekChar() != '>');
consume('>');
TypeVariable[] list = new TypeVariable[params.size()];
params.toArray(list);
return list;
}
private TypeVariable readFormalTypeParameter()
{
String identifier = readIdentifier();
consume(':');
ArrayList bounds = new ArrayList();
if (peekChar() != ':')
{
bounds.add(readFieldTypeSignature());
}
while (peekChar() == ':')
{
consume(':');
bounds.add(readFieldTypeSignature());
}
Type[] b = new Type[bounds.size()];
bounds.toArray(b);
return new TypeVariableImpl(container, b, identifier);
}
Type readFieldTypeSignature()
{
switch (peekChar())
{
case 'L':
return readClassTypeSignature();
case '[':
return readArrayTypeSignature();
case 'T':
return readTypeVariableSignature();
default:
throw new GenericSignatureFormatError();
}
}
Type readClassTypeSignature()
{
consume('L');
String className = "";
for (;;)
{
String part = readIdentifier();
if (peekChar() != '/')
{
className += part;
break;
}
consume('/');
className += part + ".";
}
Type[] typeArguments = null;
if (peekChar() == '<')
{
typeArguments = readTypeArguments();
}
Type type = new ParameterizedTypeImpl(className, loader, null,
typeArguments);
while (peekChar() == '.')
{
consume('.');
className += "$" + readIdentifier();
typeArguments = null;
if (peekChar() == '<')
{
typeArguments = readTypeArguments();
}
type = new ParameterizedTypeImpl(className, loader, type,
typeArguments);
}
consume(';');
return type;
}
private Type[] readTypeArguments()
{
consume('<');
ArrayList list = new ArrayList();
do
{
list.add(readTypeArgument());
} while ((peekChar() != '>'));
consume('>');
Type[] arr = new Type[list.size()];
list.toArray(arr);
return arr;
}
private Type readTypeArgument()
{
char c = peekChar();
if (c == '+')
{
consume('+');
return new WildcardTypeImpl(null, readFieldTypeSignature());
}
else if (c == '-')
{
consume('-');
return new WildcardTypeImpl(readFieldTypeSignature(),
java.lang.Object.class);
}
else if (c == '*')
{
consume('*');
return new WildcardTypeImpl(null, java.lang.Object.class);
}
else
{
return readFieldTypeSignature();
}
}
Type readArrayTypeSignature()
{
consume('[');
switch (peekChar())
{
case 'L':
case '[':
case 'T':
return new GenericArrayTypeImpl(readFieldTypeSignature());
case 'Z':
consume('Z');
return boolean[].class;
case 'B':
consume('B');
return byte[].class;
case 'S':
consume('S');
return short[].class;
case 'C':
consume('C');
return char[].class;
case 'I':
consume('I');
return int[].class;
case 'F':
consume('F');
return float[].class;
case 'J':
consume('J');
return long[].class;
case 'D':
consume('D');
return double[].class;
default:
throw new GenericSignatureFormatError();
}
}
Type readTypeVariableSignature()
{
consume('T');
String identifier = readIdentifier();
consume(';');
return new UnresolvedTypeVariable(container, identifier);
}
private String readIdentifier()
{
int start = pos;
char c;
do
{
readChar();
c = peekChar();
} while (";:./<>-+*".indexOf(c) == -1);
return signature.substring(start, pos);
}
final char peekChar()
{
if (pos == signature.length())
return '\u0000';
else
return signature.charAt(pos);
}
final char readChar()
{
return signature.charAt(pos++);
}
final void consume(char c)
{
if (readChar() != c)
throw new GenericSignatureFormatError();
}
final void end()
{
if (pos != signature.length())
throw new GenericSignatureFormatError();
}
}

167
libjava/classpath/gnu/java/lang/reflect/MethodSignatureParser.java Normal file
View file

@ -0,0 +1,167 @@
/* MethodSignatureParser.java
Copyright (C) 2005
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.java.lang.reflect;
import java.lang.reflect.*;
import java.util.ArrayList;
public class MethodSignatureParser extends GenericSignatureParser
{
private TypeVariable[] typeParameters;
private Type[] argTypes;
private Type retType;
private Type[] throwsSigs;
public MethodSignatureParser(Method method, String signature)
{
this(method, method.getDeclaringClass().getClassLoader(), signature);
}
public MethodSignatureParser(Constructor method, String signature)
{
this(method, method.getDeclaringClass().getClassLoader(), signature);
}
private MethodSignatureParser(GenericDeclaration wrapper,
ClassLoader loader, String signature)
{
super(wrapper, loader, signature);
if (peekChar() == '<')
{
typeParameters = readFormalTypeParameters();
}
else
{
typeParameters = new TypeVariable[0];
}
consume('(');
ArrayList args = new ArrayList();
while (peekChar() != ')')
{
args.add(readTypeSignature());
}
argTypes = new Type[args.size()];
args.toArray(argTypes);
consume(')');
retType = readTypeSignature();
ArrayList throwsSigs = new ArrayList();
while (peekChar() == '^')
{
consume('^');
if(peekChar() == 'T')
{
throwsSigs.add(readTypeVariableSignature());
}
else
{
throwsSigs.add(readClassTypeSignature());
}
}
this.throwsSigs = new Type[throwsSigs.size()];
throwsSigs.toArray(this.throwsSigs);
end();
}
public TypeVariable[] getTypeParameters()
{
TypeImpl.resolve(typeParameters);
return typeParameters;
}
public Type[] getGenericParameterTypes()
{
TypeImpl.resolve(argTypes);
return argTypes;
}
public Type getGenericReturnType()
{
retType = TypeImpl.resolve(retType);
return retType;
}
public Type[] getGenericExceptionTypes()
{
TypeImpl.resolve(throwsSigs);
return throwsSigs;
}
private Type readTypeSignature()
{
switch (peekChar())
{
case 'T':
return readTypeVariableSignature();
case 'L':
return readClassTypeSignature();
case '[':
return readArrayTypeSignature();
case 'Z':
consume('Z');
return boolean.class;
case 'B':
consume('B');
return byte.class;
case 'S':
consume('S');
return short.class;
case 'C':
consume('C');
return char.class;
case 'I':
consume('I');
return int.class;
case 'F':
consume('F');
return float.class;
case 'J':
consume('J');
return long.class;
case 'D':
consume('D');
return double.class;
case 'V':
consume('V');
return void.class;
default:
throw new GenericSignatureFormatError();
}
}
}

63
libjava/classpath/gnu/java/lang/reflect/TypeImpl.java Normal file
View file

@ -0,0 +1,63 @@
/* TypeImpl.java
Copyright (C) 2005
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.java.lang.reflect;
import java.lang.reflect.Type;
abstract class TypeImpl implements Type
{
abstract Type resolve();
static void resolve(Type[] types)
{
for (int i = 0; i < types.length; i++)
{
types[i] = resolve(types[i]);
}
}
static Type resolve(Type type)
{
if (type instanceof TypeImpl)
{
type = ((TypeImpl) type).resolve();
}
return type;
}
}