deep-c-rsc/JCGO/goclsp/vm/java/lang/VMClass.java

/*
 * @(#) $(JCGO)/goclsp/vm/java/lang/VMClass.java --
 * VM specific methods for Java "Class" class.
 **
 * Project: JCGO (http://www.ivmaisoft.com/jcgo/)
 * Copyright (C) 2001-2009 Ivan Maidanski <ivmai@ivmaisoft.com>
 * All rights reserved.
 **
 * Class specification origin: GNU Classpath v0.93 vm/reference
 */

/*
 * 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;

import java.lang.annotation.Annotation;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.VMAccessorJavaLangReflect;

final class VMClass /* hard-coded class name */
{

 final static class IdentityHashMap
 { /* used by VM classes only */

  private Object[] table = new Object[13 << 1];

  private int size;

  IdentityHashMap() {}

  Object get(Object key)
  {
   Object[] table = this.table;
   int i = indexFor(key, table);
   return table[i] == key ? table[i + 1] : null;
  }

  Object put(Object key, Object value)
  {
   Object[] table = this.table;
   int i = indexFor(key, table);
   if (table[i] == key)
   {
    Object oldValue = table[i + 1];
    table[i + 1] = value;
    return oldValue;
   }
   if (value != null)
   {
    if ((table.length >>> 3) * 3 < size)
    {
     Object[] oldTable = table;
     int j = oldTable.length;
     table = new Object[(j + 1) << 1];
     int count = 0;
     Object oldKey;
     Object oldValue;
     while ((j -= 2) >= 0)
      if ((oldKey = oldTable[j]) != null &&
          (oldValue = oldTable[j + 1]) != null)
      {
       i = indexFor(oldKey, table);
       table[i] = oldKey;
       table[i + 1] = oldValue;
       count++;
      }
     this.table = table;
     size = count;
     i = indexFor(key, table);
    }
    size++;
    table[i] = key;
    table[i + 1] = value;
   }
   return null;
  }

  private static int indexFor(Object key, Object[] table)
  {
   int i = VMSystem.identityHashCode(key);
   i += ~(i << 9);
   if ((i = (((i >>> 14) ^ i) % (table.length >> 1)) << 1) < 0)
    i = -i;
   Object oldKey;
   while ((oldKey = table[i]) != key && oldKey != null)
    if ((i -= 2) < 0)
     i = table.length - 2;
   return i;
  }
 }

 private static final class StaticData
 {

  static final IdentityHashMap classBasicCtors = new IdentityHashMap();

  static final IdentityHashMap classSigners = new IdentityHashMap();

  static final IdentityHashMap arrayClasses = createArrayClassesMap();

  private static IdentityHashMap createArrayClassesMap()
  {
   IdentityHashMap arrayClasses = new IdentityHashMap();
   arrayClasses.put(boolean.class, boolean[].class); /* hack */
   arrayClasses.put(byte.class, byte[].class);
   arrayClasses.put(char.class, char[].class);
   arrayClasses.put(short.class, short[].class);
   arrayClasses.put(int.class, int[].class);
   arrayClasses.put(long.class, long[].class);
   arrayClasses.put(float.class, float[].class);
   arrayClasses.put(double.class, double[].class);
   return arrayClasses;
  }
 }

 private static final int MODIFIER_PUBLIC = 0x1;
 private static final int MODIFIER_PRIVATE = 0x2;
 private static final int MODIFIER_PROTECTED = 0x4;
 private static final int MODIFIER_FINAL = 0x10;

 private static final int MODIFIER_VOLATILE = 0x40;
 private static final int MODIFIER_TRANSIENT = 0x80;
 private static final int MODIFIER_NATIVE = 0x100;
 private static final int MODIFIER_INTERFACE = 0x200;
 private static final int MODIFIER_ABSTRACT = 0x400;

 private VMClass() {}

 static boolean isInstance(Class klass, Object obj)
 {
  return obj != null && isAssignableFrom(klass, obj.getClass());
 }

 static boolean isAssignableFrom(Class klass, Class aclass)
 {
  if (aclass == null)
   throw new NullPointerException();
  if (klass == aclass)
   return true;
  Class clazz;
  while ((clazz = getComponentType(klass)) != null)
  {
   klass = clazz;
   if ((aclass = getComponentType(aclass)) == null)
    return false;
  }
  if (getSuperclass(klass) != null)
  {
   do
   {
    aclass = getSuperclass(aclass);
    if (klass == aclass)
     return true;
   } while (aclass != null);
  }
   else
   {
    if (isInterface(klass))
    {
     do
     {
      if (isImplementedBy(klass, aclass))
       return true;
     } while ((aclass = getSuperclass(aclass)) != null);
    }
     else if (!isPrimitive(klass) && !isPrimitive(aclass))
      return true;
   }
  return false;
 }

 static boolean isInterface(Class klass)
 {
  return (klass.modifiers & MODIFIER_INTERFACE) != 0;
 }

 static String getName(Class klass)
 {
  /* return klass.name; */
  throw new InternalError(); /* hack */
 }

 static boolean isPrimitive(Class klass)
 {
  return klass.modifiers == (MODIFIER_PUBLIC | MODIFIER_FINAL |
          MODIFIER_ABSTRACT) && klass.superclass == null; /* hack */
 }

 static Class getSuperclass(Class klass)
 {
  return (klass.modifiers & ~(MODIFIER_PUBLIC | MODIFIER_PRIVATE | /* hack */
          MODIFIER_PROTECTED)) == (MODIFIER_FINAL | MODIFIER_ABSTRACT) ?
          (klass.superclass != null ? Object.class : null) : klass.superclass;
 }

 static Class[] getInterfaces(Class klass)
 {
  /* return klass.interfaces.clone(); */
  throw new InternalError(); /* hack */
 }

 static boolean isArray(Class klass)
 {
  return (klass.modifiers & ~(MODIFIER_PUBLIC | MODIFIER_PRIVATE |
          MODIFIER_PROTECTED)) == (MODIFIER_FINAL | MODIFIER_ABSTRACT) &&
          klass.superclass != null; /* hack */
 }

 static Class getComponentType(Class klass)
 {
  return (klass.modifiers & ~(MODIFIER_PUBLIC | MODIFIER_PRIVATE |
          MODIFIER_PROTECTED)) == (MODIFIER_FINAL | MODIFIER_ABSTRACT) ?
          klass.superclass : null; /* hack */
 }

 static int getModifiers(Class klass, boolean ignoreInnerClassesAttrib)
 {
  int modifiers = klass.modifiers;
  if (ignoreInnerClassesAttrib && (modifiers & MODIFIER_PRIVATE) == 0)
   while ((klass = getDeclaringClass(klass)) != null)
   {
    int outerMods = klass.modifiers;
    if ((outerMods & MODIFIER_PRIVATE) != 0)
    {
     modifiers = (modifiers & ~(MODIFIER_PUBLIC | MODIFIER_PROTECTED)) |
                  MODIFIER_PRIVATE;
     break;
    }
     else if ((outerMods & MODIFIER_PROTECTED) != 0)
      modifiers &= ~MODIFIER_PUBLIC;
      else if ((outerMods & MODIFIER_PUBLIC) == 0)
       modifiers &= ~(MODIFIER_PUBLIC | MODIFIER_PROTECTED);
   }
  return modifiers & ~(MODIFIER_VOLATILE | MODIFIER_TRANSIENT |
          MODIFIER_NATIVE);
 }

 static Class getDeclaringClass(Class klass)
 {
  String name = klass.getName();
  int ofs = name.lastIndexOf('$');
  return ofs > 0 && name.charAt(0) != '[' && name.length() - 1 > ofs &&
          !isAsciiDigit(name.charAt(ofs + 1)) ? loadClassResolve(
          name.substring(0, ofs), getClassLoaderInner(klass)) : null;
 }

 static Class[] getDeclaredClasses(Class klass, boolean publicOnly)
 {
  String name = klass.getName();
  String baseName = name.concat("$");
  Class[] classes = new Class[0];
  Class aclass;
  ClassLoader loader = getClassLoader(klass);
  int count = 0;
  while ((aclass = VMClassLoader.getNextInnerClass(name)) != null)
  {
   name = aclass.getName();
   if (!name.regionMatches(0, baseName, 0, baseName.length()))
    break;
   if (getDeclaringClass(aclass) == klass &&
       (!publicOnly || (aclass.modifiers & MODIFIER_PUBLIC) != 0))
   {
    if (loader != null)
     loader.resolveClass(aclass);
     else VMClassLoader.resolveClass(aclass);
    if (classes.length <= count)
    {
     Class[] newClasses = new Class[(count >> 1) + count + 3];
     if (count != 0)
      VMSystem.arraycopy(classes, 0, newClasses, 0, count);
     classes = newClasses;
    }
    classes[count++] = aclass;
   }
  }
  if (classes.length > count)
  {
   Class[] newClasses = new Class[count];
   VMSystem.arraycopy(classes, 0, newClasses, 0, count);
   classes = newClasses;
  }
  return classes;
 }

 static Field[] getDeclaredFields(Class klass, boolean publicOnly)
 {
  return VMAccessorJavaLangReflect.getDeclaredFieldsVMField(klass,
          publicOnly);
 }

 static Method[] getDeclaredMethods(Class klass, boolean publicOnly)
 {
  return VMAccessorJavaLangReflect.getDeclaredMethodsVMMethod(klass,
          publicOnly);
 }

 static Constructor[] getDeclaredConstructors(Class klass, boolean publicOnly)
 {
  return VMAccessorJavaLangReflect.getDeclaredConstructorsVMMethod(klass,
          publicOnly);
 }

 static ClassLoader getClassLoader(Class klass)
 {
  if (klass == null && /* hack */
      ClassLoader.StaticData.systemClassLoader == null) /* hack */
   return null;
  return getClassLoaderInner(klass);
 }

 static Class forName(String name, boolean initialize, ClassLoader loader)
  throws ClassNotFoundException
 {
  if (name == null)
   throw new NullPointerException();
  Class aclass;
  if (name.length() > 0 && name.charAt(0) == '[')
   aclass = loadArrayClass(name, loader);
   else
   {
    if (loader != null)
    {
     aclass = loader.loadClass(name);
     if (aclass != null)
      loader.resolveClass(aclass);
    }
     else aclass = VMClassLoader.loadClass(name, true);
    if (aclass == null)
     throw new ClassNotFoundException(name);
    if (initialize)
     initialize(aclass);
   }
  return aclass;
 }

 static void throwException(Throwable throwable)
 {
  if (throwable instanceof Error)
   throw (Error) throwable;
  if (throwable instanceof RuntimeException)
   throw (RuntimeException) throwable;
  if (throwable == null)
   throw new NullPointerException();
  throwException0(throwable);
 }

 static String getSimpleName(Class klass)
 {
  Class aclass = getComponentType(klass);
  if (aclass != null)
   return getSimpleName(aclass).concat("[]");
  String name = klass.getName();
  name = name.substring(name.lastIndexOf('.') + 1);
  int ofs = name.lastIndexOf('$') + 1;
  while (name.length() > ofs && isAsciiDigit(name.charAt(ofs)))
   ofs++;
  return name.substring(ofs);
 }

 static String getCanonicalName(Class klass)
 {
  Class aclass = getComponentType(klass);
  if (aclass != null)
  {
   String name = getCanonicalName(aclass);
   return name != null ? name.concat("[]") : null;
  }
  aclass = getDeclaringClass(klass);
  if (aclass != null)
  {
   String name = getCanonicalName(aclass);
   return name != null ? name.concat(".").concat(getSimpleName(klass)) : null;
  }
  return isLocalClass(klass) || isAnonymousClass(klass) ? null :
          klass.getName();
 }

 static Annotation[] getDeclaredAnnotations(Class klass)
 {
  /* not implemented */
  return new Annotation[0];
 }

 static Class getEnclosingClass(Class klass)
 {
  /* not implemented correctly for anonymous and local classes */
  String name = klass.getName();
  int ofs = name.lastIndexOf('$');
  return ofs > 0 && name.charAt(0) != '[' && name.length() - 1 > ofs ?
          loadClassResolve(name.substring(0, ofs),
          getClassLoaderInner(klass)) : null;
 }

 static Constructor getEnclosingConstructor(Class klass)
 {
  /* not implemented */
  return null;
 }

 static Method getEnclosingMethod(Class klass)
 {
  /* not implemented */
  return null;
 }

 static native String getClassSignature(Class klass); /* JVM-core */

 static boolean isAnonymousClass(Class klass)
 {
  return getSimpleName(klass).length() == 0;
 }

 static boolean isLocalClass(Class klass)
 {
  int ofs;
  String name = klass.getName();
  return !isArray(klass) && (ofs = getSimpleName(klass).length()) > 0 &&
          (ofs = name.length() - ofs - 1) > 1 &&
          isAsciiDigit(name.charAt(ofs));
 }

 static boolean isMemberClass(Class klass)
 {
  return getDeclaringClass(klass) != null;
 }

 static final Class arrayClassOf0X(Class klass,
   int dims) /* hard-coded method signature */
 { /* called from native code */
  if (dims > 0)
  {
   if (klass == void.class)
    throw new InternalError();
   Class origClass = klass;
   int absDims = dims;
   synchronized (StaticData.arrayClasses)
   {
    do
    {
     Class aclass = (Class) StaticData.arrayClasses.get(klass);
     if (aclass == null)
      break;
     klass = aclass;
    } while (--dims > 0);
    if (dims > 0)
    {
     absDims -= dims;
     while ((origClass = getComponentType(origClass)) != null)
      absDims++;
     String className;
     if ((className = klass.name) == null) /* hack */
      className = "<UnknownClass>";
     origClass = boolean[].class; /* hack */
     Class[] interfaces = origClass.interfaces;
     int modifiers =
      (klass.modifiers & (MODIFIER_PUBLIC | MODIFIER_PRIVATE |
      MODIFIER_PROTECTED)) | (MODIFIER_FINAL | MODIFIER_ABSTRACT);
     do
     {
      Object vmdata = vmdataForObjArray0(++absDims);
      if (vmdata == null)
       throw new OutOfMemoryError("array class dimensions limit exceeded");
      className = absDims > 1 ? "[".concat(className) :
                   "[L".concat(className).concat(";");
      Class aclass = new Class(vmdata, className, klass, interfaces,
                      modifiers);
      StaticData.arrayClasses.put(klass, aclass);
      klass = aclass;
     } while (--dims > 0);
    }
   }
  }
  if (klass == null) /* hack */
   throw new InternalError();
  return klass;
 }

 static final Class classForSig(String sig, Class klass)
 { /* used by VM classes only */
  int nameLen = sig.length();
  Class aclass = null;
  if (nameLen > 0)
  {
   char ch = sig.charAt(0);
   if (nameLen == 1)
    return VMClassLoader.getPrimitiveClass(ch);
   if (sig.indexOf('.', 0) < 0)
   {
    if (ch == 'L')
    {
     if (sig.charAt(nameLen - 1) != ';')
      return null;
     sig = sig.substring(1, nameLen - 1);
    }
     else if (ch != '[')
      return null;
    try
    {
     aclass = forName(sig.replace('/', '.'), false,
               klass != null ? getClassLoaderInner(klass) : null);
    }
    catch (ClassNotFoundException e) {}
   }
  }
  return aclass;
 }

 static final Class[] getInterfacesInner(Class klass)
 { /* used by VM classes only */
  return klass.interfaces;
 }

 static final void initialize(Class klass)
 { /* used by VM classes only */
  initialize0(klass);
 }

 static final boolean hasClassInitializer(Class klass)
 { /* used by VM classes only */
  return (klass.modifiers & MODIFIER_NATIVE) != 0;
 }

 static final String getClassStatus(Class klass)
 { /* used by VM classes only */
  int flags = klass.modifiers & (MODIFIER_VOLATILE | MODIFIER_TRANSIENT);
  return flags == 0 ? "INITIALIZED" : flags == MODIFIER_TRANSIENT ?
          "PREPARED" : flags == (MODIFIER_VOLATILE | MODIFIER_TRANSIENT) ?
          "VERIFIED" : "ERROR";
 }

 static final String getSourceFilename(Class klass)
 { /* used by VM classes only */
  Class aclass;
  while ((aclass = getComponentType(klass)) != null)
   klass = aclass;
  String filename = null;
  if (!isPrimitive(klass))
  {
   while ((aclass = getEnclosingClass(klass)) != null)
    klass = aclass;
   if ((klass.modifiers & MODIFIER_PUBLIC) != 0 ||
       (klass = getSourceHeadClass0(klass)) != null)
    filename = klass.getName().replace('.', '/').concat(".java");
  }
  return filename;
 }

 static final void setBasicConstructorOf(Class klass, Constructor constructor)
 { /* used by VM classes only */
  synchronized (StaticData.classBasicCtors)
  {
   StaticData.classBasicCtors.put(klass, constructor);
  }
 }

 static final Constructor getBasicConstructorOf(Class klass)
 { /* used by VM classes only */
  synchronized (StaticData.classBasicCtors)
  {
   return (Constructor) StaticData.classBasicCtors.get(klass);
  }
 }

 static final void setClassSignersOf(Class klass, Object[] signers)
 { /* used by VM classes only */
  synchronized (StaticData.classSigners)
  {
   StaticData.classSigners.put(klass, signers);
  }
 }

 static final Object[] getClassSignersOf(Class klass)
 { /* used by VM classes only */
  synchronized (StaticData.classSigners)
  {
   return (Object[]) StaticData.classSigners.get(klass);
  }
 }

 private static boolean isAsciiDigit(char ch)
 {
  return ch >= '0' && ch <= '9';
 }

 private static ClassLoader getClassLoaderInner(Class klass)
 {
  Class aclass;
  while ((aclass = getComponentType(klass)) != null)
   klass = aclass;
  ClassLoader loader = VMClassLoader.getLoaderOfDefinedClass(klass);
  if (loader != null)
   return loader;
  String name = klass.getName();
  return name.startsWith("java.") || name.startsWith("javax.") ||
          name.startsWith("gnu.java.") || name.startsWith("gnu.javax.") ||
          name.startsWith("gnu.classpath.") ? null :
          (ClassLoader) getClassLoader0(klass);
 }

 private static Class loadClassResolve(String name, ClassLoader loader)
 {
  Class aclass = null;
  try
  {
   aclass = loader != null ? loader.loadClass(name, true) :
             VMClassLoader.loadClass(name, true);
  }
  catch (ClassNotFoundException e) {}
  if (aclass != null)
  {
   if (getClassLoaderInner(aclass) != loader)
    aclass = null;
    else if (loader != null)
     loader.resolveClass(aclass);
     else VMClassLoader.resolveClass(aclass);
  }
  return aclass;
 }

 private static Class loadArrayClass(String name, ClassLoader loader)
  throws ClassNotFoundException
 {
  int nameLen = name.length();
  int dims = 0;
  while (dims < nameLen && name.charAt(dims) == '[')
   dims++;
  Class aclass = null;
  if (dims > 0 && dims < nameLen)
  {
   char ch = name.charAt(dims);
   if (ch == 'L')
   {
    if (nameLen - 1 > dims && name.charAt(nameLen - 1) == ';')
    {
     String className = name.substring(dims + 1, nameLen - 1);
     aclass = loader != null ? loader.loadClass(className) :
               VMClassLoader.loadClass(className, false);
    }
   }
    else if (nameLen - 1 == dims && ch != 'V')
     aclass = VMClassLoader.getPrimitiveClass(ch);
  }
  if (aclass == null)
   throw new ClassNotFoundException(name);
  return arrayClassOf0X(aclass, dims);
 }

 private static boolean isImplementedBy(Class klass, Class aclass)
 {
  do
  {
   Class[] interfaces = aclass.interfaces;
   int i;
   if ((i = interfaces.length) == 0)
    break;
   do
   {
    aclass = interfaces[--i];
    if (klass == aclass)
     return true;
    if (i == 0)
     break;
    if (isImplementedBy(klass, aclass))
     return true;
   } while (true);
  } while (true);
  return false;
 }

 private static native int initialize0(Class klass); /* JVM-core */

 private static native Object getClassLoader0(Class klass); /* JVM-core */

 private static native void throwException0(Object throwable); /* JVM-core */

 private static native Object vmdataForObjArray0(int dims); /* JVM-core */

 private static native Class getSourceHeadClass0(Class klass); /* JVM-core */
}