class.c

来自「基于LWVCL开发的库」· C语言 代码 · 共 680 行 · 第 1/2 页

		if (utf8ConstEqual(init_name, mth[i].name))
			continue;

		*ptr = KaffeVM_makeReflectMethod(clazz, i);
		ptr++;
	}

	return (array);
}

HArrayOfObject*
java_lang_VMClass_getDeclaredConstructors(struct Hjava_lang_Class* clas, jboolean publicOnly)
{
	int count;
	Hjava_lang_reflect_Constructor** ptr;
	HArrayOfObject* array;
	int i;
	Method* mth = Kaffe_get_class_methods(clas);

	count = 0;
	for (i = CLASS_NMETHODS(clas)-1; i >= 0;  i--) {
		if ((mth[i].kFlags & KFLAG_CONSTRUCTOR) == 0)
			continue;

		if (publicOnly && ((mth[i].accflags&ACC_PUBLIC)==0))
			continue;
		
		count++;
	}
	array = (HArrayOfObject*)
	   AllocObjectArray(count, "Ljava/lang/reflect/Constructor;", NULL);
	ptr = (Hjava_lang_reflect_Constructor**)&unhand_array(array)->body[0];

	for (i = CLASS_NMETHODS(clas)-1; i >= 0;  i--) {
		if ((mth[i].kFlags & KFLAG_CONSTRUCTOR) == 0)
			continue;

		if (publicOnly && ((mth[i].accflags&ACC_PUBLIC)==0))
			continue;

		*ptr = KaffeVM_makeReflectConstructor(clas, i);
		ptr++;
	}
	return (array);
}

/*
 * Below, "declared" means to include a field only if it is directly
 * declared by that class (and not inherited from a superclass or defined
 * by an interface the class implements.)  This applies to both private,
 * protected, and public fields.
 *
 * On the other hand, if "declared" is false, we only include public
 * fields.  Weird semantics.
 */
HArrayOfObject*
java_lang_VMClass_getDeclaredFields(struct Hjava_lang_Class* clazz, jboolean publicOnly)
{
	int count;
	Hjava_lang_reflect_Field** ptr;
	HArrayOfObject* array;
	int i;
	Field *fld = CLASS_FIELDS(clazz);

	if (publicOnly) {
		count = 0;
		for (i = CLASS_NFIELDS(clazz)-1; i >= 0; i--) {
			if (publicOnly && ((fld[i].accflags&ACC_PUBLIC)==0))
				continue;
			
			count++;
		}
	} else {
		count = CLASS_NFIELDS(clazz);
	}

	array = (HArrayOfObject*)
	    AllocObjectArray(count, "Ljava/lang/reflect/Field;", NULL);
	ptr = (Hjava_lang_reflect_Field**)&unhand_array(array)->body[0];

	for (i = CLASS_NFIELDS(clazz)-1; i >= 0;  i--) {
		if (publicOnly && ((fld[i].accflags & ACC_PUBLIC)==0))
			continue;

		
		*ptr = KaffeVM_makeReflectField(clazz, i);
		ptr++;
	}

	return (array);
}

Hjava_lang_Class*
java_lang_VMClass_getDeclaringClass(struct Hjava_lang_Class* this)
{
	errorInfo		einfo;
	Hjava_lang_Class 	*ret = NULL;

	if (unhand(this)->this_inner_index >= 0) {
		innerClass	*ic = unhand(this)->inner_classes;
		int oc = ic[unhand(this)->this_inner_index].outer_class;

		if (oc == 0)
		  return NULL;

		ret = getClass (oc,
				this,
				&einfo);

		if (ret == NULL)
			throwError(&einfo);
	}
	return ret;
}


HArrayOfObject*
java_lang_VMClass_getDeclaredClasses(struct Hjava_lang_Class* clazz, jboolean publicOnly)
{
	errorInfo einfo;
	int count;
	int i;
	innerClass *ic;
	Hjava_lang_Class* c;
	HArrayOfObject* array;
	Hjava_lang_Class** ptr;

	/* if we don't have inner classes, bail out */
	if (clazz->nr_inner_classes == 0)
		return (HArrayOfObject*)AllocObjectArray(0, "Ljava/lang/Class;", NULL);

	count = 0;
	for (i = clazz->nr_inner_classes, ic = clazz->inner_classes; i-- > 0; ic++) {
		/* assume one unique constant pool entry per class */
		if (ic->outer_class != clazz->this_index)
			continue;
		if (publicOnly && ((ic->inner_class_accflags&ACC_PUBLIC)==0))
			continue;

		count++;
	}

	array = (HArrayOfObject*)
		AllocObjectArray(count, "Ljava/lang/Class;", NULL);

	ptr = (Hjava_lang_Class**)&unhand_array(array)->body[0];

	for (i = clazz->nr_inner_classes, ic = clazz->inner_classes; i-- > 0; ic++) {
		/* assume one unique constant pool entry per class */
		if (ic->outer_class != clazz->this_index)
			continue;
		if (publicOnly && ((ic->inner_class_accflags&ACC_PUBLIC)==0))
			continue;

		c = getClass (ic->inner_class, clazz, &einfo);
		if (c == NULL) {
			throwError(&einfo);
		}
		*ptr++ = c;
	}
	return array;
}


void
java_lang_VMClass_throwException (struct Hjava_lang_Throwable *throwable)
{
	throwExternalException(throwable);
}

struct Hjava_lang_Class*
java_lang_VMClass_getEnclosingClass(struct Hjava_lang_Class* klass)
{
  errorInfo einfo;
  struct Hjava_lang_Class *enclosing;

  if (klass->enclosingClassIndex == 0)
    return NULL;

  enclosing = getClass(klass->enclosingClassIndex, klass, &einfo);
  if (enclosing == NULL)
    discardErrorInfo(&einfo);

  return enclosing;
}

struct Hjava_lang_reflect_Constructor*
java_lang_VMClass_getEnclosingConstructor(struct Hjava_lang_Class* klass)
{
  errorInfo einfo;
  constants *pool;
  constIndex emi = klass->enclosingMethodIndex;
  constIndex eci = klass->enclosingClassIndex;
  constIndex ni;
  Utf8Const *name, *sig;
  Hjava_lang_Class *enclosingClass;
  Method *method;
  int methodSlot;

  if (emi == 0)
    return NULL;

  pool = CLASS_CONSTANTS (klass);

  enclosingClass = getClass(eci, klass, &einfo);
  if (enclosingClass == NULL)
    {
      discardErrorInfo(&einfo);
      return NULL;
    }
  
  switch (pool->tags[emi])
    {
    case CONSTANT_Methodref:
      ni = METHODREF_NAMEANDTYPE(emi, pool);
      name = WORD2UTF(pool->data[NAMEANDTYPE_NAME(ni, pool)]);
      sig = WORD2UTF(pool->data[NAMEANDTYPE_SIGNATURE(ni, pool)]);
      method = findMethodLocal(enclosingClass, name, sig);
      if (method != NULL)
	{
	  lockClass (klass);
	  if (pool->tags[emi] != CONSTANT_ResolvedMethod)
	    {
	      pool->tags[emi] = CONSTANT_ResolvedMethod;
	      pool->data[emi] = (ConstSlot)method;
	    }
	  else
	    method = (Method*)pool->data[emi];
	  unlockClass (klass);
	}
      break;
    case CONSTANT_ResolvedMethod:
      method = (Method *)pool->data[emi];
      break;
    default:
      return NULL;
    }

  if (method == NULL || !METHOD_IS_CONSTRUCTOR (method))
    return NULL;

  methodSlot = method - Kaffe_get_class_methods(klass);
  assert(methodSlot < CLASS_NMETHODS(klass));
  
  return KaffeVM_makeReflectConstructor(klass, methodSlot);
}

struct Hjava_lang_reflect_Method*
java_lang_VMClass_getEnclosingMethod(struct Hjava_lang_Class* klass)
{
  errorInfo einfo;
  constants *pool;
  constIndex emi = klass->enclosingMethodIndex;
  constIndex eci = klass->enclosingClassIndex;
  constIndex ni;
  Utf8Const *name, *sig;
  Hjava_lang_Class *enclosingClass;
  Method *method;
  int methodSlot;

  if (emi == 0)
    return NULL;

  pool = CLASS_CONSTANTS (klass);

  enclosingClass = getClass(eci, klass, &einfo);
  if (enclosingClass == NULL)
    {
      discardErrorInfo(&einfo);
      return NULL;
    }
  
  switch (pool->tags[emi])
    {
    case CONSTANT_Methodref:
      ni = METHODREF_NAMEANDTYPE(emi, pool);
      name = WORD2UTF(pool->data[NAMEANDTYPE_NAME(ni, pool)]);
      sig = WORD2UTF(pool->data[NAMEANDTYPE_SIGNATURE(ni, pool)]);
      method = findMethodLocal(enclosingClass, name, sig);
      if (method != NULL)
	{
	  lockClass (klass);
	  if (pool->tags[emi] != CONSTANT_ResolvedMethod)
	    {
	      pool->tags[emi] = CONSTANT_ResolvedMethod;
	      pool->data[emi] = (ConstSlot)method;
	    }
	  else
	    method = (Method*)pool->data[emi];
	  unlockClass (klass);
	}
      break;
    case CONSTANT_ResolvedMethod:
      method = (Method *)pool->data[emi];
      break;
    default:
      return NULL;
    }

  if (method == NULL || METHOD_IS_CONSTRUCTOR (method))
    return NULL;

  methodSlot = method - Kaffe_get_class_methods(klass);
  assert(methodSlot < CLASS_NMETHODS(klass));
  
  return KaffeVM_makeReflectMethod(klass, methodSlot);
}

struct Hjava_lang_String*
java_lang_VMClass_getClassSignature(struct Hjava_lang_Class* klass)
{
  if (klass->extSignature == NULL)
    return NULL;

  return utf8Const2Java(klass->extSignature);
}

jboolean
java_lang_VMClass_isAnonymousClass(struct Hjava_lang_Class* klass)
{
  /* We do not follow the specification exactly here. However we may want to be
   * compatible. Testcase ?
   */
  return ((klass->kFlags & KFLAG_ANONYMOUS) != 0);
}


jboolean
java_lang_VMClass_isLocalClass(struct Hjava_lang_Class* klass)
{
  return (klass->enclosingClassIndex != 0);
}

jboolean
java_lang_VMClass_isMemberClass(struct Hjava_lang_Class* klass)
{
  return (klass->this_inner_index >= 0);
}