mirror of
https://gcc.gnu.org/git/gcc.git
synced 2024-11-26 21:33:59 +08:00
Method.java: Updated status comment.
* java/lang/reflect/Method.java: Updated status comment. Imported javadoc from Classpath and re-ordered methods. * java/lang/reflect/Constructor.java: Reindented. Updated status comment. Imported javadoc from Classpath and re-ordered methods. From-SVN: r70184
This commit is contained in:
Tom Tromey
Tom Tromey
parent
10063dff3b
commit
0d4d227907
@ -1,3 +1,11 @@
|
||||
2003-08-05 Tom Tromey <tromey@redhat.com>
|
||||
|
||||
* java/lang/reflect/Method.java: Updated status comment.
|
||||
Imported javadoc from Classpath and re-ordered methods.
|
||||
* java/lang/reflect/Constructor.java: Reindented. Updated
|
||||
status comment. Imported javadoc from Classpath and re-ordered
|
||||
methods.
|
||||
|
||||
2003-08-05 Thomas Fitzsimmons <fitzsim@redhat.com>
|
||||
|
||||
* gnu/java/awt/peer/gtk/GtkComponentPeer.java (postKeyEvent):
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Constructor.java - Represents a constructor for a class.
|
||||
|
||||
/* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation
|
||||
/* Copyright (C) 1998, 1999, 2000, 2001, 2003 Free Software Foundation
|
||||
|
||||
This file is part of libgcj.
|
||||
|
||||
@ -11,89 +11,197 @@ details. */
|
||||
package java.lang.reflect;
|
||||
|
||||
/**
|
||||
* @author Tom Tromey <tromey@cygnus.com>
|
||||
* @date December 12, 1998
|
||||
* The Constructor class represents a constructor of a class. It also allows
|
||||
* dynamic creation of an object, via reflection. Invocation on Constructor
|
||||
* objects knows how to do widening conversions, but throws
|
||||
* {@link IllegalArgumentException} if a narrowing conversion would be
|
||||
* necessary. You can query for information on this Constructor regardless
|
||||
* of location, but construction access may be limited by Java language
|
||||
* access controls. If you can't do it in the compiler, you can't normally
|
||||
* do it here either.<p>
|
||||
*
|
||||
* <B>Note:</B> This class returns and accepts types as Classes, even
|
||||
* primitive types; there are Class types defined that represent each
|
||||
* different primitive type. They are <code>java.lang.Boolean.TYPE,
|
||||
* java.lang.Byte.TYPE,</code>, also available as <code>boolean.class,
|
||||
* byte.class</code>, etc. These are not to be confused with the
|
||||
* classes <code>java.lang.Boolean, java.lang.Byte</code>, etc., which are
|
||||
* real classes.<p>
|
||||
*
|
||||
* Also note that this is not a serializable class. It is entirely feasible
|
||||
* to make it serializable using the Externalizable interface, but this is
|
||||
* on Sun, not me.
|
||||
*
|
||||
* @author John Keiser
|
||||
* @author Eric Blake <ebb9@email.byu.edu>
|
||||
* @author Tom Tromey <tromey@redhat.com>
|
||||
* @see Member
|
||||
* @see Class
|
||||
* @see java.lang.Class#getConstructor(Object[])
|
||||
* @see java.lang.Class#getDeclaredConstructor(Object[])
|
||||
* @see java.lang.Class#getConstructors()
|
||||
* @see java.lang.Class#getDeclaredConstructors()
|
||||
* @since 1.1
|
||||
* @status updated to 1.4
|
||||
*/
|
||||
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
|
||||
* "The Java Language Specification", ISBN 0-201-63451-1
|
||||
* plus online API docs for JDK 1.2 beta from http://www.javasoft.com.
|
||||
* Status: Incomplete: needs a private constructor, and
|
||||
* newInstance() needs to be written.
|
||||
*/
|
||||
|
||||
public final class Constructor extends AccessibleObject implements Member
|
||||
{
|
||||
public boolean equals (Object obj)
|
||||
{
|
||||
if (! (obj instanceof Constructor))
|
||||
return false;
|
||||
Constructor c = (Constructor) obj;
|
||||
return declaringClass == c.declaringClass && offset == c.offset;
|
||||
}
|
||||
/**
|
||||
* This class is uninstantiable except from native code.
|
||||
*/
|
||||
private Constructor ()
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the class that declared this constructor.
|
||||
* @return the class that declared this member
|
||||
*/
|
||||
public Class getDeclaringClass ()
|
||||
{
|
||||
return declaringClass;
|
||||
}
|
||||
|
||||
public Class[] getExceptionTypes ()
|
||||
{
|
||||
if (exception_types == null)
|
||||
getType();
|
||||
return (Class[]) exception_types.clone();
|
||||
}
|
||||
|
||||
public native int getModifiers ();
|
||||
{
|
||||
return declaringClass;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the name of this constructor (the non-qualified name of the class
|
||||
* it was declared in).
|
||||
* @return the name of this constructor
|
||||
*/
|
||||
public String getName ()
|
||||
{
|
||||
return declaringClass.getName();
|
||||
}
|
||||
|
||||
public Class[] getParameterTypes ()
|
||||
{
|
||||
if (parameter_types == null)
|
||||
getType ();
|
||||
return (Class[]) parameter_types.clone();
|
||||
}
|
||||
/**
|
||||
* Gets the modifiers this constructor uses. Use the <code>Modifier</code>
|
||||
* class to interpret the values. A constructor can only have a subset of the
|
||||
* following modifiers: public, private, protected.
|
||||
*
|
||||
* @return an integer representing the modifiers to this Member
|
||||
* @see Modifier
|
||||
*/
|
||||
public native int getModifiers ();
|
||||
|
||||
/**
|
||||
* Get the parameter list for this constructor, in declaration order. If the
|
||||
* constructor takes no parameters, returns a 0-length array (not null).
|
||||
*
|
||||
* @return a list of the types of the constructor's parameters
|
||||
*/
|
||||
public Class[] getParameterTypes ()
|
||||
{
|
||||
if (parameter_types == null)
|
||||
getType ();
|
||||
return (Class[]) parameter_types.clone();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the exception types this constructor says it throws, in no particular
|
||||
* order. If the constructor has no throws clause, returns a 0-length array
|
||||
* (not null).
|
||||
*
|
||||
* @return a list of the types in the constructor's throws clause
|
||||
*/
|
||||
public Class[] getExceptionTypes ()
|
||||
{
|
||||
if (exception_types == null)
|
||||
getType();
|
||||
return (Class[]) exception_types.clone();
|
||||
}
|
||||
|
||||
/**
|
||||
* Compare two objects to see if they are semantically equivalent.
|
||||
* Two Constructors are semantically equivalent if they have the same
|
||||
* declaring class and the same parameter list.
|
||||
*
|
||||
* @param o the object to compare to
|
||||
* @return <code>true</code> if they are equal; <code>false</code> if not.
|
||||
*/
|
||||
public boolean equals (Object obj)
|
||||
{
|
||||
if (! (obj instanceof Constructor))
|
||||
return false;
|
||||
Constructor c = (Constructor) obj;
|
||||
return declaringClass == c.declaringClass && offset == c.offset;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the hash code for the Constructor.
|
||||
*
|
||||
* @return the hash code for the object
|
||||
*/
|
||||
public int hashCode ()
|
||||
{
|
||||
// FIXME.
|
||||
return getName().hashCode() + declaringClass.getName().hashCode();
|
||||
}
|
||||
{
|
||||
// FIXME.
|
||||
return getName().hashCode() + declaringClass.getName().hashCode();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a String representation of the Constructor. A Constructor's String
|
||||
* representation is "<modifier> <classname>(<paramtypes>)
|
||||
* throws <exceptions>", where everything after ')' is omitted if
|
||||
* there are no exceptions.<br> Example:
|
||||
* <code>public java.io.FileInputStream(java.lang.Runnable)
|
||||
* throws java.io.FileNotFoundException</code>
|
||||
*
|
||||
* @return the String representation of the Constructor
|
||||
*/
|
||||
public String toString ()
|
||||
{
|
||||
if (parameter_types == null)
|
||||
getType ();
|
||||
StringBuffer b = new StringBuffer ();
|
||||
Modifier.toString(getModifiers(), b);
|
||||
b.append(" ");
|
||||
Method.appendClassName (b, declaringClass);
|
||||
b.append("(");
|
||||
for (int i = 0; i < parameter_types.length; ++i)
|
||||
{
|
||||
Method.appendClassName (b, parameter_types[i]);
|
||||
if (i < parameter_types.length - 1)
|
||||
b.append(",");
|
||||
}
|
||||
b.append(")");
|
||||
return b.toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a new instance by invoking the constructor. Arguments are
|
||||
* automatically unwrapped and widened, if needed.<p>
|
||||
*
|
||||
* If this class is abstract, you will get an
|
||||
* <code>InstantiationException</code>. If the constructor takes 0
|
||||
* arguments, you may use null or a 0-length array for <code>args</code>.<p>
|
||||
*
|
||||
* If this Constructor enforces access control, your runtime context is
|
||||
* evaluated, and you may have an <code>IllegalAccessException</code> if
|
||||
* you could not create this object in similar compiled code. If the class
|
||||
* is uninitialized, you trigger class initialization, which may end in a
|
||||
* <code>ExceptionInInitializerError</code>.<p>
|
||||
*
|
||||
* Then, the constructor is invoked. If it completes normally, the return
|
||||
* value will be the new object. If it completes abruptly, the exception is
|
||||
* wrapped in an <code>InvocationTargetException</code>.
|
||||
*
|
||||
* @param args the arguments to the constructor
|
||||
* @return the newly created object
|
||||
* @throws IllegalAccessException if the constructor could not normally be
|
||||
* called by the Java code (i.e. it is not public)
|
||||
* @throws IllegalArgumentException if the number of arguments is incorrect;
|
||||
* or if the arguments types are wrong even with a widening
|
||||
* conversion
|
||||
* @throws InstantiationException if the class is abstract
|
||||
* @throws InvocationTargetException if the constructor throws an exception
|
||||
* @throws ExceptionInInitializerError if construction triggered class
|
||||
* initialization, which then failed
|
||||
*/
|
||||
public native Object newInstance (Object[] args)
|
||||
throws InstantiationException, IllegalAccessException,
|
||||
IllegalArgumentException, InvocationTargetException;
|
||||
|
||||
// Update cached values from method descriptor in class.
|
||||
private native void getType ();
|
||||
|
||||
public native Object newInstance (Object[] args)
|
||||
throws InstantiationException, IllegalAccessException,
|
||||
IllegalArgumentException, InvocationTargetException;
|
||||
|
||||
public String toString ()
|
||||
{
|
||||
if (parameter_types == null)
|
||||
getType ();
|
||||
StringBuffer b = new StringBuffer ();
|
||||
Modifier.toString(getModifiers(), b);
|
||||
b.append(" ");
|
||||
Method.appendClassName (b, declaringClass);
|
||||
b.append("(");
|
||||
for (int i = 0; i < parameter_types.length; ++i)
|
||||
{
|
||||
Method.appendClassName (b, parameter_types[i]);
|
||||
if (i < parameter_types.length - 1)
|
||||
b.append(",");
|
||||
}
|
||||
b.append(")");
|
||||
return b.toString();
|
||||
}
|
||||
|
||||
// Can't create these.
|
||||
private Constructor ()
|
||||
{
|
||||
}
|
||||
|
||||
// Declaring class.
|
||||
private Class declaringClass;
|
||||
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Method.java - Represent method of class or interface.
|
||||
|
||||
/* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation
|
||||
/* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation
|
||||
|
||||
This file is part of libgcj.
|
||||
|
||||
@ -13,17 +13,122 @@ package java.lang.reflect;
|
||||
import gnu.gcj.RawData;
|
||||
|
||||
/**
|
||||
* @author Tom Tromey <tromey@cygnus.com>
|
||||
* @date December 12, 1998
|
||||
* The Method class represents a member method of a class. It also allows
|
||||
* dynamic invocation, via reflection. This works for both static and
|
||||
* instance methods. Invocation on Method objects knows how to do
|
||||
* widening conversions, but throws {@link IllegalArgumentException} if
|
||||
* a narrowing conversion would be necessary. You can query for information
|
||||
* on this Method regardless of location, but invocation access may be limited
|
||||
* by Java language access controls. If you can't do it in the compiler, you
|
||||
* can't normally do it here either.<p>
|
||||
*
|
||||
* <B>Note:</B> This class returns and accepts types as Classes, even
|
||||
* primitive types; there are Class types defined that represent each
|
||||
* different primitive type. They are <code>java.lang.Boolean.TYPE,
|
||||
* java.lang.Byte.TYPE,</code>, also available as <code>boolean.class,
|
||||
* byte.class</code>, etc. These are not to be confused with the
|
||||
* classes <code>java.lang.Boolean, java.lang.Byte</code>, etc., which are
|
||||
* real classes.<p>
|
||||
*
|
||||
* Also note that this is not a serializable class. It is entirely feasible
|
||||
* to make it serializable using the Externalizable interface, but this is
|
||||
* on Sun, not me.
|
||||
*
|
||||
* @author John Keiser
|
||||
* @author Eric Blake <ebb9@email.byu.edu>
|
||||
* @author Tom Tromey <tromey@redhat.com>
|
||||
* @see Member
|
||||
* @see Class
|
||||
* @see java.lang.Class#getMethod(String,Object[])
|
||||
* @see java.lang.Class#getDeclaredMethod(String,Object[])
|
||||
* @see java.lang.Class#getMethods()
|
||||
* @see java.lang.Class#getDeclaredMethods()
|
||||
* @since 1.1
|
||||
* @status updated to 1.4
|
||||
*/
|
||||
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
|
||||
* "The Java Language Specification", ISBN 0-201-63451-1
|
||||
* plus online API docs for JDK 1.2 beta from http://www.javasoft.com.
|
||||
* Status: Complete, but not correct: access checks aren't done.
|
||||
*/
|
||||
|
||||
public final class Method extends AccessibleObject implements Member
|
||||
{
|
||||
/**
|
||||
* This class is uninstantiable.
|
||||
*/
|
||||
private Method ()
|
||||
{
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the class that declared this method, or the class where this method
|
||||
* is a non-inherited member.
|
||||
* @return the class that declared this member
|
||||
*/
|
||||
public Class getDeclaringClass ()
|
||||
{
|
||||
return declaringClass;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the name of this method.
|
||||
* @return the name of this method
|
||||
*/
|
||||
public native String getName ();
|
||||
|
||||
/**
|
||||
* Gets the modifiers this method uses. Use the <code>Modifier</code>
|
||||
* class to interpret the values. A method can only have a subset of the
|
||||
* following modifiers: public, private, protected, abstract, static,
|
||||
* final, synchronized, native, and strictfp.
|
||||
*
|
||||
* @return an integer representing the modifiers to this Member
|
||||
* @see Modifier
|
||||
*/
|
||||
public native int getModifiers ();
|
||||
|
||||
/**
|
||||
* Gets the return type of this method.
|
||||
* @return the type of this method
|
||||
*/
|
||||
public Class getReturnType ()
|
||||
{
|
||||
if (return_type == null)
|
||||
getType();
|
||||
return return_type;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the parameter list for this method, in declaration order. If the
|
||||
* method takes no parameters, returns a 0-length array (not null).
|
||||
*
|
||||
* @return a list of the types of the method's parameters
|
||||
*/
|
||||
public Class[] getParameterTypes ()
|
||||
{
|
||||
if (parameter_types == null)
|
||||
getType();
|
||||
return (Class[]) parameter_types.clone();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the exception types this method says it throws, in no particular
|
||||
* order. If the method has no throws clause, returns a 0-length array
|
||||
* (not null).
|
||||
*
|
||||
* @return a list of the types in the method's throws clause
|
||||
*/
|
||||
public Class[] getExceptionTypes ()
|
||||
{
|
||||
if (exception_types == null)
|
||||
getType();
|
||||
return (Class[]) exception_types.clone();
|
||||
}
|
||||
|
||||
/**
|
||||
* Compare two objects to see if they are semantically equivalent.
|
||||
* Two Methods are semantically equivalent if they have the same declaring
|
||||
* class, name, and parameter list. This ignores different exception
|
||||
* clauses or return types.
|
||||
*
|
||||
* @param o the object to compare to
|
||||
* @return <code>true</code> if they are equal; <code>false</code> if not
|
||||
*/
|
||||
public boolean equals (Object obj)
|
||||
{
|
||||
if (! (obj instanceof Method))
|
||||
@ -32,68 +137,26 @@ public final class Method extends AccessibleObject implements Member
|
||||
return declaringClass == m.declaringClass && offset == m.offset;
|
||||
}
|
||||
|
||||
public Class getDeclaringClass ()
|
||||
{
|
||||
return declaringClass;
|
||||
}
|
||||
|
||||
public Class[] getExceptionTypes ()
|
||||
{
|
||||
if (exception_types == null)
|
||||
getType();
|
||||
return (Class[]) exception_types.clone();
|
||||
}
|
||||
|
||||
public native int getModifiers ();
|
||||
|
||||
public native String getName ();
|
||||
|
||||
private native void getType ();
|
||||
|
||||
public Class[] getParameterTypes ()
|
||||
{
|
||||
if (parameter_types == null)
|
||||
getType();
|
||||
return (Class[]) parameter_types.clone();
|
||||
}
|
||||
|
||||
public Class getReturnType ()
|
||||
{
|
||||
if (return_type == null)
|
||||
getType();
|
||||
return return_type;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the hash code for the Method.
|
||||
*
|
||||
* @return the hash code for the object
|
||||
*/
|
||||
public int hashCode ()
|
||||
{
|
||||
// FIXME.
|
||||
return getName().hashCode() + declaringClass.getName().hashCode();
|
||||
}
|
||||
|
||||
public native Object invoke (Object obj, Object[] args)
|
||||
throws IllegalAccessException, IllegalArgumentException,
|
||||
InvocationTargetException;
|
||||
|
||||
// Append a class name to a string buffer. We try to print the
|
||||
// fully-qualified name, the way that a Java programmer would expect
|
||||
// it to be written. Weirdly, Class has no appropriate method for
|
||||
// this.
|
||||
static void appendClassName (StringBuffer buf, Class k)
|
||||
{
|
||||
if (k.isArray ())
|
||||
{
|
||||
appendClassName (buf, k.getComponentType ());
|
||||
buf.append ("[]");
|
||||
}
|
||||
else
|
||||
{
|
||||
// This is correct for primitive and reference types. Really
|
||||
// we'd like `Main$Inner' to be printed as `Main.Inner', I
|
||||
// think, but that is a pain.
|
||||
buf.append (k.getName ());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a String representation of the Method. A Method's String
|
||||
* representation is "<modifiers> <returntype>
|
||||
* <methodname>(<paramtypes>) throws <exceptions>", where
|
||||
* everything after ')' is omitted if there are no exceptions.<br> Example:
|
||||
* <code>public static int run(java.lang.Runnable,int)</code>
|
||||
*
|
||||
* @return the String representation of the Method
|
||||
*/
|
||||
public String toString ()
|
||||
{
|
||||
if (parameter_types == null)
|
||||
@ -128,8 +191,71 @@ public final class Method extends AccessibleObject implements Member
|
||||
return b.toString();
|
||||
}
|
||||
|
||||
private Method ()
|
||||
/**
|
||||
* Invoke the method. Arguments are automatically unwrapped and widened,
|
||||
* and the result is automatically wrapped, if needed.<p>
|
||||
*
|
||||
* If the method is static, <code>o</code> will be ignored. Otherwise,
|
||||
* the method uses dynamic lookup as described in JLS 15.12.4.4. You cannot
|
||||
* mimic the behavior of nonvirtual lookup (as in super.foo()). This means
|
||||
* you will get a <code>NullPointerException</code> if <code>o</code> is
|
||||
* null, and an <code>IllegalArgumentException</code> if it is incompatible
|
||||
* with the declaring class of the method. If the method takes 0 arguments,
|
||||
* you may use null or a 0-length array for <code>args</code>.<p>
|
||||
*
|
||||
* Next, if this Method enforces access control, your runtime context is
|
||||
* evaluated, and you may have an <code>IllegalAccessException</code> if
|
||||
* you could not acces this method in similar compiled code. If the method
|
||||
* is static, and its class is uninitialized, you trigger class
|
||||
* initialization, which may end in a
|
||||
* <code>ExceptionInInitializerError</code>.<p>
|
||||
*
|
||||
* Finally, the method is invoked. If it completes normally, the return value
|
||||
* will be null for a void method, a wrapped object for a primitive return
|
||||
* method, or the actual return of an Object method. If it completes
|
||||
* abruptly, the exception is wrapped in an
|
||||
* <code>InvocationTargetException</code>.
|
||||
*
|
||||
* @param o the object to invoke the method on
|
||||
* @param args the arguments to the method
|
||||
* @return the return value of the method, wrapped in the appropriate
|
||||
* wrapper if it is primitive
|
||||
* @throws IllegalAccessException if the method could not normally be called
|
||||
* by the Java code (i.e. it is not public)
|
||||
* @throws IllegalArgumentException if the number of arguments is incorrect;
|
||||
* if the arguments types are wrong even with a widening conversion;
|
||||
* or if <code>o</code> is not an instance of the class or interface
|
||||
* declaring this method
|
||||
* @throws InvocationTargetException if the method throws an exception
|
||||
* @throws NullPointerException if <code>o</code> is null and this field
|
||||
* requires an instance
|
||||
* @throws ExceptionInInitializerError if accessing a static method triggered
|
||||
* class initialization, which then failed
|
||||
*/
|
||||
public native Object invoke (Object obj, Object[] args)
|
||||
throws IllegalAccessException, IllegalArgumentException,
|
||||
InvocationTargetException;
|
||||
|
||||
private native void getType ();
|
||||
|
||||
// Append a class name to a string buffer. We try to print the
|
||||
// fully-qualified name, the way that a Java programmer would expect
|
||||
// it to be written. Weirdly, Class has no appropriate method for
|
||||
// this.
|
||||
static void appendClassName (StringBuffer buf, Class k)
|
||||
{
|
||||
if (k.isArray ())
|
||||
{
|
||||
appendClassName (buf, k.getComponentType ());
|
||||
buf.append ("[]");
|
||||
}
|
||||
else
|
||||
{
|
||||
// This is correct for primitive and reference types. Really
|
||||
// we'd like `Main$Inner' to be printed as `Main.Inner', I
|
||||
// think, but that is a pain.
|
||||
buf.append (k.getName ());
|
||||
}
|
||||
}
|
||||
|
||||
// Declaring class.
|
||||
|
||||
Loading…
Reference in New Issue
Block a user