*
* Note: This class returns and accepts types as Classes, even
* primitive types; there are Class types defined that represent each
* different primitive type. They are java.lang.Boolean.TYPE,
* java.lang.Byte.TYPE,, also available as boolean.class,
* byte.class, etc. These are not to be confused with the
* classes java.lang.Boolean, java.lang.Byte, etc., which are
* real classes.
*
* 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
*
* If the method is static,
*
* Next, if this Method enforces access control, your runtime context is
* evaluated, and you may have an
*
* 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
* Modifier
* 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 int getModifiers()
{
/* DB: Modified prototype of native method. */
return nativeGetModifiers(vmData);
}
private static native int nativeGetModifiers(byte[] vmData);
/**
* Gets the return type of this method.
* @return the type of this method
*/
//public native Class getReturnType();
public Class getReturnType()
{
if (returnType == null)
{
returnType =
ReflectUtil.getReturnType(nativeGetDescriptor(vmData),
getDeclaringClass().getClassLoader());
}
return returnType;
}
/**
* 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 native Class[] getParameterTypes();
public Class[] getParameterTypes()
{
if (parameterTypes == null)
{
parameterTypes =
ReflectUtil.getParameterTypes(nativeGetDescriptor(vmData),
getDeclaringClass().getClassLoader());
}
return parameterTypes;
}
/**
* 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 native Class[] getExceptionTypes();
public Class[] getExceptionTypes()
{
if (exceptionTypes == null)
{
exceptionTypes = nativeGetExceptionTypes(vmData);
}
return exceptionTypes;
}
public static native Class[] nativeGetExceptionTypes(byte[] vmData);
/**
* Compare two objects to see if they are semantically equivalent.
* Two Methods are semantically equivalent if they have the same declaring
* class, name, parameter list, and return type.
*
* @param o the object to compare to
* @return true if they are equal; false if not
*/
public boolean equals(Object o)
{
// Implementation note:
// The following is a correct but possibly slow implementation.
//
// This class has a private field 'slot' that could be used by
// the VM implementation to "link" a particular method to a Class.
// In that case equals could be simply implemented as:
//
// if (o instanceof Method)
// {
// Method m = (Method)o;
// return m.declaringClass == this.declaringClass
// && m.slot == this.slot;
// }
// return false;
//
// If a VM uses the Method class as their native/internal representation
// then just using the following would be optimal:
//
// return this == o;
//
if (!(o instanceof Method))
return false;
Method that = (Method)o;
if (this.getDeclaringClass() != that.getDeclaringClass())
return false;
if (!this.getName().equals(that.getName()))
return false;
if (this.getReturnType() != that.getReturnType())
return false;
if (!Arrays.equals(this.getParameterTypes(), that.getParameterTypes()))
return false;
return true;
}
/**
* Get the hash code for the Method. The Method hash code is the hash code
* of its name XOR'd with the hash code of its class name.
*
* @return the hash code for the object
*/
public int hashCode()
{
return getDeclaringClass().getName().hashCode() ^ getName().hashCode();
}
/**
* 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.
Example:
* public static int run(java.lang.Runnable,int)
*
* @return the String representation of the Method
*/
public String toString()
{
// 128 is a reasonable buffer initial size for constructor
StringBuffer sb = new StringBuffer(128);
Modifier.toString(getModifiers(), sb).append(' ');
sb.append(getUserTypeName(getReturnType().getName())).append(' ');
sb.append(getDeclaringClass().getName()).append('.');
sb.append(getName()).append('(');
Class[] c = getParameterTypes();
if (c.length > 0)
{
sb.append(getUserTypeName(c[0].getName()));
for (int i = 1; i < c.length; i++)
sb.append(',').append(getUserTypeName(c[i].getName()));
}
sb.append(')');
c = getExceptionTypes();
if (c.length > 0)
{
sb.append(" throws ").append(c[0].getName());
for (int i = 1; i < c.length; i++)
sb.append(',').append(c[i].getName());
}
return sb.toString();
}
private static String getUserTypeName(String typeSpec)
{
int pos = 0;
String typeName = "";
String arrayPart = "";
while (typeSpec.charAt(pos) == '[')
{
arrayPart += "[]";
++pos;
}
switch (typeSpec.charAt(pos))
{
case 'Z':
typeName = "boolean";
break;
case 'B':
typeName = "byte";
break;
case 'C':
typeName = "char";
break;
case 'D':
typeName = "double";
break;
case 'F':
typeName = "float";
break;
case 'I':
typeName = "int";
break;
case 'J':
typeName = "long";
break;
case 'S':
typeName = "short";
break;
case 'L':
typeName = typeSpec.substring(pos + 1, typeSpec.length() - 1);
break;
default:
typeName = typeSpec;
break;
}
return typeName + arrayPart;
}
/**
* Invoke the method. Arguments are automatically unwrapped and widened,
* and the result is automatically wrapped, if needed.o 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 NullPointerException if o is
* null, and an IllegalArgumentException 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 args.IllegalAccessException 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
* ExceptionInInitializerError.InvocationTargetException.
*
* @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 o is not an instance of the class or interface
* declaring this method
* @throws InvocationTargetException if the method throws an exception
* @throws NullPointerException if o is null and this field
* requires an instance
* @throws ExceptionInInitializerError if accessing a static method triggered
* class initialization, which then failed
*/
/*
public Object invoke(Object o, Object[] args)
throws IllegalAccessException, InvocationTargetException
{
return invokeNative(o, args, declaringClass, slot);
}
*/
public Object invoke(Object o, Object[] args)
throws IllegalAccessException, InvocationTargetException
{
if (args == null) {
args = new Object[0];
} else {
/*
* If args actual type is not Object[], allocate an Object[]
* and copy the args to that array.
*
* If this is not done, an ArrayStoreException may result
* in the following code.
*
* ex: Boolean[] passed.
*
* boolean[] wrapper = new boolean[1];
* wrapper[0] = ((Boolean) args[i]).booleanValue();
* --> args[i] = wrapper;
*
* ArrayStoreException since boolean[] is not assignable to
* type Boolean.
*
*/
if (args.getClass() != Object[].class) {
Object[] newArgs;
newArgs = new Object[args.length];
System.arraycopy(args, 0, newArgs, 0, args.length);
// ugly, changing param value
args = newArgs;
}
}
char[] paramTypes = getParamTypes();
Class[] parameterTypes = getParameterTypes();
int count = paramTypes.length;
if (count != args.length)
{
throw new IllegalArgumentException("incorrect number of arguments");
}
try {
for (int i = 0; i < count; i++)
{
switch (paramTypes[i])
{
case 'Z':
{
/* using a wrapper array is simpler for the VM. */
boolean[] wrapper = new boolean[1];
wrapper[0] = ((Boolean) args[i]).booleanValue();
args[i] = wrapper;
}
break;
case 'B':
{
byte[] wrapper = new byte[1];
wrapper[0] = ((Byte) args[i]).byteValue();
args[i] = wrapper;
}
break;
case 'S':
{
short[] wrapper = new short[1];
wrapper[0] = ((Short) args[i]).shortValue();
args[i] = wrapper;
}
break;
case 'C':
{
char[] wrapper = new char[1];
wrapper[0] = ((Character) args[i]).charValue();
args[i] = wrapper;
}
break;
case 'I':
{
int[] wrapper = new int[1];
wrapper[0] = ((Integer) args[i]).intValue();
args[i] = wrapper;
}
break;
case 'J':
{
long[] wrapper = new long[1];
wrapper[0] = ((Long) args[i]).longValue();
args[i] = wrapper;
}
break;
case 'F':
{
float[] wrapper = new float[1];
wrapper[0] = ((Float) args[i]).floatValue();
args[i] = wrapper;
}
break;
case 'D':
{
double[] wrapper = new double[1];
wrapper[0] = ((Double) args[i]).doubleValue();
args[i] = wrapper;
}
break;
case 'L':
{
// check type
if (args[i] != null) {
if (!(parameterTypes[i].isAssignableFrom(args[i].getClass()))) {
throw new IllegalArgumentException("argument of incorrect type");
}
}
}
break;
default:
throw new InternalError();
}
}
} catch (ClassCastException e) {
throw new IllegalArgumentException("argument of incorrect type");
}
Object result;
switch (resultType)
{
case 'Z':
{
boolean[] wrapper = new boolean[1];
result = wrapper;
}
break;
case 'B':
{
byte[] wrapper = new byte[1];
result = wrapper;
}
break;
case 'S':
{
short[] wrapper = new short[1];
result = wrapper;
}
break;
case 'C':
{
char[] wrapper = new char[1];
result = wrapper;
}
break;
case 'I':
{
int[] wrapper = new int[1];
result = wrapper;
}
break;
case 'J':
{
long[] wrapper = new long[1];
result = wrapper;
}
break;
case 'F':
{
float[] wrapper = new float[1];
result = wrapper;
}
break;
case 'D':
{
double[] wrapper = new double[1];
result = wrapper;
}
break;
case 'L':
{
Object[] wrapper = new Object[1];
result = wrapper;
}
break;
case 'V':
{
result = null;
}
break;
default:
throw new InternalError();
}
// invoke the thing.
invokeNative(vmData, paramTypes, resultType, o, args, result);
// unwrap and rewrap the result appropriately
switch (resultType)
{
case 'Z':
{
boolean[] wrapper = (boolean[]) result;
return new Boolean(wrapper[0]);
}
case 'B':
{
byte[] wrapper = (byte[]) result;
return new Byte(wrapper[0]);
}
case 'S':
{
short[] wrapper = (short[]) result;
return new Short(wrapper[0]);
}
case 'C':
{
char[] wrapper = (char[]) result;
return new Character(wrapper[0]);
}
case 'I':
{
int[] wrapper = (int[]) result;
return new Integer(wrapper[0]);
}
case 'J':
{
long[] wrapper = (long[]) result;
return new Long(wrapper[0]);
}
case 'F':
{
float[] wrapper = (float[]) result;
return new Float(wrapper[0]);
}
case 'D':
{
double[] wrapper = (double[]) result;
return new Double(wrapper[0]);
}
case 'L':
{
Object[] wrapper = (Object[]) result;
return wrapper[0];
}
case 'V':
{
return null;
}
default:
throw new InternalError();
}
}
private static native void invokeNative(byte[] vmData, char[] paramTypes, char resultType, Object o, Object[] args, Object result)
throws IllegalAccessException, InvocationTargetException;
private static native String nativeGetDescriptor(byte[] vmData);
private char[] paramTypes;
private char resultType;
private char[] getParamTypes()
{
if(paramTypes == null)
{
char[] array = nativeGetDescriptor(vmData).toCharArray();
int count = 0;
int i = 0;
char c;
while ((c = array[++i]) != ')')
{
switch (c)
{
case 'Z':
case 'B':
case 'S':
case 'C':
case 'I':
case 'J':
case 'F':
case 'D':
{
array[count++] = c;
}
break;
case 'L':
{
array[count++] = 'L';
/* skip to next ';' */
while (array[++i] != ';')
;
}
break;
case '[':
{
array[count++] = 'L';
/* skip all '[' */
while (array[++i] == '[')
;
if (array[i] == 'L')
{
/* skip to next ';' */
while (array[++i] != ';')
;
}
}
break;
default:
throw new InternalError();
}
}
switch (c = array[++i])
{
case 'Z':
case 'B':
case 'S':
case 'C':
case 'I':
case 'J':
case 'F':
case 'D':
case 'L':
case 'V':
{
resultType = c;
}
break;
case '[':
{
resultType = 'L';
}
break;
default:
throw new InternalError();
}
char[] types = new char[count];
System.arraycopy(array, 0, types, 0, count);
paramTypes = types;
}
return paramTypes;
}
}