2006-04-03 Andrew John Hughes <gnu_andrew@member.fsf.org>

	* gnu/java/lang/reflect/ClassSignatureParser.java,
	* gnu/java/lang/reflect/FieldSignatureParser.java,
	* gnu/java/lang/reflect/GenericSignatureParser.java,
	* gnu/java/lang/reflect/MethodSignatureParser.java,
	* gnu/java/lang/reflect/TypeImpl.java,
	* java/lang/Class.java,
	* java/lang/reflect/GenericDeclaration.java,
	* java/lang/reflect/MalformedParameterizedTypeException.java,
	* java/lang/reflect/TypeVariable.java,
	* java/util/Arrays.java,
	* vm/reference/java/lang/VMClass.java,
	* vm/reference/java/lang/reflect/Constructor.java,
	* vm/reference/java/lang/reflect/Method.java:
	Incorporate changes from the generics branch.

2005-10-01  Jeroen Frijters  <jeroen@frijters.net>

	* vm/reference/java/lang/reflect/Constructor.java
	(getSignature): New method.
	(getGenericExceptionTypes): New method.
	(getGenericParameterTypes): New method.
	* vm/reference/java/lang/reflect/Method.java
	(getSignature): New method.
	(getGenericExceptionTypes): New method.
	(getGenericParameterTypes): New method.
	(getGenericReturnType): New method.

2005-09-30  Jeroen Frijters  <jeroen@frijters.net>

	* gnu/java/lang/reflect/FieldSignatureParser.java: New file.
	* gnu/java/lang/reflect/ClassSignatureParser.java,
	gnu/java/lang/reflect/GenericSignatureParser.java,
	gnu/java/lang/reflect/MethodSignatureParser.java:
	Finished implementation.

2005-09-25  Jeroen Frijters  <jeroen@frijters.net>

	* gnu/java/lang/reflect/ClassSignatureParser.java,
	gnu/java/lang/reflect/GenericSignatureParser.java,
	gnu/java/lang/reflect/MethodSignatureParser.java: New files.
	* java/lang/Class.java
	(getGenericInterfaces, getGenericSuperclass, getTypeParameters):
	Implemented.
	* vm/reference/java/lang/VMClass.java
	(getSimpleName, getDeclaredAnnotations, getCanonicalName,
	getEnclosingClass, getEnclosingConstructor, getEnclosingMethod,
	isAnonymousClass, isLocalClass, isMemberClass):
	Removed generic types from signatures.
	(getGenericInterfaces, getGenericSuperclass, getTypeParameters):
	Removed.
	(getClassSignature): New method.
	* vm/reference/java/lang/reflect/Constructor.java
	(getTypeParameters): Implemented.
	* vm/reference/java/lang/reflect/Method.java
	(getTypeParameters, getSignature): New methods.

2005-06-09  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* java/lang/Class.java:
	(asSubclass(Class)): Documented.
	(getCanonicalName()): Implemented.
	(getEnclosingClass()): Implemented.
	(getEnclosingConstructor()): Implemented.
	(getEnclosingMethod()): Implemented.
	(getGenericInterfaces()): Implemented.
	(getGenericSuperclass()): Implemented.
	(getTypeParameters()): Implemented.
	(isAnonymousClass()): Implemented.
	(isLocalClass()): Implemented.
	(isMemberClass()): Implemented.
	* vm/reference/java/lang/VMClass.java:
	(getSuperClass(Class<?>)): Updated return type.
	(getSimpleName(Class<?>)): Use VM methods directly.
	(getCanonicalName(Class<?>)): Implemented.
	(getEnclosingClass(Class<?>)): New native method.
	(getEnclosingConstructor(Class<?>)): New native method.
	(getEnclosingMethod(Class<?>)): New native method.
	(getGenericInterfaces(Class<?>)): New native method.
	(getGenericSuperclass(Class<?>)): New native method.
	(getTypeParameters(Class<T>)): New native method.
	(isAnonymousClass(Class<?>)): New native method.
	(isLocalClass(Class<?>)): New native method.
	(isMemberClass(Class<?>)): New native method.
	* vm/reference/java/lang/reflect/Constructor.java:
	(getTypeParameters()): Changed to native method.

2005-05-05  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* java/lang/Class.java:
	(getSimpleName()): Implemented.
	* vm/reference/java/lang/VMClass.java:
	(getSimpleName()): Reference implementation.

2005-04-20  Tom Tromey  <tromey@redhat.com>

	* java/util/Arrays.java (hashCode): New methods.
	(deepHashCode): New method.
	(deepEquals): Likewise.
	(toString): New methods.
	(deepToString): New method.

2005-04-04  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* java/lang/Class.java:
	(isEnum()): New method implemented.
	(isSynthetic()): New method implemented.
	(isAnnotation()): New method implemented.
	* vm/reference/java/lang/VMClass.java:
	(isEnum()): New native method.
	(isSynthetic()): New native method.
	(isAnnotation()): New native method.

2005-03-21  Andrew John Hughes  <gnu_andrew@member.fsf.org>

	* java/lang/Class.java:
	Implements java.lang.reflect.Type

1 files changed, 167 insertions, 0 deletions

diff --git a/gnu/java/lang/reflect/MethodSignatureParser.java b/gnu/java/lang/reflect/MethodSignatureParser.java
new file mode 100644
index 000000000..16b1af99b
--- /dev/null
+++ b/gnu/java/lang/reflect/MethodSignatureParser.java
@@ -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();
+        }
+    }
+}