jvm.c

来自「This is a resource based on j2me embedde」· C语言 代码 · 共 2,294 行 · 第 1/5 页

	return NULL;
    }
    return obj;
#else /* CVM_REFLECT */
    CVMthrowUnsupportedOperationException(CVMjniEnv2ExecEnv(env), NULL);
    return NULL;
#endif /* CVM_REFLECT */
}

JNIEXPORT jobjectArray JNICALL
JVM_GetClassConstructors(JNIEnv *env, jclass cls, jint which)
{
#ifdef CVM_REFLECT
    CVMExecEnv* ee = CVMjniEnv2ExecEnv(env);
    jobject obj = CVMjniCreateLocalRef(ee);
    if (obj == NULL) /* exception thrown */
	return NULL;
    CVMreflectConstructors(ee, CVMgcSafeClassRef2ClassBlock(ee, cls),
			   which, (CVMArrayOfRefICell*) obj);
    if (CVMexceptionOccurred(ee)) {
	CVMjniDeleteLocalRef(env, obj);
	return NULL;
    }
    return obj;
#else /* CVM_REFLECT */
    CVMthrowUnsupportedOperationException(CVMjniEnv2ExecEnv(env), NULL);
    return NULL;
#endif /* CVM_REFLECT */
}

JNIEXPORT jobject JNICALL
JVM_GetClassField(JNIEnv *env, jclass cls, jstring name, jint which)
{
#ifdef CVM_REFLECT
    CVMExecEnv* ee = CVMjniEnv2ExecEnv(env);
    jobject obj;
    const char *nameChars;
    
    if (name == NULL) {
	CVMthrowNullPointerException(ee, NULL);
	return NULL;
    }

    obj = CVMjniCreateLocalRef(ee);
    if (obj == NULL) /* exception thrown */
	return NULL;

    nameChars = (*env)->GetStringUTFChars(env, name, NULL);
    if (nameChars == NULL) {
	(*env)->DeleteLocalRef(env, obj);
	return NULL;
    }

    CVMreflectField(ee, CVMgcSafeClassRef2ClassBlock(ee, cls),
		    nameChars, which, (CVMObjectICell*) obj);
    (*env)->ReleaseStringUTFChars(env, name, nameChars);
    if (CVMexceptionOccurred(ee)) {
	CVMjniDeleteLocalRef(env, obj);
	return NULL;
    }
    return obj;
#else /* CVM_REFLECT */
    CVMthrowUnsupportedOperationException(CVMjniEnv2ExecEnv(env), NULL);
    return NULL;
#endif /* CVM_REFLECT */
}

JNIEXPORT jobject JNICALL
JVM_GetClassMethod(JNIEnv *env, jclass cls, jstring name, jobjectArray types,
		   jint which)
{
#ifdef CVM_REFLECT
    CVMExecEnv* ee = CVMjniEnv2ExecEnv(env);
    jobject obj;
    const char *nameChars;

    if (name == NULL) {
	CVMthrowNullPointerException(ee, NULL);
	return NULL;
    }
    
    obj = CVMjniCreateLocalRef(ee);
    if (obj == NULL) /* exception thrown */
	return NULL;

    nameChars = (*env)->GetStringUTFChars(env, name, NULL);
    if (nameChars == NULL) {
	(*env)->DeleteLocalRef(env, obj);
	return NULL;
    }

    CVMreflectMethod(ee, CVMgcSafeClassRef2ClassBlock(ee, cls),
		     nameChars, (CVMArrayOfRefICell*) types,
		     which, (CVMObjectICell*) obj);
    (*env)->ReleaseStringUTFChars(env, name, nameChars);
    if (CVMexceptionOccurred(ee)) {
	CVMjniDeleteLocalRef(env, obj);
	return NULL;
    }
    return obj;
#else /* CVM_REFLECT */
    CVMthrowUnsupportedOperationException(CVMjniEnv2ExecEnv(env), NULL);
    return NULL;
#endif /* CVM_REFLECT */
}

JNIEXPORT jobject JNICALL
JVM_GetClassConstructor(JNIEnv *env, jclass cls, jobjectArray types,
			jint which)
{
#ifdef CVM_REFLECT
    CVMExecEnv* ee = CVMjniEnv2ExecEnv(env);
    jobject obj = CVMjniCreateLocalRef(ee);
    if (obj == NULL) /* exception thrown */
	return NULL;
    CVMreflectConstructor(ee, CVMgcSafeClassRef2ClassBlock(ee, cls),
			  (CVMArrayOfRefICell*) types,
			  which, (CVMObjectICell*) obj);
    if (CVMexceptionOccurred(ee)) {
	CVMjniDeleteLocalRef(env, obj);
	return NULL;
    }
    return obj;
#else /* CVM_REFLECT */
    CVMthrowUnsupportedOperationException(CVMjniEnv2ExecEnv(env), NULL);
    return NULL;
#endif /* CVM_REFLECT */
}

JNIEXPORT jobjectArray JNICALL
JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass)
{
#ifdef CVM_REFLECT
    CVMExecEnv *ee = CVMjniEnv2ExecEnv(env);
    CVMClassBlock* cb = CVMgcSafeClassRef2ClassBlock(ee, ofClass);
    jobject obj = CVMjniCreateLocalRef(ee);
    if (obj == NULL)
	return NULL;
    CVMreflectInnerClasses(ee, cb, (CVMArrayOfRefICell*) obj);
    if (CVMexceptionOccurred(ee)) {
	CVMjniDeleteLocalRef(env, obj);
	return NULL;
    }
    return obj;
#else /* CVM_REFLECT */
    CVMthrowUnsupportedOperationException(CVMjniEnv2ExecEnv(env), NULL);
    return NULL;
#endif /* CVM_REFLECT */
}

JNIEXPORT jclass JNICALL
JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass)
{
#ifdef CVM_REFLECT
    CVMExecEnv *ee = CVMjniEnv2ExecEnv(env);
    CVMClassBlock* cb = CVMgcSafeClassRef2ClassBlock(ee, ofClass);
    CVMClassBlock* parentCb;

    parentCb = CVMreflectGetDeclaringClass(ee, cb);
    if (parentCb == NULL) {
	return NULL;
    }

    return (*env)->NewLocalRef(env, CVMcbJavaInstance(parentCb));
#else /* CVM_REFLECT */
    CVMthrowUnsupportedOperationException(CVMjniEnv2ExecEnv(env), NULL);
    return NULL;
#endif /* CVM_REFLECT */
}

JNIEXPORT jclass JNICALL
JVM_GetCallerClass(JNIEnv *env, int n)
{
    CVMExecEnv* ee = CVMjniEnv2ExecEnv(env);
    CVMClassBlock* cb = CVMgetCallerClass(ee, n);
    if (cb == NULL) {
	return NULL;
    } else {
	return (*env)->NewLocalRef(env, CVMcbJavaInstance(cb));
    }
}

#ifndef CDC_10
/* Assertion support. */

jboolean
JVM_DesiredAssertionStatus(JNIEnv *env, jclass unused, jclass cls)
{
    CVMExecEnv* ee = CVMjniEnv2ExecEnv(env);
    CVMClassBlock* cb;
    char* classname;
    jboolean result;
    CVMassert(cls != NULL);
    cb = CVMgcSafeClassRef2ClassBlock(ee, cls);
    CVMassert(!CVMcbIs(cb, PRIMITIVE));
    classname = CVMtypeidClassNameToAllocatedCString(CVMcbClassName(cb));
    if (classname == NULL) {
	CVMthrowOutOfMemoryError(ee, NULL);
	return CVM_FALSE;
    }
    result = CVMJavaAssertions_enabled(classname,
				       CVMcbClassLoader(cb) == NULL);
    free(classname);
    return result;
}


/* Return a new AssertionStatusDirectives object with the fields filled in with
   command-line assertion arguments (i.e., -ea, -da). */
jobject
JVM_AssertionStatusDirectives(JNIEnv *env, jclass unused)
{
    CVMExecEnv* ee = CVMjniEnv2ExecEnv(env);
    jobject asd = CVMJavaAssertions_createAssertionStatusDirectives(ee);
    if (CVMlocalExceptionOccurred(ee)) {
	return NULL;
    }
    return asd;
}
#endif /* !CDC_10 */

/* Note: JVM_NewInstance is not needed in CVM because Class.newInstance
   is implemented in Java. */

/*
 * Called from System.c
 */

JNIEXPORT jlong JNICALL
JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored)
{
    return CVMtimeMillis();
}

/*
 * Copies an array of refs to another array of refs where an assignability
 * check is required for every element copied to the destination array.
 */
void
CVMcopyRefArrays(CVMExecEnv* ee,
		 CVMArrayOfRef* srcArr, jint src_pos,
		 CVMArrayOfRef* dstArr, jint dst_pos,
		 CVMClassBlock* dstElemCb, jint length)
{
    CVMJavaInt i, j;
    if ((dstArr != srcArr) || (dst_pos < src_pos)) {
	for (i = src_pos, j = dst_pos; i < src_pos + length;
	     i++, j++) {
	    CVMObject* elem;
	    CVMD_arrayReadRef(srcArr, i, elem);
	    if (elem != NULL) {
		CVMClassBlock* rhsType = CVMobjectGetClass(elem);
		if ((rhsType != dstElemCb) &&
		    !CVMisAssignable(ee, rhsType, dstElemCb)) {
			if (!CVMlocalExceptionOccurred(ee)) {
			    CVMthrowArrayStoreException(ee, NULL);
			}
			return;
		    }
	    }
	    CVMD_arrayWriteRef(dstArr, j, elem);
	}
    } else {
	for (i = src_pos + length - 1, j = dst_pos + length - 1; 
	     i >= src_pos;
	     i--, j--) {
	    CVMObject* elem;
	    CVMD_arrayReadRef(srcArr, i, elem);
	    if (elem != NULL) {
		CVMClassBlock* rhsType = CVMobjectGetClass(elem);
		if ((rhsType != dstElemCb) &&
		    !CVMisAssignable(ee, rhsType, dstElemCb)) {
			if (!CVMlocalExceptionOccurred(ee)) {
			   CVMthrowArrayStoreException(ee, NULL);
			}
			return;
		    }
	    }
	    CVMD_arrayWriteRef(dstArr, j, elem);
	}
    }
}

JNIEXPORT void JNICALL
JVM_ArrayCopy(JNIEnv *env, jclass ignored,
	      jobject src, jint src_pos, 
	      jobject dst, jint dst_pos, jint length)
{
    CVMExecEnv *ee = CVMjniEnv2ExecEnv(env);
    CVMClassBlock *srcCb, *dstCb;
    CVMClassBlock *srcElemCb, *dstElemCb;
    CVMArrayOfAnyType *srcArr;
    CVMArrayOfAnyType *dstArr;
    size_t srclen;
    size_t dstlen;

    if ((src == 0) || (dst == 0)) {
	CVMthrowNullPointerException(ee, NULL);
	return;
    }
    CVMD_gcUnsafeExec(ee, {

	srcArr = (CVMArrayOfAnyType *)CVMID_icellDirect(ee, src);
	dstArr = (CVMArrayOfAnyType *)CVMID_icellDirect(ee, dst);

	srcCb = CVMobjectGetClass(srcArr);
	dstCb = CVMobjectGetClass(dstArr);

	/*
	 * First check whether we are dealing with source and destination
	 * arrays here. If not, bail out quickly.
	 */
	if (!CVMisArrayClass(srcCb) || !CVMisArrayClass(dstCb)) {
	    CVMthrowArrayStoreException(ee, NULL);
	    goto bail;
	}

	srcElemCb = CVMarrayElementCb(srcCb);
	dstElemCb = CVMarrayElementCb(dstCb);

	srclen = CVMD_arrayGetLength(srcArr);
	dstlen = CVMD_arrayGetLength(dstArr);

	/*
	 * If we are trying to copy between
	 * arrays that don't have the same type of primitive elements,
	 * bail out quickly.
	 *
	 * The more refined assignability checks for reference arrays
	 * will be performed in the CVM_T_CLASS case below.
	 */
	/*
	 * We could make this check slightly faster by comparing
	 * type-codes of the elements of the array, if we had a
	 * quick way of getting to that.
	 */
	if ((srcElemCb != dstElemCb) && (CVMcbIs(srcElemCb, PRIMITIVE) ||
					 CVMcbIs(dstElemCb, PRIMITIVE))) {
	    CVMthrowArrayStoreException(ee, NULL);
	    goto bail;
	} else if ((length < 0) || (src_pos < 0) || (dst_pos < 0) ||
		   (length + src_pos > srclen) ||
		   (length + dst_pos > dstlen)) {
	    CVMthrowArrayIndexOutOfBoundsException(ee, NULL);
	    goto bail;
	}
	
	switch(CVMarrayElemTypeCode(srcCb)) {
	case CVM_T_BOOLEAN: 
	    CVMD_arrayCopyBoolean((CVMArrayOfBoolean*)srcArr, src_pos,
				  (CVMArrayOfBoolean*)dstArr, dst_pos,
				  length);
	    break;
	case CVM_T_BYTE: 
	    CVMD_arrayCopyByte((CVMArrayOfByte*)srcArr, src_pos,
			       (CVMArrayOfByte*)dstArr, dst_pos,
			       length);
	    break;
	    
	case CVM_T_SHORT:
	    CVMD_arrayCopyShort((CVMArrayOfShort*)srcArr, src_pos,
				(CVMArrayOfShort*)dstArr, dst_pos,
				length);
	    break;
	case CVM_T_CHAR:
	    CVMD_arrayCopyChar((CVMArrayOfChar*)srcArr, src_pos,
			       (CVMArrayOfChar*)dstArr, dst_pos,
			       length);
	    break;
	case CVM_T_INT:
	    CVMD_arrayCopyInt((CVMArrayOfInt*)srcArr, src_pos,
			      (CVMArrayOfInt*)dstArr, dst_pos,
			      length);
	    break;
	case CVM_T_LONG:
	    CVMD_arrayCopyLong((CVMArrayOfLong*)srcArr, src_pos,
			       (CVMArrayOfLong*)dstArr, dst_pos,
			       length);
	    break;
	case CVM_T_FLOAT: 
	    CVMD_arrayCopyFloat((CVMArrayOfFloat*)srcArr, src_pos,
				(CVMArrayOfFloat*)dstArr, dst_pos,
				length);
	    break;
	case CVM_T_DOUBLE: 
	    CVMD_arrayCopyDouble((CVMArrayOfDouble*)srcArr, src_pos,
				 (CVMArrayOfDouble*)dstArr, dst_pos,
				 length);
	    break;
	case CVM_T_CLASS: {
	    /*
	     * Do a quick check here for the easy case of the same
	     * array type, or copying into an array of objects. No
	     * need for element-wise checks in that case.  
	     */
	    if ((srcElemCb == dstElemCb) ||
		(dstElemCb == CVMsystemClass(java_lang_Object))) {
		CVMD_arrayCopyRef((CVMArrayOfRef*)srcArr, src_pos,
				  (CVMArrayOfRef*)dstArr, dst_pos,
				  length);
	    } else {
		/* Do it the hard way. */
		CVMcopyRefArrays(ee, 
				 (CVMArrayOfRef*)srcArr, src_pos, 
				 (CVMArrayOfRef*)dstArr, dst_pos, 
				 dstElemCb, length);
	    }
	    break;
	case CVM_T_VOID: 
	    CVMassert(CVM_FALSE);
	}
	}
    bail:;
    });
}

/* For compatibility only; no longer called by java.lang.Runtime */

#ifdef JDK12
JNIEXPORT void JNICALL
JVM_Exit(jint code)
{
    if (code == 0) {
        RunFinalizersOnExit();
    }
    Exit((int)code);
}
#endif

JNIEXPORT void JNICALL
JVM_Halt(jint code)		/* Called from java.lang.Shutdown */
{
#ifdef CVM_LVM /* %begin lvm */
    CVMExecEnv* ee = CVMgetEE();
    if (CVMLVMinMainLVM(ee)) {
	CVMexit(code);
    } else {
	CVMLVMcontextHalt(ee);
    }
#else /* %end lvm */
    CVMexit(code);
#endif /* %begin,end lvm */
}

JNIEXPORT void JNICALL
JVM_OnExit(void (*func)(void))
{
    CVMatExit(func);
}

JNIEXPORT void JNICALL
JVM_GC(void)
{
    CVMgcRunGC(CVMgetEE());
}

JNIEXPORT jlong JNICALL
JVM_MaxObjectInspectionAge()
{