This is the mail archive of the java-patches@gcc.gnu.org mailing list for the Java project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Patch: FYI: partial merge of Method and Constructor


I'm checking this in on the trunk.

This re-orders and reindents Method and Constructor, and imports the
javadoc from Classpath.  This brings us a little closer to merging.

This is a cosmetic change only, with no logic changes.

Tom

Index: ChangeLog
from  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.

Index: java/lang/reflect/Constructor.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/lang/reflect/Constructor.java,v
retrieving revision 1.8
diff -u -r1.8 Constructor.java
--- java/lang/reflect/Constructor.java 14 Nov 2001 23:42:38 -0000 1.8
+++ java/lang/reflect/Constructor.java 5 Aug 2003 19:42:34 -0000
@@ -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,88 +11,196 @@
 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();
   }
 
+  /**
+   * 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();
-    }
+  {
+    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();
+  }
 
-  // Update cached values from method descriptor in class.
-  private native void getType ();
+  /**
+   * Get a String representation of the Constructor. A Constructor's String
+   * representation is "&lt;modifier&gt; &lt;classname&gt;(&lt;paramtypes&gt;)
+   * throws &lt;exceptions&gt;", 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;
+    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 ()
-    {
-    }
+  // Update cached values from method descriptor in class.
+  private native void getType ();
 
   // Declaring class.
   private Class declaringClass;
Index: java/lang/reflect/Method.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/lang/reflect/Method.java,v
retrieving revision 1.12
diff -u -r1.12 Method.java
--- java/lang/reflect/Method.java 24 Aug 2001 17:24:44 -0000 1.12
+++ java/lang/reflect/Method.java 5 Aug 2003 19:42:34 -0000
@@ -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,43 +13,92 @@
 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
 {
-  public boolean equals (Object obj)
+  /**
+   * This class is uninstantiable.
+   */
+  private Method ()
   {
-    if (! (obj instanceof Method))
-      return false;
-    Method m = (Method) obj;
-    return declaringClass == m.declaringClass && offset == m.offset;
   }
 
+  /**
+   * 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;
   }
 
-  public Class[] getExceptionTypes ()
-  {
-    if (exception_types == null)
-      getType();
-    return (Class[]) exception_types.clone();
-  }
+  /**
+   * 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 ();
 
-  public native String getName ();
-
-  private native void getType ();
+  /**
+   * 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)
@@ -57,43 +106,57 @@
     return (Class[]) parameter_types.clone();
   }
 
-  public Class getReturnType ()
+  /**
+   * 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 (return_type == null)
+    if (exception_types == null)
       getType();
-    return return_type;
+    return (Class[]) exception_types.clone();
   }
 
-  public int hashCode ()
+  /**
+   * 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)
   {
-    // FIXME.
-    return getName().hashCode() + declaringClass.getName().hashCode();
+    if (! (obj instanceof Method))
+      return false;
+    Method m = (Method) obj;
+    return declaringClass == m.declaringClass && offset == m.offset;
   }
 
-  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)
+  /**
+   * Get the hash code for the Method.
+   *
+   * @return the hash code for the object
+   */
+  public int hashCode ()
   {
-    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 ());
-      }
+    // FIXME.
+    return getName().hashCode() + declaringClass.getName().hashCode();
   }
 
+  /**
+   * Get a String representation of the Method. A Method's String
+   * representation is "&lt;modifiers&gt; &lt;returntype&gt;
+   * &lt;methodname&gt;(&lt;paramtypes&gt;) throws &lt;exceptions&gt;", 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 @@
     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.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]