deep-c-rsc/JCGO/goclsp/vm/java/lang/reflect/VMMethod.java

/*
 * @(#) $(JCGO)/goclsp/vm/java/lang/reflect/VMMethod.java --
 * VM specific methods for Java "Method" implementation.
 **
 * Project: JCGO (http://www.ivmaisoft.com/jcgo/)
 * Copyright (C) 2001-2009 Ivan Maidanski <ivmai@ivmaisoft.com>
 * All rights reserved.
 */

/*
 * This 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.
 **
 * This software 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 (GPL) for more details.
 **
 * 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;

final class VMMethod /* hard-coded class name */
{ /* VM class */ /* used by VM classes only */

 private static final int TYPECODE_BOOLEAN = 1;

 private static final int TYPECODE_BYTE = 2;

 private static final int TYPECODE_CHAR = 3;

 private static final int TYPECODE_SHORT = 4;

 private static final int TYPECODE_INT = 5;

 private static final int TYPECODE_LONG = 6;

 private static final int TYPECODE_FLOAT = 7;

 private static final int TYPECODE_DOUBLE = 8;

 private static final int TYPECODE_OBJECT = 9;

 private static final Class[] EMPTY_TYPES = {};

 static
 {
  if (!"".equals("")) /* hack */
  {
   getMethodDeclClass0X(null); /* hack */
   getMethodSlot0X(null); /* hack */
   getMethodByName0X(void.class, "", "", 0); /* hack */
   getMethodBySlot0X(void.class, 0); /* hack */
  }
 }

 private VMMethod() {}

 static final int getModifiersInternal(Method method)
 {
  return method.modifiers;
 }

 static final Class getReturnType(Method method)
 {
  Class type = method.returnType;
  if (type == null) /* hack */
   throw new InternalError();
  return type;
 }

 static final Class[] getParameterTypesInternal(Method method)
 {
  return method.parameterTypes;
 }

 static final Class[] getExceptionTypesInternal(Method method)
 {
  return method.exceptionTypes;
 }

 static final String getSignature(Method method)
 {
  return method.signature;
 }

 static final Object invoke(Method method, Object obj, Object[] args,
   Class caller)
  throws IllegalAccessException, InvocationTargetException
 {
  int modifiers = getModifiersInternal(method);
  Class declaringClass = method.getDeclaringClass();
  if ((modifiers & Modifier.STATIC) == 0)
  {
   if (obj == null)
    throw new NullPointerException();
   if (!declaringClass.isInstance(obj))
    throw new IllegalArgumentException(
           "not an instance of a method declaring class: " +
           declaringClass.getName() + "." + method.getName());
  }
  if (caller != declaringClass && ((modifiers & Modifier.PUBLIC) == 0 ||
      (declaringClass.getModifiers() & Modifier.PUBLIC) == 0) &&
      caller != null && ((modifiers & Modifier.PRIVATE) != 0 ||
      (((modifiers & Modifier.PROTECTED) == 0 ||
      !declaringClass.isAssignableFrom(caller)) &&
      !packageNameOf(declaringClass).equals(packageNameOf(caller)))))
   throw new IllegalAccessException("method not accessible: " +
          declaringClass.getName() + "." + method.getName());
  Class[] parameterTypes = getParameterTypesInternal(method);
  int argsCnt = parameterTypes.length;
  if ((args != null ? args.length : 0) != argsCnt)
   throw new IllegalArgumentException("method arguments number mismatch");
  byte[] argsTypecodes = new byte[argsCnt];
  int longArgsLen = 0;
  int floatArgsLen = 0;
  int doubleArgsLen = 0;
  int objectArgsLen = 0;
  for (int i = 0; i < argsCnt; i++)
  {
   Class type = parameterTypes[i];
   int typecode;
   if (type == double.class)
   {
    typecode = TYPECODE_DOUBLE;
    doubleArgsLen++;
   }
    else if (type == float.class)
    {
     typecode = TYPECODE_FLOAT;
     floatArgsLen++;
    }
     else if (type == long.class)
     {
      typecode = TYPECODE_LONG;
      longArgsLen++;
     }
      else if (type == int.class)
       typecode = TYPECODE_INT;
       else if (type == short.class)
        typecode = TYPECODE_SHORT;
        else if (type == char.class)
         typecode = TYPECODE_CHAR;
         else if (type == byte.class)
          typecode = TYPECODE_BYTE;
          else if (type == boolean.class)
           typecode = TYPECODE_BOOLEAN;
           else
           {
            typecode = TYPECODE_OBJECT;
            objectArgsLen++;
           }
   argsTypecodes[i] = (byte) typecode;
  }
  int intArgsLen = argsCnt - (longArgsLen + floatArgsLen + doubleArgsLen +
                    objectArgsLen);
  int[] intArgs = new int[intArgsLen > 0 ? intArgsLen : 1];
  long[] longArgs = new long[longArgsLen > 0 ? longArgsLen : 1];
  float[] floatArgs = new float[floatArgsLen > 0 ? floatArgsLen : 1];
  double[] doubleArgs = new double[doubleArgsLen > 0 ? doubleArgsLen : 1];
  Object[] objectArgs = new Object[objectArgsLen];
  intArgsLen = 0;
  longArgsLen = 0;
  floatArgsLen = 0;
  doubleArgsLen = 0;
  objectArgsLen = 0;
  for (int i = 0; i < argsCnt; i++)
  {
   int typecode = argsTypecodes[i];
   Object value = args[i];
   switch (typecode)
   {
   case TYPECODE_BOOLEAN:
    if (!(value instanceof Boolean))
     throw new IllegalArgumentException("method argument type mismatch");
    intArgs[intArgsLen++] = ((Boolean) value).booleanValue() ? 1 : 0;
    break;
   case TYPECODE_BYTE:
    if (!(value instanceof Byte))
     throw new IllegalArgumentException("method argument type mismatch");
    intArgs[intArgsLen++] = ((Byte) value).intValue();
    break;
   case TYPECODE_CHAR:
    if (!(value instanceof Character))
     throw new IllegalArgumentException("method argument type mismatch");
    intArgs[intArgsLen++] = ((Character) value).charValue();
    break;
   case TYPECODE_SHORT:
    int intValue;
    if (value instanceof Short)
     intValue = ((Short) value).intValue();
     else if (value instanceof Byte)
      intValue = ((Byte) value).intValue();
      else throw new IllegalArgumentException(
                  "method argument type mismatch");
    intArgs[intArgsLen++] = intValue;
    break;
   case TYPECODE_INT:
    intArgs[intArgsLen++] = unwrapIntValue(value);
    break;
   case TYPECODE_LONG:
    long longValue;
    if (value instanceof Long)
     longValue = ((Long) value).longValue();
     else longValue = unwrapIntValue(value);
    longArgs[longArgsLen++] = longValue;
    break;
   case TYPECODE_FLOAT:
    float floatValue;
    if (value instanceof Float)
     floatValue = ((Float) value).floatValue();
     else if (value instanceof Long)
      floatValue = ((Long) value).floatValue();
      else floatValue = unwrapIntValue(value);
    floatArgs[floatArgsLen++] = floatValue;
    break;
   case TYPECODE_DOUBLE:
    double doubleValue;
    if (value instanceof Double)
     doubleValue = ((Double) value).doubleValue();
     else if (value instanceof Float)
      doubleValue = ((Float) value).doubleValue();
      else if (value instanceof Long)
       doubleValue = ((Long) value).doubleValue();
       else doubleValue = unwrapIntValue(value);
    doubleArgs[doubleArgsLen++] = doubleValue;
    break;
   default:
    if (value != null && !parameterTypes[i].isInstance(value))
     throw new IllegalArgumentException(
            "method argument reference type mismatch");
    objectArgs[objectArgsLen++] = value;
    break;
   }
  }
  int allowOverride = 0;
  if ((modifiers & Modifier.STATIC) != 0)
  {
   obj = null;
   VMAccessorJavaLang.initializeVMClass(declaringClass);
  }
   else if ((modifiers & (Modifier.PRIVATE | Modifier.FINAL)) == 0 &&
            (declaringClass.getModifiers() & Modifier.FINAL) == 0)
    allowOverride = 1;
  Object value;
  try
  {
   value = invokeNative0(declaringClass, obj, argsTypecodes, intArgs,
            longArgs, floatArgs, doubleArgs, objectArgs, argsCnt, method.slot,
            allowOverride);
  }
  catch (Error e)
  {
   throw e;
  }
  catch (Throwable e)
  {
   throw new InvocationTargetException(e);
  }
  Class type = getReturnType(method);
  if (type == double.class)
   value = new Double(doubleArgs[0]);
   else if (type == float.class)
    value = new Float(floatArgs[0]);
    else if (type == long.class)
     value = new Long(longArgs[0]);
     else if (type == int.class)
      value = new Integer(intArgs[0]);
      else if (type == short.class)
       value = new Short((short) intArgs[0]);
       else if (type == char.class)
        value = new Character((char) intArgs[0]);
        else if (type == byte.class)
         value = new Byte((byte) intArgs[0]);
         else if (type == boolean.class)
          value = intArgs[0] != 0 ? Boolean.TRUE : Boolean.FALSE;
  return value;
 }

 static final Object invokeProxyHandler(InvocationHandler handler,
   Proxy proxy, Class declaringClass, int[] intArgs, long[] longArgs,
   float[] floatArgs, double[] doubleArgs, Object[] objectArgs, int slot,
   int proxySlot)
  throws Throwable
 {
  Method method = null;
  Class returnType = void.class;
  Class[] parameterTypes = EMPTY_TYPES;
  int argsCnt = 0;
  if (declaringClass != null)
  {
   Class[] methTypes = getMethodsTypes0(declaringClass)[slot];
   if (methTypes != null)
   {
    byte[][] methodsDims;
    byte[] dims = (methodsDims = getMethodsDims0(declaringClass)) != null ?
                   methodsDims[slot] : null;
    argsCnt = methTypes.length - 1;
    returnType = makeArrayClass(methTypes, dims, argsCnt);
    if (argsCnt > 0)
     parameterTypes = dims != null ? makeParameterTypes(argsCnt, methTypes,
                       dims) : copyTypes(methTypes, argsCnt);
   }
   Class[][] methodsThrows = getMethodsThrows0(declaringClass);
   Class[] exceptionTypes;
   short[] modifiers = getMethodsModifiers0(declaringClass);
   String[] signatures = getMethodsSignature0(declaringClass);
   method = new Method(declaringClass, getMethodsName0(declaringClass)[slot],
             slot, returnType, parameterTypes, methodsThrows != null &&
             (exceptionTypes = methodsThrows[slot]) != null ? exceptionTypes :
             EMPTY_TYPES, modifiers != null ? modifiers[slot] & 0xffff :
             declaringClass.isInterface() ? Modifier.PUBLIC |
             Modifier.ABSTRACT : Modifier.PUBLIC, signatures != null ?
             signatures[slot] : null);
  }
  Object[] args = null;
  if (argsCnt > 0)
  {
   args = new Object[argsCnt];
   int intArgsPos = 0;
   int longArgsPos = 0;
   int floatArgsPos = 0;
   int doubleArgsPos = 0;
   int objectArgsPos = 0;
   for (int i = 0; i < argsCnt; i++)
   {
    Class type = parameterTypes[i];
    args[i] =
     type == double.class ? new Double(doubleArgs[doubleArgsPos++]) :
     type == float.class ? new Float(floatArgs[floatArgsPos++]) :
     type == long.class ? new Long(longArgs[longArgsPos++]) :
     type == int.class ? new Integer(intArgs[intArgsPos++]) :
     type == short.class ? new Short((short) intArgs[intArgsPos++]) :
     type == char.class ? new Character((char) intArgs[intArgsPos++]) :
     type == byte.class ? new Byte((byte) intArgs[intArgsPos++]) :
     type == boolean.class ? (intArgs[intArgsPos++] != 0 ?
     Boolean.TRUE : Boolean.FALSE) : objectArgs[objectArgsPos++];
   }
  }
  Object value;
  try
  {
   value = handler.invoke(proxy, method, args);
  }
  catch (Error e)
  {
   throw e;
  }
  catch (RuntimeException e)
  {
   throw e;
  }
  catch (Throwable e)
  {
   Class[] exceptionTypes = method.exceptionTypes;
   if (proxySlot >= 0)
   {
    Class[][] methodsThrows = getMethodsThrows0(proxy.getClass());
    if (methodsThrows == null ||
        (exceptionTypes = methodsThrows[proxySlot]) == null)
     exceptionTypes = EMPTY_TYPES;
   }
   int cnt = exceptionTypes.length;
   if (cnt != 0)
   {
    Class excClass = e.getClass();
    for (int i = 0; i < cnt; i++)
     if (exceptionTypes[i].isAssignableFrom(excClass))
      throw e;
   }
   throw new UndeclaredThrowableException(e);
  }
  if (returnType == void.class)
   value = null;
   else
   {
    Class wrapperClass = returnType;
    if (returnType == double.class)
     wrapperClass = Double.class;
     else if (returnType == float.class)
      wrapperClass = Float.class;
      else if (returnType == long.class)
       wrapperClass = Long.class;
       else if (returnType == int.class)
        wrapperClass = Integer.class;
        else if (returnType == short.class)
         wrapperClass = Short.class;
         else if (returnType == char.class)
          wrapperClass = Character.class;
          else if (returnType == byte.class)
           wrapperClass = Byte.class;
           else if (returnType == boolean.class)
            wrapperClass = Boolean.class;
    if (value != null && !wrapperClass.isInstance(value))
     throw new ClassCastException(value.getClass().getName());
    if (wrapperClass != returnType)
    {
     if (value == null)
      throw new NullPointerException();
     if (returnType == double.class)
      doubleArgs[0] = ((Double) value).doubleValue();
      else if (returnType == float.class)
       floatArgs[0] = ((Float) value).floatValue();
       else if (returnType == long.class)
        longArgs[0] = ((Long) value).longValue();
        else intArgs[0] =
              returnType == int.class ? ((Integer) value).intValue() :
              returnType == short.class ? ((Short) value).intValue() :
              returnType == char.class ? ((Character) value).charValue() :
              returnType == byte.class ? ((Byte) value).intValue() :
              ((Boolean) value).booleanValue() ? 1 : 0;
     value = null;
    }
   }
  return value;
 }

 static final Constructor[] getDeclaredConstructors(Class klass,
   boolean publicOnly)
 {
  Class[][] methodsTypes;
  int count;
  if (klass.isInterface() || klass.isPrimitive() || klass.isArray() ||
      (methodsTypes = getMethodsTypes0(klass)) == null ||
      (count = methodsTypes.length) == 0)
   return new Constructor[0];
  String[] names = getMethodsName0(klass);
  short[] modifiers = getMethodsModifiers0(klass);
  if (modifiers == null)
   publicOnly = false;
  int cnt = count;
  if (names != null)
  {
   for (int i = 0; i < count; i++)
    if ((names[i] != null && names[i].length() > 0) ||
        (publicOnly && (modifiers[i] & Modifier.PUBLIC) == 0))
     cnt--;
  }
   else
   {
    if (publicOnly)
     for (int i = 0; i < count; i++)
      if ((modifiers[i] & Modifier.PUBLIC) == 0)
       cnt--;
   }
  Constructor[] constructors = new Constructor[cnt];
  if (cnt > 0)
  {
   byte[][] methodsDims = getMethodsDims0(klass);
   Class[][] methodsThrows = getMethodsThrows0(klass);
   String[] signatures = getMethodsSignature0(klass);
   cnt = 0;
   for (int i = 0; i < count; i++)
    if ((names == null || names[i] == null || names[i].length() == 0) &&
        (!publicOnly || (modifiers[i] & Modifier.PUBLIC) != 0))
    {
     Class[] ctorTypes = methodsTypes[i];
     Class[] parameterTypes = EMPTY_TYPES;
     if (ctorTypes != null)
     {
      byte[] dims = methodsDims != null ? methodsDims[i] : null;
      parameterTypes = ctorTypes;
      if (dims != null)
       parameterTypes = makeParameterTypes(ctorTypes.length, ctorTypes, dims);
     }
     Class[] exceptionTypes = methodsThrows != null ? methodsThrows[i] : null;
     constructors[cnt++] = new Constructor(klass, i, parameterTypes,
                            exceptionTypes != null ? exceptionTypes :
                            EMPTY_TYPES, modifiers != null ?
                            modifiers[i] & 0xffff : Modifier.PUBLIC,
                            signatures != null ? signatures[i] : null);
    }
  }
  return constructors;
 }

 static final Method[] getDeclaredMethods(Class klass, boolean publicOnly)
 {
  String[] names;
  int count;
  if (klass.isPrimitive() || klass.isArray() ||
      (names = getMethodsName0(klass)) == null || (count = names.length) == 0)
   return new Method[0];
  short[] modifiers = getMethodsModifiers0(klass);
  if (modifiers == null)
   publicOnly = false;
  int cnt = 0;
  for (int i = 0; i < count; i++)
   if (names[i] != null && names[i].length() != 0 &&
       (!publicOnly || (modifiers[i] & Modifier.PUBLIC) != 0))
    cnt++;
  Method[] methods = new Method[cnt];
  if (cnt != 0)
  {
   Class[][] methodsTypes = getMethodsTypes0(klass);
   byte[][] methodsDims = getMethodsDims0(klass);
   Class[][] methodsThrows = getMethodsThrows0(klass);
   String[] signatures = getMethodsSignature0(klass);
   int mods = klass.isInterface() ? Modifier.PUBLIC | Modifier.ABSTRACT :
               Modifier.PUBLIC;
   cnt = 0;
   for (int i = 0; i < count; i++)
    if (!publicOnly || (modifiers[i] & Modifier.PUBLIC) != 0)
    {
     String name = names[i];
     if (name != null && name.length() != 0)
     {
      Class[] methTypes = methodsTypes[i];
      Class returnType = void.class;
      Class[] parameterTypes = EMPTY_TYPES;
      if (methTypes != null)
      {
       byte[] dims = methodsDims != null ? methodsDims[i] : null;
       int argsCnt = methTypes.length - 1;
       returnType = makeArrayClass(methTypes, dims, argsCnt);
       if (argsCnt > 0)
        parameterTypes = dims != null ? makeParameterTypes(argsCnt, methTypes,
                          dims) : copyTypes(methTypes, argsCnt);
      }
      Class[] exceptionTypes = methodsThrows != null ?
                                methodsThrows[i] : null;
      methods[cnt++] = new Method(klass, name, i, returnType, parameterTypes,
                        exceptionTypes != null ? exceptionTypes : EMPTY_TYPES,
                        modifiers != null ? modifiers[i] & 0xffff : mods,
                        signatures != null ? signatures[i] : null);
     }
    }
  }
  return methods;
 }

 static final Constructor getDeclaredConstructor(Class klass, Class[] types)
 { /* used by VM classes only */
  Class[][] methodsTypes;
  int count;
  if (!klass.isInterface() && !klass.isPrimitive() && !klass.isArray() &&
      (methodsTypes = getMethodsTypes0(klass)) != null &&
      (count = methodsTypes.length) > 0)
  {
   String[] names = getMethodsName0(klass);
   byte[][] methodsDims = null;
   if (types != null)
    methodsDims = getMethodsDims0(klass);
    else types = EMPTY_TYPES;
   for (int i = 0; i < count; i++)
    if (names == null || names[i] == null || names[i].length() == 0)
    {
     Class[] ctorTypes;
     if ((ctorTypes = methodsTypes[i]) == null)
      ctorTypes = EMPTY_TYPES;
     byte[] dims;
     int argsCnt = ctorTypes.length;
     if (types.length == argsCnt && matchMethodTypes(argsCnt, ctorTypes,
         dims = methodsDims != null ? methodsDims[i] : null, types))
     {
      Class[] parameterTypes = ctorTypes;
      if (dims != null)
       parameterTypes = makeParameterTypes(argsCnt, ctorTypes, dims);
      Class[][] methodsThrows = getMethodsThrows0(klass);
      Class[] exceptionTypes = methodsThrows != null ?
                                methodsThrows[i] : null;
      short[] modifiers;
      String[] signatures;
      return new Constructor(klass, i, parameterTypes,
              exceptionTypes != null ? exceptionTypes : EMPTY_TYPES,
              (modifiers = getMethodsModifiers0(klass)) != null ?
              modifiers[i] & 0xffff : Modifier.PUBLIC,
              (signatures = getMethodsSignature0(klass)) != null ?
              signatures[i] : null);
     }
    }
  }
  return null;
 }

 static final Method getDeclaredMethod(Class klass, String methodName,
   Class[] types)
 { /* used by VM classes only */
  String[] names;
  int count;
  if (methodName.length() > 0 && !klass.isPrimitive() && !klass.isArray() &&
      (names = getMethodsName0(klass)) != null && (count = names.length) > 0)
  {
   Class[][] methodsTypes = getMethodsTypes0(klass);
   byte[][] methodsDims = getMethodsDims0(klass);
   if (types == null)
    types = EMPTY_TYPES;
   for (int i = 0; i < count; i++)
    if (methodName.equals(names[i]))
    {
     Class[] methTypes = methodsTypes[i];
     int argsCnt = 0;
     if (methTypes != null)
      argsCnt = methTypes.length - 1;
     byte[] dims;
     if (types.length == argsCnt && matchMethodTypes(argsCnt, methTypes,
         dims = methodsDims != null ? methodsDims[i] : null, types))
     {
      Class returnType = void.class;
      Class[] parameterTypes = EMPTY_TYPES;
      if (methTypes != null)
      {
       returnType = makeArrayClass(methTypes, dims, argsCnt);
       if (argsCnt > 0)
        parameterTypes = dims != null ? makeParameterTypes(argsCnt, methTypes,
                          dims) : copyTypes(methTypes, argsCnt);
      }
      Class[][] methodsThrows = getMethodsThrows0(klass);
      Class[] exceptionTypes = methodsThrows != null ?
                                methodsThrows[i] : null;
      short[] modifiers;
      String[] signatures;
      return new Method(klass, methodName, i, returnType, parameterTypes,
              exceptionTypes != null ? exceptionTypes : EMPTY_TYPES,
              (modifiers = getMethodsModifiers0(klass)) != null ?
              modifiers[i] & 0xffff : klass.isInterface() ?
              Modifier.PUBLIC | Modifier.ABSTRACT : Modifier.PUBLIC,
              (signatures = getMethodsSignature0(klass)) != null ?
              signatures[i] : null);
     }
    }
  }
  return null;
 }

 static final Class getMethodDeclClass0X(Object methodObj)
  throws ClassCastException
 { /* called from native code */
  Class declaringClass = methodObj instanceof Constructor ?
                          ((Constructor) methodObj).getDeclaringClass() :
                          ((Method) methodObj).getDeclaringClass();
  VMAccessorJavaLang.initializeVMClass(declaringClass);
  return declaringClass;
 }

 static final int getMethodSlot0X(Object methodObj)
 { /* called from native code */
  return methodObj instanceof Constructor ? ((Constructor) methodObj).slot :
          ((Method) methodObj).slot;
 }

 static final Object getMethodByName0X(Class klass, String name,
   String paramSig, int isStatic)
 { /* called from native code */
  Class[] sigTypes;
  if (klass.isPrimitive() || klass.isArray() || name.length() == 0 ||
      (sigTypes = decodeMethodSig(paramSig, klass)) == null)
   return null;
  if (name.equals("<init>"))
   return isStatic == 0 && !klass.isInterface() &&
           sigTypes[sigTypes.length - 1] == void.class ?
           getMethodByNameInner(klass, null, sigTypes, false) : null;
  if (name.equals("<clinit>"))
  {
   if (isStatic != 0 && sigTypes.length == 1 && sigTypes[0] == void.class)
    do
    {
     if (VMAccessorJavaLang.hasClassInitializerVMClass(klass))
      return new Method(klass, "<clinit>", -1, void.class, EMPTY_TYPES,
              EMPTY_TYPES, Modifier.STATIC | Modifier.SYNTHETIC, null);
    } while ((klass = klass.getSuperclass()) != null);
   return null;
  }
  return isStatic == 0 || !klass.isInterface() ?
          getMethodByNameInner(klass, name, sigTypes, isStatic != 0) : null;
 }

 static final Object getMethodBySlot0X(Class klass, long slot)
 { /* called from native code */
  Class[][] methodsTypes;
  int count;
  if (slot < 0 || klass.isPrimitive() || klass.isArray() ||
      (methodsTypes = getMethodsTypes0(klass)) == null ||
      (count = methodsTypes.length) <= slot)
   return null;
  String[] names = getMethodsName0(klass);
  String name = null;
  int intSlot = (int) slot;
  if (names != null && (name = names[intSlot]) != null && name.length() == 0)
   name = null;
  Class[] methTypes = methodsTypes[intSlot];
  Class returnType = void.class;
  Class[] parameterTypes = EMPTY_TYPES;
  if (methTypes != null)
  {
   int argsCnt = methTypes.length;
   byte[][] methodsDims;
   byte[] dims = (methodsDims = getMethodsDims0(klass)) != null ?
                  methodsDims[intSlot] : null;
   if (name != null)
   {
    argsCnt--;
    returnType = makeArrayClass(methTypes, dims, argsCnt);
   }
   if (argsCnt > 0)
    parameterTypes = dims != null ? makeParameterTypes(argsCnt, methTypes,
                      dims) : name != null ? copyTypes(methTypes, argsCnt) :
                      methTypes;
  }
  Class[][] methodsThrows = getMethodsThrows0(klass);
  Class[] exceptionTypes = methodsThrows != null ?
                            methodsThrows[intSlot] : null;
  short[] modifiers = getMethodsModifiers0(klass);
  String[] signatures = getMethodsSignature0(klass);
  String signature = signatures != null ? signatures[intSlot] : null;
  if (exceptionTypes == null)
   exceptionTypes = EMPTY_TYPES;
  if (name != null)
   return new Method(klass, name, intSlot, returnType, parameterTypes,
           exceptionTypes, modifiers != null ? modifiers[intSlot] & 0xffff :
           klass.isInterface() ? Modifier.PUBLIC | Modifier.ABSTRACT :
           Modifier.PUBLIC, signature);
  return new Constructor(klass, intSlot, parameterTypes, exceptionTypes,
          modifiers != null ? modifiers[intSlot] & 0xffff : Modifier.PUBLIC,
          signature);
 }

 private static Object getMethodByNameInner(Class klass, String name,
   Class[] sigTypes, boolean isStatic)
 {
  int argsCnt = sigTypes.length - 1;
  Class returnType = sigTypes[argsCnt];
  Class aclass = klass;
  Object method = null;
  do
  {
   Class[][] methodsTypes;
   String[] names;
   int count;
   if ((methodsTypes = getMethodsTypes0(aclass)) != null &&
       (count = methodsTypes.length) != 0 &&
       ((names = getMethodsName0(aclass)) != null || name == null))
   {
    byte[][] methodsDims = getMethodsDims0(aclass);
    short[] modifiers = getMethodsModifiers0(aclass);
    Class[] methTypes;
    int mods = aclass.isInterface() ? Modifier.PUBLIC | Modifier.ABSTRACT :
                Modifier.PUBLIC;
    for (int i = 0; i < count; i++)
     if ((name != null ? name.equals(names[i]) :
         names == null || names[i] == null || names[i].length() == 0) &&
         ((methTypes = methodsTypes[i]) != null ? methTypes.length -
         (name != null ? 1 : 0) == argsCnt : argsCnt == 0) && (name != null &&
         methTypes != null ? makeArrayClass(methTypes, methodsDims != null ?
         methodsDims[i] : null, argsCnt) : void.class) == returnType &&
         (((modifiers != null ? (mods = modifiers[i] & 0xffff) :
         mods) & Modifier.STATIC) != 0) == isStatic)
     {
      byte[] dims = methodsDims != null && argsCnt > 0 ?
                     methodsDims[i] : null;
      if (matchMethodTypes(argsCnt, methTypes, dims, sigTypes))
      {
       Class[] parameterTypes = EMPTY_TYPES;
       if (argsCnt > 0 && methTypes != null)
        parameterTypes = dims != null || name != null ?
                          copyTypes(sigTypes, argsCnt) : methTypes;
       Class[][] methodsThrows;
       Class[] exceptionTypes;
       if ((methodsThrows = getMethodsThrows0(aclass)) == null ||
           (exceptionTypes = methodsThrows[i]) == null)
        exceptionTypes = EMPTY_TYPES;
       String[] signatures = getMethodsSignature0(aclass);
       String signature = signatures != null ? signatures[i] : null;
       Object m;
       if (name != null)
        m = new Method(aclass, names[i], i, returnType, parameterTypes,
             exceptionTypes, mods, signature);
        else m = new Constructor(aclass, i, parameterTypes, exceptionTypes,
                  mods, signature);
       if (aclass == klass ||
           (mods & (Modifier.PUBLIC | Modifier.PROTECTED)) != 0 ||
           ((mods & Modifier.PRIVATE) == 0 &&
           packageNameOf(aclass).equals(packageNameOf(klass))))
        return m;
       if (method == null)
        method = m;
       break;
      }
     }
   }
   if (name == null)
    break;
   if (!isStatic)
   {
    Class[] interfaces = VMAccessorJavaLang.getInterfacesInnerVMClass(aclass);
    int len = interfaces.length;
    for (int i = 0; i < len; i++)
    {
     Object m = getMethodByNameInner(interfaces[i], name, sigTypes, false);
     if (m != null)
      return m;
    }
   }
   aclass = aclass.getSuperclass();
  } while (aclass != null);
  return method;
 }

 private static Class[] decodeMethodSig(String paramSig, Class klass)
 {
  int len = paramSig.length();
  if (len <= 1 || paramSig.charAt(0) != '(')
   return null;
  int pos = 1;
  int count = 0;
  char ch;
  while ((ch = paramSig.charAt(pos)) != ')')
  {
   if (ch != '[')
   {
    if (ch == 'L' && (pos = paramSig.indexOf(';', pos + 1)) < 0)
     return null;
    count++;
   }
   if (++pos >= len)
    return null;
  }
  Class[] sigTypes = new Class[count + 1];
  pos = 1;
  for (int i = 0; i < count; i++)
  {
   int next = pos;
   while ((ch = paramSig.charAt(next)) == '[')
    next++;
   next = (ch == 'L' ? paramSig.indexOf(';', next + 1) : next) + 1;
   Class type = VMAccessorJavaLang.classForSigVMClass(paramSig.substring(pos,
                 next), klass);
   if (type == null || type == void.class)
    return null;
   sigTypes[i] = type;
   pos = next;
  }
  return (sigTypes[count] = VMAccessorJavaLang.classForSigVMClass(
          paramSig.substring(pos + 1), klass)) != null ? sigTypes : null;
 }

 private static int unwrapIntValue(Object value)
 {
  int intValue;
  if (value instanceof Integer)
   intValue = ((Integer) value).intValue();
   else if (value instanceof Short)
    intValue = ((Short) value).intValue();
    else if (value instanceof Character)
     intValue = ((Character) value).charValue();
     else if (value instanceof Byte)
      intValue = ((Byte) value).intValue();
      else throw new IllegalArgumentException(
                  "method argument type mismatch");
  return intValue;
 }

 private static String packageNameOf(Class aclass)
 {
  String name = aclass.getName();
  int lastInd = name.lastIndexOf('.');
  return lastInd > 0 ? name.substring(0, lastInd) : "";
 }

 private static Class[] copyTypes(Class[] types, int count)
 {
  Class[] destTypes = new Class[count];
  for (int i = 0; i < count; i++) /* hack */
   destTypes[i] = types[i];
  return destTypes;
 }

 private static boolean matchMethodTypes(int argsCnt, Class[] methTypes,
   byte[] dims, Class[] types)
 {
  for (int i = 0; i < argsCnt; i++)
   if (makeArrayClass(methTypes, dims, i) != types[i])
    return false;
  return true;
 }

 private static Class[] makeParameterTypes(int argsCnt, Class[] methTypes,
   byte[] dims)
 {
  Class[] parameterTypes = new Class[argsCnt];
  for (int i = 0; i < argsCnt; i++)
   parameterTypes[i] = VMAccessorJavaLang.arrayClassOfVMClass(methTypes[i],
                        dims[i] & 0xff);
  return parameterTypes;
 }

 private static Class makeArrayClass(Class[] types, byte[] dims, int index)
 {
  return dims != null ? VMAccessorJavaLang.arrayClassOfVMClass(types[index],
          dims[index] & 0xff) : types[index];
 }

 private static native String[] getMethodsName0(
   Class klass); /* JVM-core */ /* const data */

 private static native byte[][] getMethodsDims0(
   Class klass); /* JVM-core */ /* const data of const data */

 private static native Class[][] getMethodsThrows0(
   Class klass); /* JVM-core */ /* const data of const data */

 private static native short[] getMethodsModifiers0(
   Class klass); /* JVM-core */ /* const data */

 private static native String[] getMethodsSignature0(
   Class klass); /* JVM-core */ /* const data */

 private static native Class[][] getMethodsTypes0(
   Class klass); /* JVM-core */ /* const data of const data */

 private static native Object invokeNative0(Class declaringClass, Object obj,
   byte[] argsTypecodes, int[] intArgs, long[] longArgs, float[] floatArgs,
   double[] doubleArgs, Object[] objectArgs, int argsCnt, int slot,
   int allowOverride)
  throws Throwable; /* JVM-core */
}