ccmintrinsics.c

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

            CVMthrowArrayIndexOutOfBoundsException(ee, NULL);
        }
        CVMCCMhandleException(ccee);
    }
}
#endif

#ifndef CVMCCM_DISABLE_SHARED_STRING_INDEXOF_II_INTRINSIC
/* Purpose: Intrinsic version of String.indexOf(int ch, int fromIndex). */
static CVMJavaInt
CVMCCMintrinsic_java_lang_String_indexOf_II(CVMObject* thisObj,
					    CVMJavaInt ch,
					    CVMJavaInt fromIndex)
{
    CVMObject *valueObj;
    CVMArrayOfChar *valueArr;
    CVMJavaInt offset;
    CVMJavaInt count;
    CVMJavaInt max;
    CVMJavaInt i;
    CVMJavaChar c;

    FIELD_READ_COUNT(thisObj, count);
 
    if (fromIndex >= count) {
        return -1;
    }

    if (fromIndex < 0) {
	fromIndex = 0;
    }
   
    FIELD_READ_OFFSET(thisObj, offset);
    FIELD_READ_VALUE(thisObj, valueObj);
    valueArr = (CVMArrayOfChar *)valueObj;

    max = offset + count;
    i = offset + fromIndex;
    while (i < max) {
	CVMD_arrayReadChar(valueArr, i, c);
	if (c == ch) {
	    return i - offset;
	}
	i++;
    }
    /* Not found. Return -1. */
    return -1;
}
#endif

#ifndef CVMCCM_DISABLE_SHARED_STRING_INDEXOF_I_INTRINSIC
/* Purpose: Intrinsic version of String.indexOf(int ch). */
static CVMJavaInt
CVMCCMintrinsic_java_lang_String_indexOf_I(CVMObject* thisObj,
					   CVMJavaInt ch)
{
    return CVMCCMintrinsic_java_lang_String_indexOf_II(thisObj, ch, 0);
}
#endif

#ifndef CVMCCM_DISABLE_SHARED_STRING_INDEXOF_STRING_I_INTRINSIC
/* Purpose: Intrinsic version of String.indexOf(String str, int fromIndex). */
static CVMJavaInt
CVMCCMintrinsic_java_lang_String_indexOf_STRING_I(CVMCCExecEnv *ccee,
						  CVMObject* thisObj,
						  CVMObject *strObj,
						  CVMJavaInt fromIndex)
{
   CVMObject *vObj1;
   CVMObject *vObj2;
   CVMArrayOfChar *v1;
   CVMArrayOfChar *v2;
   CVMJavaInt offset;
   CVMJavaInt strOffset;
   CVMJavaInt count;
   CVMJavaInt strCount;
   CVMJavaInt max;
   CVMJavaChar first;
   CVMJavaChar c1;
   CVMJavaChar c2;
   CVMJavaInt i; /* Iterates v1 searching for the first char of v2 */
   CVMJavaInt j; /* Iterates v1 searching for the rest of v2 */
   CVMJavaInt k; /* Iterates v2 */
   CVMJavaInt end;
   CVMassert(CVMD_isgcUnsafe(CVMcceeGetEE(ccee)));

    /* If strObj is null, a NullPointerException should be thrown. */
    if (strObj == NULL) {
        CVMExecEnv *ee = CVMcceeGetEE(ccee);
        CVMCCMruntimeLazyFixups(ee);
	CVMthrowNullPointerException(ee, NULL);
        CVMCCMhandleException(ccee);
	return -1;
    }

   /* The caller is responsible for NULL checking for strICell. */
   FIELD_READ_COUNT(thisObj, count);
   FIELD_READ_COUNT(strObj, strCount);

   if (fromIndex >= count) {
       if (strCount == 0) {
           /* 
            * Special case: return the length of the first string
            * when searching for an empty String, 4276204 & 6205369
            */
           return count;
       }
       return -1;
   }
   if (fromIndex < 0) {
       fromIndex = 0;
   }
   if (strCount == 0) {
       return fromIndex;
   }

   FIELD_READ_VALUE(thisObj, vObj1);
   FIELD_READ_VALUE(strObj, vObj2);
   FIELD_READ_OFFSET(thisObj, offset);
   FIELD_READ_OFFSET(strObj, strOffset);
   v1 = (CVMArrayOfChar *)vObj1;
   v2 = (CVMArrayOfChar *)vObj2;

   CVMD_arrayReadChar(v2, strOffset, first);
   max = offset + (count - strCount);
   i = offset + fromIndex;

   while (i <= max) {
       /* Search for first character. */
       CVMD_arrayReadChar(v1, i, c1);
       if (c1 == first) {
	   /* Found first character, now look at the rest of v2 */
	   j = i + 1;
	   end = i + strCount;
	   k = strOffset + 1;
	   while(j < end) {
	       CVMD_arrayReadChar(v1, j, c1);
	       CVMD_arrayReadChar(v2, k, c2);
	       if (c1 != c2) {
		   goto continueSearch;
	       }
	       j++;
	       k++;
	   }
	   /* Found */
	   return i - offset;
       }
   continueSearch:
       i++;
   }
   /* If we are here, then we have failed to find v2 in v1.*/
   return -1;
}
#endif

#ifndef CVMCCM_DISABLE_SHARED_STRING_INDEXOF_STRING_INTRINSIC
/* Purpose: Intrinsic version of String.indexOf(String str). */
static CVMJavaInt
CVMCCMintrinsic_java_lang_String_indexOf_STRING(CVMCCExecEnv *ccee,
						CVMObject* thisObj,
						CVMObject *strObj)
{
    return CVMCCMintrinsic_java_lang_String_indexOf_STRING_I(ccee, thisObj,
							     strObj, 0);
}
#endif

#undef MIN
#undef FIELD_READ_COUNT
#undef FIELD_READ_VALUE
#undef FIELD_READ_OFFSET

#ifdef CVM_DEBUG_ASSERTS
#define CVMassertOKToCopyArrayOfType(expectedType_) \
    {                                                                   \
        CVMClassBlock *srcCb, *dstCb;                                   \
        CVMClassBlock *srcElemCb, *dstElemCb;                           \
        size_t srclen, dstlen;                                          \
        CVMArrayOfAnyType *srcArr;                                      \
        CVMArrayOfAnyType *dstArr;                                      \
                                                                        \
        srcArr = (CVMArrayOfAnyType *)src;                              \
        dstArr = (CVMArrayOfAnyType *)dst;                              \
        CVMassert(srcArr != NULL);                                      \
        CVMassert(dstArr != NULL);                                      \
                                                                        \
        srcCb = CVMobjectGetClass(srcArr);                              \
        dstCb = CVMobjectGetClass(dstArr);                              \
        CVMassert(CVMisArrayClass(srcCb));                              \
        CVMassert(CVMisArrayClass(dstCb));                              \
                                                                        \
        srcElemCb = CVMarrayElementCb(srcCb);                           \
        dstElemCb = CVMarrayElementCb(dstCb);                           \
        CVMassert(srcElemCb == dstElemCb);                              \
        CVMassert(CVMarrayElemTypeCode(srcCb) == expectedType_);        \
                                                                        \
        srclen = CVMD_arrayGetLength(srcArr);                           \
        dstlen = CVMD_arrayGetLength(dstArr);                           \
                                                                        \
        CVMassert(!(length < 0));                                       \
        CVMassert(!(src_pos < 0));                                      \
        CVMassert(!(dst_pos < 0));                                      \
        CVMassert(!(length + src_pos > srclen));                        \
        CVMassert(!(length + dst_pos > dstlen));                        \
    }
#else
#define CVMassertOKToCopyArrayOfType(expectedType_)
#endif /* CVM_DEBUG_ASSERTS */

#ifndef CVMCCM_DISABLE_SHARED_CVM_COPYBOOLEANARRAY_INTRINSIC
/* Purpose: Intrinsic version of CVM.copyBooleanArray(). */
void
CVMCCMintrinsic_sun_misc_CVM_copyBooleanArray(CVMArrayOfBoolean *src,
    jint src_pos, CVMArrayOfBoolean *dst, jint dst_pos, jint length)
{
    CVMassertOKToCopyArrayOfType(CVM_T_BOOLEAN);
    CVMD_arrayCopyBoolean(src, src_pos, dst, dst_pos, length);
}
#endif

#ifndef CVMCCM_DISABLE_SHARED_CVM_COPYBYTEARRAY_INTRINSIC
/* Purpose: Intrinsic version of CVM.copyByteArray(). */
void
CVMCCMintrinsic_sun_misc_CVM_copyByteArray(CVMArrayOfByte *src,
    jint src_pos, CVMArrayOfByte *dst, jint dst_pos, jint length)
{
    CVMassertOKToCopyArrayOfType(CVM_T_BYTE);
    CVMD_arrayCopyByte(src, src_pos, dst, dst_pos, length);
}
#endif

#ifndef CVMCCM_DISABLE_SHARED_CVM_COPYSHORTARRAY_INTRINSIC
/* Purpose: Intrinsic version of CVM.copyShortArray(). */
void
CVMCCMintrinsic_sun_misc_CVM_copyShortArray(CVMArrayOfShort *src,
    jint src_pos, CVMArrayOfShort *dst, jint dst_pos, jint length)
{
    CVMassertOKToCopyArrayOfType(CVM_T_SHORT);
    CVMD_arrayCopyShort(src, src_pos, dst, dst_pos, length);
}
#endif

#ifndef CVMCCM_DISABLE_SHARED_CVM_COPYCHARARRAY_INTRINSIC
/* Purpose: Intrinsic version of CVM.copyCharArray(). */
void
CVMCCMintrinsic_sun_misc_CVM_copyCharArray(CVMArrayOfChar *src,
    jint src_pos, CVMArrayOfChar *dst, jint dst_pos, jint length)
{
    CVMassertOKToCopyArrayOfType(CVM_T_CHAR);
    CVMD_arrayCopyChar(src, src_pos, dst, dst_pos, length);
}
#endif

#ifndef CVMCCM_DISABLE_SHARED_CVM_COPYINTARRAY_INTRINSIC
/* Purpose: Intrinsic version of CVM.copyIntArray(). */
void
CVMCCMintrinsic_sun_misc_CVM_copyIntArray(CVMArrayOfInt *src,
    jint src_pos, CVMArrayOfInt *dst, jint dst_pos, jint length)
{
    CVMassertOKToCopyArrayOfType(CVM_T_INT);
    CVMD_arrayCopyInt(src, src_pos, dst, dst_pos, length);
}
#endif

#ifndef CVMCCM_DISABLE_SHARED_CVM_COPYLONGARRAY_INTRINSIC
/* Purpose: Intrinsic version of CVM.copyLongArray(). */
void
CVMCCMintrinsic_sun_misc_CVM_copyLongArray(CVMArrayOfLong *src,
    jint src_pos, CVMArrayOfLong *dst, jint dst_pos, jint length)
{
    CVMassertOKToCopyArrayOfType(CVM_T_LONG);
    CVMD_arrayCopyLong(src, src_pos, dst, dst_pos, length);
}
#endif

#ifndef CVMCCM_DISABLE_SHARED_CVM_COPYFLOATARRAY_INTRINSIC
/* Purpose: Intrinsic version of CVM.copyFloatArray(). */
void
CVMCCMintrinsic_sun_misc_CVM_copyFloatArray(CVMArrayOfFloat *src,
    jint src_pos, CVMArrayOfFloat *dst, jint dst_pos, jint length)
{
    CVMassertOKToCopyArrayOfType(CVM_T_FLOAT);
    CVMD_arrayCopyFloat(src, src_pos, dst, dst_pos, length);
}
#endif

#ifndef CVMCCM_DISABLE_SHARED_CVM_COPYDOUBLEARRAY_INTRINSIC
/* Purpose: Intrinsic version of CVM.copyDoubleArray(). */
void
CVMCCMintrinsic_sun_misc_CVM_copyDoubleArray(CVMArrayOfDouble *src,
    jint src_pos, CVMArrayOfDouble *dst, jint dst_pos, jint length)
{
    CVMassertOKToCopyArrayOfType(CVM_T_DOUBLE);
    CVMD_arrayCopyDouble(src, src_pos, dst, dst_pos, length);
}
#endif

#ifndef CVMCCM_DISABLE_SHARED_CVM_COPYOBJECTARRAY_INTRINSIC
/* Purpose: Intrinsic version of CVM.copyObjectArray(). */
void
CVMCCMintrinsic_sun_misc_CVM_copyObjectArray(CVMArrayOfRef *src,
    jint src_pos, CVMArrayOfRef *dst, jint dst_pos, jint length)
{
    CVMassertOKToCopyArrayOfType(CVM_T_CLASS);
    if (length != 0)
	CVMD_arrayCopyRef(src, src_pos, dst, dst_pos, length);
}
#endif

#ifndef CVMCCM_DISABLE_SHARED_SYSTEM_ARRAYCOPY_INTRINSIC
/* Purpose: Intrinsic version of System.arraycopy(). */
void
CVMCCMintrinsic_java_lang_System_arraycopy(CVMCCExecEnv *ccee,
    CVMArrayOfAnyType *srcArr, jint src_pos,
    CVMArrayOfAnyType *dstArr, jint dst_pos, jint length)
{
    CVMExecEnv *ee = CVMcceeGetEE(ccee);
    CVMClassBlock *srcCb, *dstCb;
    CVMClassBlock *srcElemCb, *dstElemCb;
    size_t srclen;
    size_t dstlen;

    CVMassert(CVMD_isgcUnsafe(ee));

    if ((srcArr == 0) || (dstArr == 0)) {
        CVMCCMruntimeLazyFixups(ee);
        CVMthrowNullPointerException(ee, NULL);
        goto bail;
    }
    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)) {
        CVMCCMruntimeLazyFixups(ee);
        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))) {
        CVMCCMruntimeLazyFixups(ee);
        CVMthrowArrayStoreException(ee, NULL);
        goto bail;
    } else if ((length < 0) || (src_pos < 0) || (dst_pos < 0) ||
               (length + src_pos > srclen) ||
               (length + dst_pos > dstlen)) {
        CVMCCMruntimeLazyFixups(ee);
        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,