Add Proxy support.

From-SVN: r57635

libjava/ChangeLog

@@ -1,3 +1,26 @@
+2002-09-29  Anthony Green  <green@redhat.com>
+
+	* java/lang/reflect/UndeclaredThrowableException.java: New file.
+	Imported from GNU Classpath.
+	* java/lang/reflect/natProxy.cc: New file.
+	* java/lang/reflect/InvocationHandler.java: New file.  Imported
+	from GNU Classpath.
+	* java/lang/reflect/Proxy.java: New file.  Imported from GNU
+	Classpath.
+	* gnu/java/lang/reflect/TypeSignature.java: Refresh from GNU
+	Classpath.	
+	* gnu/classpath/Configuration.java.in (HAVE_NATIVE_GET_PROXY_DATA,
+	HAVE_NATIVE_GET_PROXY_CLASS, HAVE_NATIVE_GENERATE_PROXY_CLASS):
+	New statics.
+	* gcj/javaprims.h ("Java"): Add new classes.
+	* java/lang/reflect/Proxy.java: Fix check for duplicate interfaces.
+	* Makefile.am (java/lang/reflect/Proxy$$ProxyData.h): Create this.
+ 	java/lang/reflect/Proxy$$ProxyType.h): And this.
+	(inner_nat_headers): Add these new headers.
+	(ordinary_java_source_files): Add new files.
+	(nat_source_files): Add new file.
+	* Makefile.in: Rebuilt.
+
 2002-09-28  Richard Earnshaw  <rearnsha@arm.com>
 
 	* configure.host: Handle arm*-elf, strongarm*-elf and xscale*-elf with

libjava/Makefile.am

@@ -249,7 +249,9 @@ ordinary_nat_headers = $(ordinary_java_source_files:.java=.h) \
 	$(built_java_source_files:.java=.h)
 
 inner_nat_headers = java/io/ObjectOutputStream$$PutField.h \
-	java/io/ObjectInputStream$$GetField.h
+	java/io/ObjectInputStream$$GetField.h \
+	java/lang/reflect/Proxy$$ProxyData.h \
+	java/lang/reflect/Proxy$$ProxyType.h
 
 nat_headers = $(ordinary_nat_headers) $(inner_nat_headers)
 
@@ -309,6 +311,18 @@ java/lang/reflect/Method.h: java/lang/reflect/Method.class
 	    -friend 'jobject _Jv_JNI_ToReflectedMethod (_Jv_JNIEnv *, jclass, jmethodID, jboolean);' \
 	    $(basename $<)
 
+java/lang/reflect/Proxy.h: java/lang/reflect/Proxy.class
+	$(GCJH) -classpath '' -bootclasspath $(top_builddir) \
+	    $(basename $<)
+
+java/lang/reflect/Proxy$$ProxyData.h: java/lang/reflect/Proxy.class
+	$(GCJH) -classpath '' -bootclasspath $(top_builddir) \
+	'java/lang/reflect/Proxy$$ProxyData'
+
+java/lang/reflect/Proxy$$ProxyType.h: java/lang/reflect/Proxy.class
+	$(GCJH) -classpath '' -bootclasspath $(top_builddir) \
+	'java/lang/reflect/Proxy$$ProxyType'
+
 gnu/gcj/runtime/VMClassLoader.h: gnu/gcj/runtime/VMClassLoader.class
 	$(GCJH) -classpath '' -bootclasspath $(top_builddir) \
 	    -friend 'class ::java::lang::ClassLoader;' \
@@ -1873,11 +1887,14 @@ java/lang/reflect/AccessibleObject.java	\
 java/lang/reflect/Array.java \
 java/lang/reflect/Constructor.java \
 java/lang/reflect/Field.java \
+java/lang/reflect/InvocationHandler.java \
 java/lang/reflect/InvocationTargetException.java \
 java/lang/reflect/Member.java \
 java/lang/reflect/Method.java \
 java/lang/reflect/Modifier.java	\
+java/lang/reflect/Proxy.java \
 java/lang/reflect/ReflectPermission.java \
+java/lang/reflect/UndeclaredThrowableException.java \
 java/math/BigDecimal.java \
 java/math/BigInteger.java \
 java/net/Authenticator.java \
@@ -2242,6 +2259,7 @@ java/lang/reflect/natArray.cc \
 java/lang/reflect/natConstructor.cc \
 java/lang/reflect/natField.cc \
 java/lang/reflect/natMethod.cc \
+java/lang/reflect/natProxy.cc \
 java/net/natNetworkInterface.cc \
 java/net/natInetAddress.cc \
 java/net/natPlainDatagramSocketImpl.cc \

libjava/Makefile.in

@@ -1,6 +1,6 @@
-# Makefile.in generated automatically by automake 1.4 from Makefile.am
+# Makefile.in generated automatically by automake 1.4-p5 from Makefile.am
 
-# Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc.
+# Copyright (C) 1994, 1995-8, 1999, 2001 Free Software Foundation, Inc.
 # This Makefile.in is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
 # with or without modifications, as long as this notice is preserved.
@@ -246,7 +246,9 @@ ordinary_nat_headers = $(ordinary_java_source_files:.java=.h) \
 
 
 inner_nat_headers = java/io/ObjectOutputStream$$PutField.h \
-	java/io/ObjectInputStream$$GetField.h
+	java/io/ObjectInputStream$$GetField.h \
+	java/lang/reflect/Proxy$$ProxyData.h \
+	java/lang/reflect/Proxy$$ProxyType.h
 
 
 nat_headers = $(ordinary_nat_headers) $(inner_nat_headers)
@@ -1635,11 +1637,14 @@ java/lang/reflect/AccessibleObject.java	\
 java/lang/reflect/Array.java \
 java/lang/reflect/Constructor.java \
 java/lang/reflect/Field.java \
+java/lang/reflect/InvocationHandler.java \
 java/lang/reflect/InvocationTargetException.java \
 java/lang/reflect/Member.java \
 java/lang/reflect/Method.java \
 java/lang/reflect/Modifier.java	\
+java/lang/reflect/Proxy.java \
 java/lang/reflect/ReflectPermission.java \
+java/lang/reflect/UndeclaredThrowableException.java \
 java/math/BigDecimal.java \
 java/math/BigInteger.java \
 java/net/Authenticator.java \
@@ -2003,6 +2008,7 @@ java/lang/reflect/natArray.cc \
 java/lang/reflect/natConstructor.cc \
 java/lang/reflect/natField.cc \
 java/lang/reflect/natMethod.cc \
+java/lang/reflect/natProxy.cc \
 java/net/natNetworkInterface.cc \
 java/net/natInetAddress.cc \
 java/net/natPlainDatagramSocketImpl.cc \
@@ -2157,11 +2163,11 @@ java/lang/natStringBuffer.lo java/lang/natSystem.lo \
 java/lang/natThread.lo java/lang/natVMThrowable.lo \
 java/lang/ref/natReference.lo java/lang/reflect/natArray.lo \
 java/lang/reflect/natConstructor.lo java/lang/reflect/natField.lo \
-java/lang/reflect/natMethod.lo java/net/natNetworkInterface.lo \
+java/lang/reflect/natMethod.lo java/lang/reflect/natProxy.lo \
-java/net/natInetAddress.lo java/net/natPlainDatagramSocketImpl.lo \
+java/net/natNetworkInterface.lo java/net/natInetAddress.lo \
-java/net/natPlainSocketImpl.lo java/text/natCollator.lo \
+java/net/natPlainDatagramSocketImpl.lo java/net/natPlainSocketImpl.lo \
-java/util/natTimeZone.lo java/util/zip/natDeflater.lo \
+java/text/natCollator.lo java/util/natTimeZone.lo \
-java/util/zip/natInflater.lo
+java/util/zip/natDeflater.lo java/util/zip/natInflater.lo
 libgcjx_la_OBJECTS =  gnu/gcj/xlib/natClip.lo \
 gnu/gcj/xlib/natColormap.lo gnu/gcj/xlib/natDisplay.lo \
 gnu/gcj/xlib/natDrawable.lo gnu/gcj/xlib/natFont.lo \
@@ -2854,29 +2860,32 @@ DEP_FILES =  .deps/$(srcdir)/$(CONVERT_DIR)/gen-from-JIS.P \
 .deps/java/lang/reflect/AccessibleObject.P \
 .deps/java/lang/reflect/Array.P .deps/java/lang/reflect/Constructor.P \
 .deps/java/lang/reflect/Field.P \
+.deps/java/lang/reflect/InvocationHandler.P \
 .deps/java/lang/reflect/InvocationTargetException.P \
 .deps/java/lang/reflect/Member.P .deps/java/lang/reflect/Method.P \
-.deps/java/lang/reflect/Modifier.P \
+.deps/java/lang/reflect/Modifier.P .deps/java/lang/reflect/Proxy.P \
 .deps/java/lang/reflect/ReflectPermission.P \
+.deps/java/lang/reflect/UndeclaredThrowableException.P \
 .deps/java/lang/reflect/natArray.P \
 .deps/java/lang/reflect/natConstructor.P \
 .deps/java/lang/reflect/natField.P .deps/java/lang/reflect/natMethod.P \
-.deps/java/lang/s_atan.P .deps/java/lang/s_ceil.P \
+.deps/java/lang/reflect/natProxy.P .deps/java/lang/s_atan.P \
-.deps/java/lang/s_copysign.P .deps/java/lang/s_cos.P \
+.deps/java/lang/s_ceil.P .deps/java/lang/s_copysign.P \
-.deps/java/lang/s_fabs.P .deps/java/lang/s_floor.P \
+.deps/java/lang/s_cos.P .deps/java/lang/s_fabs.P \
-.deps/java/lang/s_rint.P .deps/java/lang/s_scalbn.P \
+.deps/java/lang/s_floor.P .deps/java/lang/s_rint.P \
-.deps/java/lang/s_sin.P .deps/java/lang/s_tan.P \
+.deps/java/lang/s_scalbn.P .deps/java/lang/s_sin.P \
-.deps/java/lang/sf_fabs.P .deps/java/lang/sf_rint.P \
+.deps/java/lang/s_tan.P .deps/java/lang/sf_fabs.P \
-.deps/java/lang/strtod.P .deps/java/lang/w_acos.P \
+.deps/java/lang/sf_rint.P .deps/java/lang/strtod.P \
-.deps/java/lang/w_asin.P .deps/java/lang/w_atan2.P \
+.deps/java/lang/w_acos.P .deps/java/lang/w_asin.P \
-.deps/java/lang/w_exp.P .deps/java/lang/w_fmod.P \
+.deps/java/lang/w_atan2.P .deps/java/lang/w_exp.P \
-.deps/java/lang/w_log.P .deps/java/lang/w_pow.P \
+.deps/java/lang/w_fmod.P .deps/java/lang/w_log.P \
-.deps/java/lang/w_remainder.P .deps/java/lang/w_sqrt.P \
+.deps/java/lang/w_pow.P .deps/java/lang/w_remainder.P \
-.deps/java/math/BigDecimal.P .deps/java/math/BigInteger.P \
+.deps/java/lang/w_sqrt.P .deps/java/math/BigDecimal.P \
-.deps/java/net/Authenticator.P .deps/java/net/BindException.P \
+.deps/java/math/BigInteger.P .deps/java/net/Authenticator.P \
-.deps/java/net/ConnectException.P .deps/java/net/ContentHandler.P \
+.deps/java/net/BindException.P .deps/java/net/ConnectException.P \
-.deps/java/net/ContentHandlerFactory.P .deps/java/net/DatagramPacket.P \
+.deps/java/net/ContentHandler.P .deps/java/net/ContentHandlerFactory.P \
-.deps/java/net/DatagramSocket.P .deps/java/net/DatagramSocketImpl.P \
+.deps/java/net/DatagramPacket.P .deps/java/net/DatagramSocket.P \
+.deps/java/net/DatagramSocketImpl.P \
 .deps/java/net/DatagramSocketImplFactory.P .deps/java/net/FileNameMap.P \
 .deps/java/net/HttpURLConnection.P .deps/java/net/InetAddress.P \
 .deps/java/net/InetSocketAddress.P .deps/java/net/JarURLConnection.P \
@@ -3776,7 +3785,7 @@ maintainer-clean-recursive:
 	dot_seen=no; \
 	rev=''; list='$(SUBDIRS)'; for subdir in $$list; do \
 	  rev="$$subdir $$rev"; \
-	  test "$$subdir" = "." && dot_seen=yes; \
+	  test "$$subdir" != "." || dot_seen=yes; \
 	done; \
 	test "$$dot_seen" = "no" && rev=". $$rev"; \
 	target=`echo $@ | sed s/-recursive//`; \
@@ -4162,6 +4171,18 @@ java/lang/reflect/Method.h: java/lang/reflect/Method.class
 	    -friend 'jobject _Jv_JNI_ToReflectedMethod (_Jv_JNIEnv *, jclass, jmethodID, jboolean);' \
 	    $(basename $<)
 
+java/lang/reflect/Proxy.h: java/lang/reflect/Proxy.class
+	$(GCJH) -classpath '' -bootclasspath $(top_builddir) \
+	    $(basename $<)
+
+java/lang/reflect/Proxy$$ProxyData.h: java/lang/reflect/Proxy.class
+	$(GCJH) -classpath '' -bootclasspath $(top_builddir) \
+	'java/lang/reflect/Proxy$$ProxyData'
+
+java/lang/reflect/Proxy$$ProxyType.h: java/lang/reflect/Proxy.class
+	$(GCJH) -classpath '' -bootclasspath $(top_builddir) \
+	'java/lang/reflect/Proxy$$ProxyType'
+
 gnu/gcj/runtime/VMClassLoader.h: gnu/gcj/runtime/VMClassLoader.class
 	$(GCJH) -classpath '' -bootclasspath $(top_builddir) \
 	    -friend 'class ::java::lang::ClassLoader;' \

libjava/gcj/Makefile.in

@@ -1,6 +1,6 @@
-# Makefile.in generated automatically by automake 1.4 from Makefile.am
+# Makefile.in generated automatically by automake 1.4-p5 from Makefile.am
 
-# Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc.
+# Copyright (C) 1994, 1995-8, 1999, 2001 Free Software Foundation, Inc.
 # This Makefile.in is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
 # with or without modifications, as long as this notice is preserved.

libjava/gcj/javaprims.h

@@ -230,11 +230,16 @@ extern "Java"
         class Array;
         class Constructor;
         class Field;
+	class InvocationHandler;
         class InvocationTargetException;
         class Member;
         class Method;
         class Modifier;
+	class Proxy;
+	class Proxy$ProxyData;
+	class Proxy$ProxyType;
         class ReflectPermission;
+	class UndeclaredThrowableException;
       };
     };
 

libjava/gnu/classpath/Configuration.java.in

@@ -51,4 +51,9 @@ public interface Configuration
 
   // For libgcj we never load the JNI libraries.
   boolean INIT_LOAD_LIBRARY = false;
+	
+  // For libgcj we have native methods for proxy support....
+  boolean HAVE_NATIVE_GET_PROXY_DATA = false;
+  boolean HAVE_NATIVE_GET_PROXY_CLASS = false;
+  boolean HAVE_NATIVE_GENERATE_PROXY_CLASS = false;
 }

libjava/gnu/java/lang/reflect/TypeSignature.java

@@ -1,5 +1,5 @@
 /* TypeSignature.java -- Class used to compute type signatures
-   Copyright (C) 1998 Free Software Foundation, Inc.
+   Copyright (C) 1998, 2000, 2002 Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -7,7 +7,7 @@ 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
@@ -44,230 +44,218 @@ import java.lang.reflect.Member;
 import java.lang.reflect.Method;
 
 /**
-   This class provides static methods that can be used to compute
+ * This class provides static methods that can be used to compute
-   type-signatures of <code>Class</code>s or <code>Member</code>s.
+ * type-signatures of <code>Class</code>s or <code>Member</code>s.
-   More specific methods are also provided for computing the
+ * More specific methods are also provided for computing the
-   type-signature of <code>Constructor</code>s and
+ * type-signature of <code>Constructor</code>s and
-   <code>Method</code>s.  Methods are also provided to go in the
+ * <code>Method</code>s.  Methods are also provided to go in the
-   reverse direction.
+ * reverse direction.
-*/
+ *
+ * @author Eric Blake <ebb9@email.byu.edu>
+ */
 public class TypeSignature
 {
- 
   /**
-     Returns a <code>String</code> representing the type-encoding of
+   * Returns a <code>String</code> representing the type-encoding of a class.
-     CLAZZ.  Type-encodings are computed as follows:
+   * The .class file format has different encodings for classes, depending
-
+   * on whether it must be disambiguated from primitive types or not; hence
-     <pre>
+   * the descriptor parameter to choose between them. If you are planning
-     boolean -> "Z"
+   * on decoding primitive types along with classes, then descriptor should
-     byte    -> "B"
+   * be true for correct results. Type-encodings are computed as follows:
-     char    -> "C"
+   *
-     double  -> "D"
+   * <pre>
-     float   -> "F"
+   * boolean -> "Z"
-     int     -> "I"
+   * byte    -> "B"
-     long    -> "J"
+   * char    -> "C"
-     short   -> "S"
+   * double  -> "D"
-     void    -> "V"
+   * float   -> "F"
-     arrays  -> "[" + type-encoding of component type
+   * int     -> "I"
-     object  -> "L"
+   * long    -> "J"
-                 + fully qualified class name with "."'s replaced by "/"'s
+   * short   -> "S"
-                 + ";"</pre>
+   * void    -> "V"
-  */
+   * arrays  -> "[" + descriptor format of component type
-  public static String getEncodingOfClass( Class clazz )
+   * object  -> class format: fully qualified name with '.' replaced by '/'
+   *            descriptor format: "L" + class format + ";"
+   * </pre>
+   *
+   * @param type the class name to encode
+   * @param descriptor true to return objects in descriptor format
+   * @return the class name, as it appears in bytecode constant pools
+   * @see #getClassForEncoding(String)
+   */
+  public static String getEncodingOfClass(String type, boolean descriptor)
   {
-    if( clazz.isPrimitive() )
+    if (! descriptor || type.charAt(0) == '[')
-    {
+      return type.replace('.', '/');
-      if( clazz == Boolean.TYPE )
+    if (type.equals("boolean"))
-	return "Z";
+      return "Z";
-      if( clazz == Byte.TYPE )
+    if (type.equals("byte"))
-	return "B";
+      return "B";
-      if( clazz == Character.TYPE )
+    if (type.equals("short"))
-	return "C";
+      return "S";
-      if( clazz == Double.TYPE )
+    if (type.equals("char"))
-	return "D";
+      return "C";
-      if( clazz == Float.TYPE )
+    if (type.equals("int"))
-	return "F";
+      return "I";
-      if( clazz == Integer.TYPE )
+    if (type.equals("long"))
-	return "I";
+      return "J";
-      if( clazz == Long.TYPE )
+    if (type.equals("float"))
-	return "J";
+      return "F";
-      if( clazz == Short.TYPE )
+    if (type.equals("double"))
-	return "S";
+      return "D";
-      if( clazz == Void.TYPE )
+    if (type.equals("void"))
-	return "V";
+      return "V";
-      else
+    return 'L' + type.replace('.', '/') + ';';
-	throw new RuntimeException( "Unknown primitive class " + clazz );
-    }
-    else if( clazz.isArray() )
-    {
-      return '[' + getEncodingOfClass( clazz.getComponentType() );
-    }
-    else
-    {
-      String classname = clazz.getName();
-      int name_len = classname.length();
-      char[] buf = new char[ name_len + 2 ];
-      buf[0] = 'L';
-      classname.getChars( 0, name_len, buf, 1 );
-      
-      int i;
-      for( i=1; i <= name_len; i++ )
-      {
-	if( buf[i] == '.' )
-	  buf[i] = '/';
-      }
-      
-      buf[i] = ';';
-      return new String( buf );
-    }
   }
 
-  
   /**
-     This function is the inverse of <code>getEncodingOfClass</code>.
+   * Gets the descriptor encoding for a class.
+   *
+   * @param clazz the class to encode
+   * @param descriptor true to return objects in descriptor format
+   * @return the class name, as it appears in bytecode constant pools
+   * @see #getEncodingOfClass(String, boolean)
+   */
+  public static String getEncodingOfClass(Class clazz, boolean descriptor)
+  {
+    return getEncodingOfClass(clazz.getName(), descriptor);
+  }
 
-     @see getEncodingOfClass
+  /**
+   * Gets the descriptor encoding for a class.
+   *
+   * @param clazz the class to encode
+   * @return the class name, as it appears in bytecode constant pools
+   * @see #getEncodingOfClass(String, boolean)
+   */
+  public static String getEncodingOfClass(Class clazz)
+  {
+    return getEncodingOfClass(clazz.getName(), true);
+  }
 
-     @exception ClassNotFoundException If class encoded as type_code
+
-     cannot be located.
+  /**
-  */
+   * This function is the inverse of <code>getEncodingOfClass</code>. This
-  public static Class getClassForEncoding( String type_code )
+   * accepts both object and descriptor formats, but must know which style
+   * of string is being passed in (usually, descriptor should be true). In
+   * descriptor format, "I" is treated as int.class, in object format, it
+   * is treated as a class named I in the unnamed package.
+   *
+   * @param type_code the class name to decode
+   * @param descriptor if the string is in descriptor format
+   * @return the corresponding Class object
+   * @throws ClassNotFoundException if the class cannot be located
+   * @see #getEncodingOfClass(Class, boolean)
+   */
+  public static Class getClassForEncoding(String type_code, boolean descriptor)
     throws ClassNotFoundException
   {
-    if( type_code.equals( "B" ) )
+    if (descriptor)
-      return Byte.TYPE;
+      {
-    if( type_code.equals( "C" ) )
+        switch (type_code.charAt(0))
-      return Character.TYPE;
+          {
-    if( type_code.equals( "D" ) )
+          case 'B':
-      return Double.TYPE;
+            return byte.class;
-    if( type_code.equals( "F" ) )
+          case 'C':
-      return Float.TYPE;
+            return char.class;
-    if( type_code.equals( "I" ) )
+          case 'D':
-      return Integer.TYPE;
+            return double.class;
-    if( type_code.equals( "J" ) )
+          case 'F':
-      return Long.TYPE;
+            return float.class;
-    if( type_code.equals( "S" ) )
+          case 'I':
-      return Short.TYPE;
+            return int.class;
-    if( type_code.equals( "Z" ) )
+          case 'J':
-      return Boolean.TYPE;
+            return long.class;
-    if( type_code.charAt( 0 ) == 'L' )
+          case 'S':
-    {
+            return short.class;
-      return Class.forName(
+          case 'V':
-	type_code.substring( 1, type_code.length() - 1 ).replace( '/', '.' ));
+            return void.class;
-    }
+          case 'Z':
-    if( type_code.charAt( 0 ) == '[' )
+            return boolean.class;
-    {
+          default:
-      int last_bracket = type_code.lastIndexOf( '[' );
+            throw new ClassNotFoundException("Invalid class name: "
-      String brackets = type_code.substring( 0, last_bracket + 1 );
+                                             + type_code);
-      String component = type_code.substring( last_bracket + 1 );
+          case 'L':
-      
+            type_code = type_code.substring(1, type_code.length() - 1);
-// ??? This is what the Classpath implementation did, but I don't
+            // Fallthrough.
-// think that it's correct.  The JLS says that Class.forName takes the
+          case '[':
-// classname of an array element in fully qualified form, whereas this
+          }
-// code is tring to strip off the punctuation.
+      }
-
+    return Class.forName(type_code.replace('/', '.'));
-//        if( component.charAt( 0 ) == 'L' )
-//  	component =
-//  	  component.substring( 1, component.length() - 1 ).replace('/', '.');
-
-      if( component.charAt( 0 ) == 'L' )
-  	component = component.replace('/', '.');
-	
-      return Class.forName( brackets + component );
-    }
-    else
-      throw new ClassNotFoundException( "Type code cannot be parsed as a valid class name" );
   }
-  
 
   /**
-     Returns a <code>String</code> representing the type-encoding of
+   * Gets the Class object for a type name.
-     M.  The type-encoding of a method is:
+   *
-
+   * @param type_code the class name to decode
-     "(" + type-encodings of parameter types + ")" 
+   * @return the corresponding Class object
-     + type-encoding of return type
+   * @throws ClassNotFoundException if the class cannot be located
-  */
+   * @see #getClassForEncoding(String, boolean)
-  public static String getEncodingOfMethod( Method m )
+   */
+  public static Class getClassForEncoding(String type_code)
+    throws ClassNotFoundException
+  {
+    return getClassForEncoding(type_code, true);
+  }
+
+  /**
+   * Returns a <code>String</code> representing the type-encoding of a
+   * method.  The type-encoding of a method is:
+   *
+   * "(" + parameter type descriptors + ")" + return type descriptor
+   *
+   * XXX This could be faster if it were implemented natively.
+   *
+   * @param m the method to encode
+   * @return the encoding
+   */
+  public static String getEncodingOfMethod(Method m)
   {
-    String returnEncoding = getEncodingOfClass( m.getReturnType() );
     Class[] paramTypes = m.getParameterTypes();
-    String[] paramEncodings = new String[ paramTypes.length ];
+    StringBuffer buf = new StringBuffer().append('(');
-
+    for (int i = 0; i < paramTypes.length; i++)
-    String paramEncoding;
+      buf.append(getEncodingOfClass(paramTypes[i].getName(), true));
-    int size = 2; // make room for parens
+    buf.append(')').append(getEncodingOfClass(m.getReturnType().getName(),
-    for( int i=0; i < paramTypes.length; i++ )
+                                              true));
-    {
-      paramEncoding = getEncodingOfClass( paramTypes[i] );
-      size += paramEncoding.length();
-      paramEncodings[i] = paramEncoding;
-    }
-    
-    size += returnEncoding.length();
-
-    StringBuffer buf = new StringBuffer( size );
-    buf.append( '(' );
-    
-    for( int i=0; i < paramTypes.length; i++ )
-    {
-      buf.append( paramEncodings[i] );
-    }
-    
-    buf.append( ')' );
-    buf.append( returnEncoding );
-    
     return buf.toString();
   }
 
-
   /**
-     Returns a <code>String</code> representing the type-encoding of
+   * Returns a <code>String</code> representing the type-encoding of a
-     C.  The type-encoding of a method is:
+   * constructor. The type-encoding of a method is:
-
+   *
-     "(" + type-encodings of parameter types + ")V" 
+   * "(" + parameter type descriptors + ")V"
-  */
+   *
-  public static String getEncodingOfConstructor( Constructor c )
+   * XXX This could be faster if it were implemented natively.
+   *
+   * @param c the constructor to encode
+   * @return the encoding
+   */
+  public static String getEncodingOfConstructor(Constructor c)
   {
     Class[] paramTypes = c.getParameterTypes();
-    String[] paramEncodings = new String[ paramTypes.length ];
+    StringBuffer buf = new StringBuffer().append('(');
-
+    for (int i = 0; i < paramTypes.length; i++)
-    String paramEncoding;
+      buf.append(getEncodingOfClass(paramTypes[i].getName(), true));
-    int size = 3; // make room for parens and V for return type
+    buf.append(")V");
-    for( int i=0; i < paramTypes.length; i++ )
-    {
-      paramEncoding = getEncodingOfClass( paramTypes[i] );
-      size += paramEncoding.length();
-      paramEncodings[i] = paramEncoding;
-    }
-    
-    StringBuffer buf = new StringBuffer( size );
-    buf.append( '(' );
-    
-    for( int i=0; i < paramTypes.length; i++ )
-    {
-      buf.append( paramEncodings[i] );
-    }
-    
-    buf.append( ")V" );
-    
     return buf.toString();
   }
 
-
   /**
-     Returns a <code>String</code> representing the type-encoding of
+   * Returns a <code>String</code> representing the type-encoding of a
-     MEM.  <code>Constructor</code>s are handled by
+   * class member. This appropriately handles Constructors, Methods, and
-     <code>getEncodingOfConstructor</code>.  <code>Method</code>s are
+   * Fields.
-     handled by <code>getEncodingOfMethod</code>.  <code>Field</code>s
+   *
-     are handled by returning the encoding of the type of the
+   * @param mem the member to encode
-     <code>Field</code>.
+   * @return the encoding
-  */
+   */
-  public static String getEncodingOfMember( Member mem )
+  public static String getEncodingOfMember(Member mem)
   {
-    if( mem instanceof Constructor )
+    if (mem instanceof Constructor)
-      return getEncodingOfConstructor( (Constructor)mem );
+      return getEncodingOfConstructor((Constructor) mem);
-    if( mem instanceof Method )
+    if (mem instanceof Method)
-      return getEncodingOfMethod( (Method)mem );
+      return getEncodingOfMethod((Method) mem);
     else // Field
-      return getEncodingOfClass( ((Field)mem).getType() );
+      return getEncodingOfClass(((Field) mem).getType().getName(), true);
   }
-}
+} // class TypeSignature

libjava/include/Makefile.in

@@ -1,6 +1,6 @@
-# Makefile.in generated automatically by automake 1.4 from Makefile.am
+# Makefile.in generated automatically by automake 1.4-p5 from Makefile.am
 
-# Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc.
+# Copyright (C) 1994, 1995-8, 1999, 2001 Free Software Foundation, Inc.
 # This Makefile.in is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
 # with or without modifications, as long as this notice is preserved.

libjava/java/lang/VMClassLoader.java

@@ -43,10 +43,10 @@ class VMClassLoader {
      * @return the class that was defined.
      * @exception ClassFormatError if the byte array is not in proper classfile format.
      */
-  // Not yet needed for libgcj.
+    final static native Class defineClass(ClassLoader cl, String name, 
-//      final static native Class defineClass(ClassLoader cl, String name, 
+					  byte[] data, int offset, int len) 
-//  	     byte[] data, int offset, int len) throws ClassFormatError;
+	throws ClassFormatError;
-    
+
     /** 
      * Helper to resolve all references to other classes from this class.
      * @param c the class to resolve.

libjava/java/lang/natClassLoader.cc

@@ -170,6 +170,16 @@ java::lang::ClassLoader::markClassErrorState0 (java::lang::Class *klass)
   klass->notifyAll ();
 }
 
+jclass
+java::lang::VMClassLoader::defineClass (java::lang::ClassLoader *cl, 
+					jstring name,
+					jbyteArray data, 
+					jint offset,
+					jint length)
+{
+  return cl->defineClass (name, data, offset, length);
+}
+
 jclass
 java::lang::VMClassLoader::getPrimitiveClass (jchar type)
 {
@@ -269,6 +279,7 @@ _Jv_PrepareCompiledClass (jclass klass)
       else if (pool->tags[index] == JV_CONSTANT_String)
 	{
 	  jstring str;
+
 	  str = _Jv_NewStringUtf8Const (pool->data[index].utf8);
 	  pool->data[index].o = str;
 	  pool->tags[index] |= JV_CONSTANT_ResolvedFlag;

libjava/java/lang/reflect/InvocationHandler.java

@@ -0,0 +1,136 @@
+/* java.lang.reflect.InvocationHandler - dynamically executes methods in
+   proxy instances
+   Copyright (C) 2001 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., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 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 interface defines an invocation handler.  Suppose you are using
+ * reflection, and found a method that requires that its parameter
+ * be an object of a given interface.  You want to call this method,
+ * but have no idea what classes implement that interface.  So, you can
+ * create a {@link Proxy} instance, a convenient way to dynamically
+ * generate a class that meets all the necessary properties of that
+ * interface.  But in order for the proxy instance to do any good, it
+ * needs to know what to do when interface methods are invoked!  So,
+ * this interface is basically a cool wrapper that provides runtime
+ * code generation needed by proxy instances.<p>
+ *
+ * While this interface was designed for use by Proxy, it will also
+ * work on any object in general.<p>
+ *
+ * Hints for implementing this class:<br>
+ * <ul>
+ *  <li>Don't forget that Object.equals, Object.hashCode, and
+ *      Object.toString will call this handler.  In particular,
+ *      a naive call to proxy.equals, proxy.hashCode, or proxy.toString
+ *      will put you in an infinite loop.  And remember that string
+ *      concatenation also invokes toString.</li>
+ *  <li>Obey the contract of the Method object you are handling, or
+ *      the proxy instance will be forced to throw a
+ *      {@link NullPointerException}, {@link ClassCastException},
+ *      or {@link UndeclaredThrowableException}.</li>
+ *  <li>Be prepared to wrap/unwrap primitives as necessary.</li>
+ *  <li>The Method object may be owned by a different interface than
+ *      what was actually used as the qualifying type of the method
+ *      invocation in the Java source code. This means that it might
+ *      not always be safe to throw an exception listed as belonging
+ *      to the method's throws clause.</li>
+ * </ul>
+ *
+ * <p><small>For a fun time, create an InvocationHandler that handles the
+ * methods of a proxy instance of the InvocationHandler interface!</small>
+ *
+ * @see Proxy
+ * @see UndeclaredThrowableException
+ *
+ * @author Eric Blake <ebb9@email.byu.edu>
+ * @since 1.3
+ * @status updated to 1.4
+ */
+public interface InvocationHandler
+{
+  /**
+   * When a method is invoked on a proxy instance, it is wrapped and
+   * this method is called instead, so that you may decide at runtime
+   * how the original method should behave.
+   *
+   * @param proxy the instance that the wrapped method should be
+   *        invoked on.  When this method is called by a Proxy object,
+   *        `proxy' will be an instance of {@link Proxy}, and oddly enough,
+   *        <code>Proxy.getInvocationHandler(proxy)</code> will return
+   *        <code>this</code>!
+   * @param method the reflected method to invoke on the proxy.
+   *        When this method is called by a Proxy object, 'method'
+   *        will be the reflection object owned by the declaring
+   *        class or interface, which may be a supertype of the
+   *        interfaces the proxy directly implements.
+   * @param args the arguments passed to the original method, or
+   *        <code>null</code> if the method takes no arguments.
+   *        (But also be prepared to handle a 0-length array).
+   *        Arguments of primitive type, such as <code>boolean</code>
+   *        or <code>int</code>, are wrapped in the appropriate
+   *        class such as {@link Boolean} or {@link Integer}.
+   * @return whatever is necessary to return from the wrapped method.
+   *         If the wrapped method is <code>void</code>, the proxy
+   *         instance will ignore it.  If the wrapped method returns
+   *         a primitive, this must be the correct wrapper type whose value
+   *         is exactly assignable to the appropriate type (no widening
+   *         will be performed); a null object in this case causes a
+   *         {@link NullPointerException}.  In all remaining cases, if
+   *         the returned object is not assignment compatible to the
+   *         declared type of the original method, the proxy instance
+   *         will generate a {@link ClassCastException}.
+   * @throws Throwable this interface is listed as throwing anything,
+   *         but the implementation should only throw unchecked
+   *         exceptions and exceptions listed in the throws clause of
+   *         all methods being overridden by the proxy instance.  If
+   *         something is thrown that is not compatible with the throws
+   *         clause of all overridden methods, the proxy instance will
+   *         wrap the exception in an UndeclaredThrowableException.
+   *         Note that an exception listed in the throws clause of the
+   *         `method' parameter might not be declared in additional
+   *         interfaces also implemented by the proxy object.
+   *
+   * @see Proxy
+   * @see UndeclaredThrowableException
+   */
+  Object invoke(Object proxy, Method method, Object[] args)
+    throws Throwable;
+
+}

libjava/java/lang/reflect/UndeclaredThrowableException.java

@@ -0,0 +1,128 @@
+/* UndeclaredThrowableException.java -- wraps an undeclared checked exception
+   thrown by a Proxy invocation handler
+   Copyright (C) 2001, 2002 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., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 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 by a {@link Proxy} instance if
+ * the {@link InvocationHandler#invoke(Object, Method, Object[]) invoke}
+ * method of that instance's InvocationHandler attempts to throw an
+ * exception that not declared by the throws clauses of all of the
+ * interface methods that the proxy instance is implementing.
+ *
+ * <p>When thrown by Proxy, this class will always wrap a checked
+ * exception, never {@link Error} or {@link RuntimeException},
+ * which are unchecked.
+ *
+ * @author Eric Blake <ebb9@email.byu.edu>
+ * @see Proxy
+ * @see InvocationHandler
+ * @since 1.3
+ * @status updated to 1.4
+ */
+public class UndeclaredThrowableException extends RuntimeException
+{
+  /**
+   * Compatible with JDK 1.3+.
+   */
+  private static final long serialVersionUID = 330127114055056639L;
+
+  /**
+   * The immutable exception that this wraps. This field is redundant
+   * with {@link Throwable#cause}, but is necessary for serial compatibility.
+   *
+   * @serial the chained exception
+   */
+  private final Throwable undeclaredThrowable;
+
+  /**
+   * Wraps the given checked exception into a RuntimeException, with no
+   * detail message.  {@link Throwable#initCause(Throwable)} will fail
+   * on this instance.
+   *
+   * @param cause the undeclared throwable that caused this exception,
+   *        may be null
+   */
+  public UndeclaredThrowableException(Throwable cause)
+  {
+    this(cause, null);
+  }
+
+  /**
+   * Wraps the given checked exception into a RuntimeException, with the
+   * specified detail message.  {@link Throwable#initCause(Throwable)} will
+   * fail on this instance.
+   *
+   * @param cause the undeclared throwable that caused this exception,
+   *        may be null
+   * @param message the message, may be null
+   */
+  public UndeclaredThrowableException(Throwable cause, String message)
+  {
+    super(message, cause);
+    undeclaredThrowable = cause;
+  }
+
+  /**
+   * Returns the cause of this exception.  If this exception was created
+   * by a {@link Proxy} instance, it will be a non-null checked
+   * exception.  This method pre-dates exception chaining, and is now
+   * simply a longer way to call <code>getCause()</code>.
+   *
+   * @return the cause of this exception, may be null
+   * @see #getCause()
+   */
+  public Throwable getUndeclaredThrowable()
+  {
+    return undeclaredThrowable;
+  }
+
+  /**
+   * Returns the cause of this exception.  If this exception was created
+   * by a {@link Proxy} instance, it will be a non-null checked
+   * exception.
+   *
+   * @return the cause of this exception, may be null
+   * @since 1.4
+   */
+  public Throwable getCause()
+  {
+    return undeclaredThrowable;
+  }
+}

libjava/java/lang/reflect/natProxy.cc

@@ -0,0 +1,38 @@
+// natProxy.cc - Native code for Proxy class.
+
+/* Copyright (C) 2002  Free Software Foundation
+
+   This file is part of libgcj.
+
+This software is copyrighted work licensed under the terms of the
+Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
+details.  */
+
+#include <config.h>
+
+#include <gcj/cni.h>
+#include <jvm.h>
+
+#include <java/lang/Class.h>
+#include <java/lang/ClassLoader.h>
+#include <java/lang/reflect/Proxy.h>
+#include <java/lang/reflect/Proxy$ProxyData.h>
+
+::java::lang::Class *
+java::lang::reflect::Proxy::getProxyClass0 (::java::lang::ClassLoader *, JArray< ::java::lang::Class *> *)
+{
+  return 0;
+}
+
+::java::lang::reflect::Proxy$ProxyData *
+java::lang::reflect::Proxy::getProxyData0 (::java::lang::ClassLoader *, JArray< ::java::lang::Class *> *)
+{
+  return 0;
+}
+
+::java::lang::Class *
+java::lang::reflect::Proxy::generateProxyClass0 (::java::lang::ClassLoader *, 
+						 ::java::lang::reflect::Proxy$ProxyData *)
+{
+  return 0;
+}

libjava/testsuite/ChangeLog

@@ -1,3 +1,13 @@
+2002-09-29  Anthony Green  <green@redhat.com>
+
+	* libjava.lang/TestProxy.java: New file.
+	* libjava.lang/TestProxy.out: Ditto.
+
+2002-09-29  Anthony Green  <green@redhat.com>
+
+	* libjava.lang/utf8concat.java: New file.
+	* libjava.lang/utf8concat.out: Ditto.
+
 2002-08-26  Tom Tromey  <tromey@redhat.com>
 
 	* libjava.compile/narrow_case.java: New file.

libjava/testsuite/Makefile.in

@@ -1,6 +1,6 @@
-# Makefile.in generated automatically by automake 1.4 from Makefile.am
+# Makefile.in generated automatically by automake 1.4-p5 from Makefile.am
 
-# Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc.
+# Copyright (C) 1994, 1995-8, 1999, 2001 Free Software Foundation, Inc.
 # This Makefile.in is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
 # with or without modifications, as long as this notice is preserved.

libjava/testsuite/libjava.lang/TestProxy.java

@@ -0,0 +1,34 @@
+import java.lang.reflect.*;
+import java.net.*;
+
+public class TestProxy
+{
+  public class MyInvocationHandler implements InvocationHandler
+  {
+    public Object invoke (Object proxy,
+			  Method method,
+			  Object[] args)
+      throws Throwable
+    {
+      System.out.println (args[0]);
+      return null;
+    }
+  }
+
+  public static void main (String[] args)
+  {
+    try {
+      InvocationHandler ih = new MyInvocationHandler();
+      
+      SocketOptions c = (SocketOptions)
+	Proxy.newProxyInstance (SocketOptions.class.getClassLoader(),
+				new Class[]{SocketOptions.class},
+				ih);
+      
+      c.getOption (555);
+
+    } catch (Exception e) {
+      e.printStackTrace ();
+    }
+  }
+}

libjava/testsuite/libjava.lang/TestProxy.out

@@ -0,0 +1 @@
+555

libjava/testsuite/libjava.lang/utf8concat.java

@@ -0,0 +1,11 @@
+public class utf8concat
+{
+  private static String s;
+
+  public static void main (String[] args)
+  {
+    // This causes a crash at runtime because the compiler is
+    // producing an invalid UTF-8 string literal.
+    s = "abc" + (char)183;
+  }
+}