main/native/ConverterInterface.c

/**
*******************************************************************************
* Copyright (C) 1996-2006, International Business Machines Corporation and    *
* others. All Rights Reserved.                                                *
*******************************************************************************
*
*
*******************************************************************************
*/
/*
 *  @(#) icujniinterface.c	1.2 00/10/11
 *
 * (C) Copyright IBM Corp. 2000 - All Rights Reserved
 *  A JNI wrapper to ICU native converter Interface
 * @author: Ram Viswanadha
 */

#include "ConverterInterface.h"
#include "JNIHelp.h"
#include "AndroidSystemNatives.h"
#include "unicode/utypes.h"   /* Basic ICU data types */
#include "unicode/ucnv.h"     /* C   Converter API    */
#include "unicode/ustring.h"  /* some more string functions*/
#include "unicode/ucnv_cb.h"  /* for callback functions */
#include "unicode/uset.h"     /* for contains function */
#include "ErrorCode.h"
#include <stdlib.h>
#include <string.h>

// BEGIN android-removed
// #define UTF_16BE "UTF-16BE"
// #define UTF_16 "UTF-16"
// END android-removed

/* Prototype of callback for substituting user settable sub chars */
void  JNI_TO_U_CALLBACK_SUBSTITUTE
 (const void *,UConverterToUnicodeArgs *,const char* ,int32_t ,UConverterCallbackReason ,UErrorCode * );

/**
 * Opens the ICU converter
 * @param env environment handle for JNI
 * @param jClass handle for the class
 * @param handle buffer to recieve ICU's converter address
 * @param converterName name of the ICU converter
 */
static jlong openConverter (JNIEnv *env, jclass jClass, jstring converterName) {

    UConverter* conv=NULL;
    UErrorCode errorCode = U_ZERO_ERROR;

    const char* cnvName= (const char*) (*env)->GetStringUTFChars(env, converterName,NULL);
    if(cnvName) {
        int count = (*env)->GetStringUTFLength(env,converterName);

        conv = ucnv_open(cnvName,&errorCode);
    }
    (*env)->ReleaseStringUTFChars(env, converterName,cnvName);

    if (icu4jni_error(env, errorCode) != FALSE) {
        return 0;
    }

    return (jlong) conv;
}

/**
 * Closes the ICU converter
 * @param env environment handle for JNI
 * @param jClass handle for the class
 * @param handle address of ICU converter
 */
static void closeConverter (JNIEnv *env, jclass jClass, jlong handle) {

    UConverter* cnv = (UConverter*)(long)handle;
    if(cnv) {
        // BEGIN android-added
        // Free up any contexts created in setCallback[Encode|Decode]()
        UConverterToUCallback toAction;
        UConverterFromUCallback fromAction;
        void * context1 = NULL;
        void * context2 = NULL;
        ucnv_getToUCallBack(cnv, &toAction, &context1);
        ucnv_getFromUCallBack(cnv, &fromAction, &context2);
        // END android-added
        ucnv_close(cnv);
        // BEGIN android-added
        if (context1 != NULL) {
            free(context1);
        }
        if (context2 != NULL) {
            free(context2);
        }
        // END android-added
    }
}

/**
 * Sets the substution mode for from Unicode conversion. Currently only
 * two modes are supported: substitute or report
 * @param env environment handle for JNI
 * @param jClass handle for the class
 * @param handle address of ICU converter
 * @param mode the mode to set
 */
static jint setSubstitutionModeCharToByte (JNIEnv *env, jclass jClass, jlong handle, jboolean mode) {

    UConverter* conv = (UConverter*)(long)handle;
    UErrorCode errorCode =U_ZERO_ERROR;

    if(conv) {

        UConverterFromUCallback fromUOldAction ;
        void* fromUOldContext;
        void* fromUNewContext=NULL;
        if(mode) {

            ucnv_setFromUCallBack(conv,
               UCNV_FROM_U_CALLBACK_SUBSTITUTE,
               fromUNewContext,
               &fromUOldAction,
               (const void**)&fromUOldContext,
               &errorCode);

        }
        else{

            ucnv_setFromUCallBack(conv,
               UCNV_FROM_U_CALLBACK_STOP,
               fromUNewContext,
               &fromUOldAction,
               (const void**)&fromUOldContext,
               &errorCode);

        }
        return errorCode;
    }
    errorCode = U_ILLEGAL_ARGUMENT_ERROR;
    return errorCode;
}
/**
 * Sets the substution mode for to Unicode conversion. Currently only
 * two modes are supported: substitute or report
 * @param env environment handle for JNI
 * @param jClass handle for the class
 * @param handle address of ICU converter
 * @param mode the mode to set
 */
static jint setSubstitutionModeByteToChar (JNIEnv *env, jclass jClass, jlong handle, jboolean mode) {

    UConverter* conv = (UConverter*)handle;
    UErrorCode errorCode =U_ZERO_ERROR;

    if(conv) {

        UConverterToUCallback toUOldAction ;
        void* toUOldContext;
        void* toUNewContext=NULL;
        if(mode) {

            ucnv_setToUCallBack(conv,
               UCNV_TO_U_CALLBACK_SUBSTITUTE,
               toUNewContext,
               &toUOldAction,
               (const void**)&toUOldContext,
               &errorCode);

        }
        else{

            ucnv_setToUCallBack(conv,
               UCNV_TO_U_CALLBACK_STOP,
               toUNewContext,
               &toUOldAction,
               (const void**)&toUOldContext,
               &errorCode);

        }
        return errorCode;
    }
    errorCode = U_ILLEGAL_ARGUMENT_ERROR;
    return errorCode;
}
/**
 * Converts a buffer of Unicode code units to target encoding
 * @param env environment handle for JNI
 * @param jClass handle for the class
 * @param handle address of ICU converter
 * @param source buffer of Unicode chars to convert
 * @param sourceEnd limit of the source buffer
 * @param target buffer to recieve the converted bytes
 * @param targetEnd the limit of the target buffer
 * @param data buffer to recieve state of the current conversion
 * @param flush boolean that specifies end of source input
 */
static jint convertCharToByte(JNIEnv *env, jclass jClass, jlong handle,  jcharArray source,  jint sourceEnd, jbyteArray target, jint targetEnd, jintArray data, jboolean flush) {


    UErrorCode errorCode =U_ZERO_ERROR;
    UConverter* cnv = (UConverter*)handle;
    if(cnv) {
        jint* myData = (jint*) (*env)->GetPrimitiveArrayCritical(env,data,NULL);
        if(myData) {
            jint* sourceOffset = &myData[0];
            jint* targetOffset = &myData[1];
            const jchar* uSource =(jchar*) (*env)->GetPrimitiveArrayCritical(env,source, NULL);
            if(uSource) {
                jbyte* uTarget=(jbyte*) (*env)->GetPrimitiveArrayCritical(env,target,NULL);
                if(uTarget) {
                    const jchar* mySource = uSource+ *sourceOffset;
                    const UChar* mySourceLimit= uSource+sourceEnd;
                    char* cTarget=uTarget+ *targetOffset;
                    const char* cTargetLimit=uTarget+targetEnd;

                    ucnv_fromUnicode( cnv , &cTarget, cTargetLimit,&mySource,
                                    mySourceLimit,NULL,(UBool) flush, &errorCode);

                    *sourceOffset = (jint) (mySource - uSource)-*sourceOffset;
                    *targetOffset = (jint) ((jbyte*)cTarget - uTarget)- *targetOffset;
                    if(U_FAILURE(errorCode)) {
                        (*env)->ReleasePrimitiveArrayCritical(env,target,uTarget,0);
                        (*env)->ReleasePrimitiveArrayCritical(env,source,(jchar*)uSource,0);
                        (*env)->ReleasePrimitiveArrayCritical(env,data,(jint*)myData,0);
                        return errorCode;
                    }
                }else{
                    errorCode = U_ILLEGAL_ARGUMENT_ERROR;
                }
                (*env)->ReleasePrimitiveArrayCritical(env,target,uTarget,0);
            }else{
                    errorCode = U_ILLEGAL_ARGUMENT_ERROR;
            }
            (*env)->ReleasePrimitiveArrayCritical(env,source,(jchar*)uSource,0);
        }else{
                    errorCode = U_ILLEGAL_ARGUMENT_ERROR;
        }
        (*env)->ReleasePrimitiveArrayCritical(env,data,(jint*)myData,0);
        return errorCode;
    }
    errorCode = U_ILLEGAL_ARGUMENT_ERROR;
    return errorCode;
}

static jint encode(JNIEnv *env, jclass jClass, jlong handle, jcharArray source, jint sourceEnd, jbyteArray target, jint targetEnd, jintArray data, jboolean flush) {

    UErrorCode ec = convertCharToByte(env,jClass,handle,source,sourceEnd, target,targetEnd,data,flush);
    UConverter* cnv = (UConverter*)handle;
    jint* myData = (jint*) (*env)->GetPrimitiveArrayCritical(env,data,NULL);

    if(cnv && myData) {

       UErrorCode errorCode = U_ZERO_ERROR;
       myData[3] = ucnv_fromUCountPending(cnv, &errorCode);

       if(ec == U_ILLEGAL_CHAR_FOUND || ec == U_INVALID_CHAR_FOUND) {
            int8_t count =32;
            UChar invalidUChars[32];
            ucnv_getInvalidUChars(cnv,invalidUChars,&count,&errorCode);

            if(U_SUCCESS(errorCode)) {
                myData[2] = count;
            }
        }
    }
    (*env)->ReleasePrimitiveArrayCritical(env,data,(jint*)myData,0);
    return ec;
}

/**
 * Converts a buffer of encoded bytes to Unicode code units
 * @param env environment handle for JNI
 * @param jClass handle for the class
 * @param handle address of ICU converter
 * @param source buffer of Unicode chars to convert
 * @param sourceEnd limit of the source buffer
 * @param target buffer to recieve the converted bytes
 * @param targetEnd the limit of the target buffer
 * @param data buffer to recieve state of the current conversion
 * @param flush boolean that specifies end of source input
 */
static jint convertByteToChar(JNIEnv *env, jclass jClass, jlong handle, jbyteArray source, jint sourceEnd, jcharArray target, jint targetEnd, jintArray data, jboolean flush) {

    UErrorCode errorCode =U_ZERO_ERROR;
    UConverter* cnv = (UConverter*)handle;
    if(cnv) {
        jint* myData = (jint*) (*env)->GetPrimitiveArrayCritical(env,data,NULL);
        if(myData) {
            jint* sourceOffset = &myData[0];
            jint* targetOffset = &myData[1];

            const jbyte* uSource =(jbyte*) (*env)->GetPrimitiveArrayCritical(env,source, NULL);
            if(uSource) {
                jchar* uTarget=(jchar*) (*env)->GetPrimitiveArrayCritical(env,target,NULL);
                if(uTarget) {
                    const jbyte* mySource = uSource+ *sourceOffset;
                    const char* mySourceLimit= uSource+sourceEnd;
                    UChar* cTarget=uTarget+ *targetOffset;
                    const UChar* cTargetLimit=uTarget+targetEnd;

                    ucnv_toUnicode( cnv , &cTarget, cTargetLimit,(const char**)&mySource,
                                   mySourceLimit,NULL,(UBool) flush, &errorCode);

                    *sourceOffset = mySource - uSource - *sourceOffset  ;
                    *targetOffset = cTarget - uTarget - *targetOffset;
                    if(U_FAILURE(errorCode)) {
                        (*env)->ReleasePrimitiveArrayCritical(env,target,uTarget,0);
                        (*env)->ReleasePrimitiveArrayCritical(env,source,(jchar*)uSource,0);
                        (*env)->ReleasePrimitiveArrayCritical(env,data,(jint*)myData,0);
                        return errorCode;
                    }
                }else{
                    errorCode = U_ILLEGAL_ARGUMENT_ERROR;
                }
                (*env)->ReleasePrimitiveArrayCritical(env,target,uTarget,0);
            }else{
                errorCode = U_ILLEGAL_ARGUMENT_ERROR;
            }
            (*env)->ReleasePrimitiveArrayCritical(env,source,(jchar*)uSource,0);
        }else{
            errorCode = U_ILLEGAL_ARGUMENT_ERROR;
        }
        (*env)->ReleasePrimitiveArrayCritical(env,data,(jint*)myData,0);
        return errorCode;
    }
    errorCode = U_ILLEGAL_ARGUMENT_ERROR;
    return errorCode;
}

static jint decode(JNIEnv *env, jclass jClass, jlong handle, jbyteArray source, jint sourceEnd, jcharArray target, jint targetEnd, jintArray data, jboolean flush) {

    jint ec = convertByteToChar(env, jClass,handle,source,sourceEnd, target,targetEnd,data,flush);

    jint* myData = (jint*) (*env)->GetPrimitiveArrayCritical(env,data,NULL);
    UConverter* cnv = (UConverter*)handle;

    if(myData && cnv) {
        UErrorCode errorCode = U_ZERO_ERROR;
        myData[3] = ucnv_toUCountPending(cnv, &errorCode);

        if(ec == U_ILLEGAL_CHAR_FOUND || ec == U_INVALID_CHAR_FOUND ) {
            char invalidChars[32] = {'\0'};
            int8_t len = 32;
            ucnv_getInvalidChars(cnv,invalidChars,&len,&errorCode);

            if(U_SUCCESS(errorCode)) {
                myData[2] = len;
            }
        }
    }
    (*env)->ReleasePrimitiveArrayCritical(env,data,(jint*)myData,0);
    return ec;
}
static void resetByteToChar(JNIEnv *env, jclass jClass, jlong handle) {

    UConverter* cnv = (UConverter*)handle;
    if(cnv) {
        ucnv_resetToUnicode(cnv);
    }
}

static void resetCharToByte(JNIEnv *env, jclass jClass, jlong handle) {

    UConverter* cnv = (UConverter*)handle;
    if(cnv) {
        ucnv_resetFromUnicode(cnv);
    }

}

static jint countInvalidBytes (JNIEnv *env, jclass jClass, jlong handle, jintArray length) {

    UConverter* cnv = (UConverter*)handle;
    UErrorCode errorCode = U_ZERO_ERROR;
    if(cnv) {
        char invalidChars[32];

        jint* len = (jint*) (*env)->GetPrimitiveArrayCritical(env,length, NULL);
        if(len) {
            ucnv_getInvalidChars(cnv,invalidChars,(int8_t*)len,&errorCode);
        }
        (*env)->ReleasePrimitiveArrayCritical(env,length,(jint*)len,0);
        return errorCode;
    }
    errorCode = U_ILLEGAL_ARGUMENT_ERROR;
    return errorCode;

}


static jint countInvalidChars(JNIEnv *env, jclass jClass, jlong handle, jintArray length) {

    UErrorCode errorCode =U_ZERO_ERROR;
    UConverter* cnv = (UConverter*)handle;
    UChar invalidUChars[32];
    if(cnv) {
        jint* len = (jint*) (*env)->GetPrimitiveArrayCritical(env,length, NULL);
        if(len) {
            ucnv_getInvalidUChars(cnv,invalidUChars,(int8_t*)len,&errorCode);
        }
        (*env)->ReleasePrimitiveArrayCritical(env,length,(jint*)len,0);
        return errorCode;
    }
    errorCode = U_ILLEGAL_ARGUMENT_ERROR;
    return errorCode;

}

static jint getMaxBytesPerChar(JNIEnv *env, jclass jClass, jlong handle) {

    UConverter* cnv = (UConverter*)handle;
    if(cnv) {
        return (jint)ucnv_getMaxCharSize(cnv);
    }
    return -1;
}

static jint getMinBytesPerChar(JNIEnv *env, jclass jClass, jlong handle) {

    UConverter* cnv = (UConverter*)handle;
    if(cnv) {
        return (jint)ucnv_getMinCharSize(cnv);
    }
    return -1;
}
static jfloat getAveBytesPerChar(JNIEnv *env, jclass jClass, jlong handle) {

    UConverter* cnv = (UConverter*)handle;
    if(cnv) {
         jfloat max = (jfloat)ucnv_getMaxCharSize(cnv);
         jfloat min = (jfloat)ucnv_getMinCharSize(cnv);
         return (jfloat) ( (max+min)/2 );
    }
    return -1;
}
static jint flushByteToChar(JNIEnv *env, jclass jClass,jlong handle, jcharArray target, jint targetEnd, jintArray data) {

    UErrorCode errorCode =U_ZERO_ERROR;
    UConverter* cnv = (UConverter*)handle;
    if(cnv) {
        jbyte source ='\0';
        jint* myData = (jint*) (*env)->GetPrimitiveArrayCritical(env,data,NULL);
        if(myData) {
            jint* targetOffset = &myData[1];
            jchar* uTarget=(jchar*) (*env)->GetPrimitiveArrayCritical(env,target,NULL);
            if(uTarget) {
                const jbyte* mySource =&source;
                const char* mySourceLimit=&source;
                UChar* cTarget=uTarget+ *targetOffset;
                const UChar* cTargetLimit=uTarget+targetEnd;

                ucnv_toUnicode( cnv , &cTarget, cTargetLimit,(const char**)&mySource,
                               mySourceLimit,NULL,TRUE, &errorCode);


                *targetOffset = (jint) ((jchar*)cTarget - uTarget)- *targetOffset;
                if(U_FAILURE(errorCode)) {
                    (*env)->ReleasePrimitiveArrayCritical(env,target,uTarget,0);
                    (*env)->ReleasePrimitiveArrayCritical(env,data,(jint*)myData,0);
                    return errorCode;
                }
            }else{
                errorCode = U_ILLEGAL_ARGUMENT_ERROR;
            }
            (*env)->ReleasePrimitiveArrayCritical(env,target,uTarget,0);

        }else{
            errorCode = U_ILLEGAL_ARGUMENT_ERROR;
        }
        (*env)->ReleasePrimitiveArrayCritical(env,data,(jint*)myData,0);
        return errorCode;
    }
    errorCode = U_ILLEGAL_ARGUMENT_ERROR;
    return errorCode;
}

static jint flushCharToByte (JNIEnv *env, jclass jClass, jlong handle, jbyteArray target, jint targetEnd, jintArray data) {

    UErrorCode errorCode =U_ZERO_ERROR;
    UConverter* cnv = (UConverter*)handle;
    jchar source = '\0';
    if(cnv) {
        jint* myData = (jint*) (*env)->GetPrimitiveArrayCritical(env,data,NULL);
        if(myData) {
            jint* targetOffset = &myData[1];
            jbyte* uTarget=(jbyte*) (*env)->GetPrimitiveArrayCritical(env,target,NULL);
            if(uTarget) {
                const jchar* mySource = &source;
                const UChar* mySourceLimit= &source;
                char* cTarget=uTarget+ *targetOffset;
                const char* cTargetLimit=uTarget+targetEnd;

                ucnv_fromUnicode( cnv , &cTarget, cTargetLimit,&mySource,
                                  mySourceLimit,NULL,TRUE, &errorCode);


                *targetOffset = (jint) ((jbyte*)cTarget - uTarget)- *targetOffset;
                if(U_FAILURE(errorCode)) {
                    (*env)->ReleasePrimitiveArrayCritical(env,target,uTarget,0);

                    (*env)->ReleasePrimitiveArrayCritical(env,data,(jint*)myData,0);
                    return errorCode;
                }
            }else{
                errorCode = U_ILLEGAL_ARGUMENT_ERROR;
            }
            (*env)->ReleasePrimitiveArrayCritical(env,target,uTarget,0);
        }else{
            errorCode = U_ILLEGAL_ARGUMENT_ERROR;
        }
        (*env)->ReleasePrimitiveArrayCritical(env,data,(jint*)myData,0);
        return errorCode;
    }
    errorCode = U_ILLEGAL_ARGUMENT_ERROR;
    return errorCode;
}

void toChars(const UChar* us, char* cs, int32_t length) {
    UChar u;
    while(length>0) {
        u=*us++;
        *cs++=(char)u;
        --length;
    }
}
static jint setSubstitutionBytes(JNIEnv *env, jclass jClass, jlong handle, jbyteArray subChars, jint length) {

    UConverter* cnv = (UConverter*) handle;
    UErrorCode errorCode = U_ZERO_ERROR;
    if(cnv) {
        jbyte* u_subChars = (*env)->GetPrimitiveArrayCritical(env,subChars,NULL);
        if(u_subChars) {
             char* mySubChars= (char*)malloc(sizeof(char)*length);
             toChars((UChar*)u_subChars,&mySubChars[0],length);
             ucnv_setSubstChars(cnv,mySubChars, (char)length,&errorCode);
             if(U_FAILURE(errorCode)) {
                (*env)->ReleasePrimitiveArrayCritical(env,subChars,mySubChars,0);
                return errorCode;
             }
             free(mySubChars);
        }
        else{
           errorCode =  U_ILLEGAL_ARGUMENT_ERROR;
        }
        (*env)->ReleasePrimitiveArrayCritical(env,subChars,u_subChars,0);
        return errorCode;
    }
    errorCode = U_ILLEGAL_ARGUMENT_ERROR;
    return errorCode;
}


#define VALUE_STRING_LENGTH 32

typedef struct{
    int length;
    UChar subChars[256];
    UBool stopOnIllegal;
}SubCharStruct;


static UErrorCode
setToUCallbackSubs(UConverter* cnv,UChar* subChars, int32_t length,UBool stopOnIllegal ) {
    SubCharStruct* substitutionCharS = (SubCharStruct*) malloc(sizeof(SubCharStruct));
    UErrorCode errorCode = U_ZERO_ERROR;
    if(substitutionCharS) {
       UConverterToUCallback toUOldAction;
       void* toUOldContext=NULL;
       void* toUNewContext=NULL ;
       if(subChars) {
            u_strncpy(substitutionCharS->subChars,subChars,length);
       }else{
           substitutionCharS->subChars[length++] =0xFFFD;
       }
       substitutionCharS->subChars[length]=0;
       substitutionCharS->length = length;
       substitutionCharS->stopOnIllegal = stopOnIllegal;
       toUNewContext = substitutionCharS;

       ucnv_setToUCallBack(cnv,
           JNI_TO_U_CALLBACK_SUBSTITUTE,
           toUNewContext,
           &toUOldAction,
           (const void**)&toUOldContext,
           &errorCode);

       if(toUOldContext) {
           SubCharStruct* temp = (SubCharStruct*) toUOldContext;
           free(temp);
       }

       return errorCode;
    }
    return U_MEMORY_ALLOCATION_ERROR;
}
static jint setSubstitutionChars(JNIEnv *env, jclass jClass, jlong handle, jcharArray subChars, jint length) {

    UErrorCode errorCode = U_ZERO_ERROR;
    UConverter* cnv = (UConverter*) handle;
    jchar* u_subChars=NULL;
    if(cnv) {
        if(subChars) {
            int len = (*env)->GetArrayLength(env,subChars);
            u_subChars = (*env)->GetPrimitiveArrayCritical(env,subChars,NULL);
            if(u_subChars) {
               errorCode =  setToUCallbackSubs(cnv,u_subChars,len,FALSE);
            }else{
                errorCode = U_ILLEGAL_ARGUMENT_ERROR;
            }
            (*env)->ReleasePrimitiveArrayCritical(env,subChars,u_subChars,0);
            return errorCode;
        }
    }
    return U_ILLEGAL_ARGUMENT_ERROR;
}


void  JNI_TO_U_CALLBACK_SUBSTITUTE( const void *context, UConverterToUnicodeArgs *toArgs, const char* codeUnits, int32_t length, UConverterCallbackReason reason, UErrorCode * err) {

    if(context) {
        SubCharStruct* temp = (SubCharStruct*)context;
        if( temp) {
            if(temp->stopOnIllegal==FALSE) {
                if (reason > UCNV_IRREGULAR) {
                    return;
                }
                /* reset the error */
                *err = U_ZERO_ERROR;
                ucnv_cbToUWriteUChars(toArgs,temp->subChars ,temp->length , 0, err);
            }else{
                if(reason != UCNV_UNASSIGNED) {
                    /* the caller must have set
                     * the error code accordingly
                     */
                    return;
                }else{
                    *err = U_ZERO_ERROR;
                    ucnv_cbToUWriteUChars(toArgs,temp->subChars ,temp->length , 0, err);
                    return;
                }
            }
        }
    }
    return;
}

static jboolean canEncode(JNIEnv *env, jclass jClass, jlong handle, jint codeUnit) {

    UErrorCode errorCode =U_ZERO_ERROR;
    UConverter* cnv = (UConverter*)handle;
    if(cnv) {
        UChar source[3];
        UChar *mySource=source;
        const UChar* sourceLimit = (codeUnit<0x010000) ? &source[1] : &source[2];
        char target[5];
        char *myTarget = target;
        const char* targetLimit = &target[4];
        int i=0;
        UTF_APPEND_CHAR(&source[0],i,2,codeUnit);

        ucnv_fromUnicode(cnv,&myTarget,targetLimit,
                         (const UChar**)&mySource,
                         sourceLimit,NULL, TRUE,&errorCode);

        if(U_SUCCESS(errorCode)) {
            return (jboolean)TRUE;
        }
    }
    return (jboolean)FALSE;
}


static jboolean canDecode(JNIEnv *env, jclass jClass, jlong handle, jbyteArray source) {

    UErrorCode errorCode =U_ZERO_ERROR;
    UConverter* cnv = (UConverter*)handle;
    if(cnv) {
        jint len = (*env)->GetArrayLength(env,source);
        jbyte* cSource =(jbyte*) (*env)->GetPrimitiveArrayCritical(env,source, NULL);
        if(cSource) {
            const jbyte* cSourceLimit = cSource+len;

            /* Assume that we need at most twice the length of source */
            UChar* target = (UChar*) malloc(sizeof(UChar)* (len<<1));
            UChar* targetLimit = target + (len<<1);
            if(target) {
                ucnv_toUnicode(cnv,&target,targetLimit,
                               (const char**)&cSource,
                               cSourceLimit,NULL, TRUE,&errorCode);

                if(U_SUCCESS(errorCode)) {
                    free(target);
                    (*env)->ReleasePrimitiveArrayCritical(env,source,cSource,0);
                    return (jboolean)TRUE;
                }
            }
            free(target);
        }
        (*env)->ReleasePrimitiveArrayCritical(env,source,cSource,0);
    }
    return (jboolean)FALSE;
}

static jint countAvailable(JNIEnv *env, jclass jClass) {
    return ucnv_countAvailable();
}

int32_t copyString(char* dest, int32_t destCapacity, int32_t startIndex,
           const char* src, UErrorCode* status) {
    int32_t srcLen = 0, i=0;
    if(U_FAILURE(*status)) {
        return 0;
    }
    if(dest == NULL || src == NULL || destCapacity < startIndex) {
        *status = U_ILLEGAL_ARGUMENT_ERROR;
        return 0;
    }
    srcLen = strlen(src);
    if(srcLen >= destCapacity) {
        *status = U_BUFFER_OVERFLOW_ERROR;
        return 0;
    }
    for(i=0; i < srcLen; i++) {
        dest[startIndex++] = src[i];
    }
    /* null terminate the buffer */
    dest[startIndex] = 0; /* no bounds check already made sure that we have enough room */
    return startIndex;
}

int32_t getJavaCanonicalName1(const char* icuCanonicalName,
                     char* canonicalName, int32_t capacity,
                     UErrorCode* status) {
 /*
 If a charset listed in the IANA Charset Registry is supported by an implementation
 of the Java platform then its canonical name must be the name listed in the registry.
 Many charsets are given more than one name in the registry, in which case the registry
 identifies one of the names as MIME-preferred. If a charset has more than one registry
 name then its canonical name must be the MIME-preferred name and the other names in
 the registry must be valid aliases. If a supported charset is not listed in the IANA
 registry then its canonical name must begin with one of the strings "X-" or "x-".
 */
    int32_t retLen = 0;
    const char* cName = NULL;
    /* find out the alias with MIME tag */
    if((cName =ucnv_getStandardName(icuCanonicalName, "MIME", status)) !=  NULL) {
        retLen = copyString(canonicalName, capacity, 0, cName, status);
        /* find out the alias with IANA tag */
    }else if((cName =ucnv_getStandardName(icuCanonicalName, "IANA", status)) !=  NULL) {
        retLen = copyString(canonicalName, capacity, 0, cName, status);
    }else {
        /*
            check to see if an alias already exists with x- prefix, if yes then
            make that the canonical name
        */
        int32_t aliasNum = ucnv_countAliases(icuCanonicalName,status);
        int32_t i=0;
        const char* name;
        for(i=0;i<aliasNum;i++) {
            name = ucnv_getAlias(icuCanonicalName,(uint16_t)i, status);
            if(name != NULL && name[0]=='x' && name[1]=='-') {
                retLen = copyString(canonicalName, capacity, 0, name, status);
                break;
            }
        }
        /* last resort just append x- to any of the alias and
            make it the canonical name */
        if(retLen == 0 && U_SUCCESS(*status)) {
            name = ucnv_getStandardName(icuCanonicalName, "UTR22", status);
            if(name == NULL && strchr(icuCanonicalName, ',')!= NULL) {
                name = ucnv_getAlias(icuCanonicalName, 1, status);
                if(*status == U_INDEX_OUTOFBOUNDS_ERROR) {
                    *status = U_ZERO_ERROR;
                }
            }
            /* if there is no UTR22 canonical name .. then just return itself*/
            if(name == NULL) {
                name = icuCanonicalName;
            }
            if(capacity >= 2) {
                strcpy(canonicalName,"x-");
            }
            retLen = copyString(canonicalName, capacity, 2, name, status);
        }
    }
    return retLen;
}

static jobjectArray getAvailable(JNIEnv *env, jclass jClass) {

    jobjectArray ret;
    int32_t i = 0;
    int32_t num = ucnv_countAvailable();
    UErrorCode error = U_ZERO_ERROR;
    const char* name =NULL;
    char canonicalName[256]={0};
    ret= (jobjectArray)(*env)->NewObjectArray( env,num,
                                               (*env)->FindClass(env,"java/lang/String"),
                                               (*env)->NewStringUTF(env,""));

    for(i=0;i<num;i++) {
        name = ucnv_getAvailableName(i);
        getJavaCanonicalName1(name, canonicalName, 256, &error);
#if DEBUG
        if(U_FAILURE(error)) {
            printf("An error occurred retrieving index %i. Error: %s. \n", i, u_errorName(error));
        }

        printf("canonical name for %s\n", canonicalName);
#endif
        // BEGIN android-changed
        jstring canonName = (*env)->NewStringUTF(env,canonicalName);
        (*env)->SetObjectArrayElement(env,ret,i,canonName);
        (*env)->DeleteLocalRef(env, canonName);
        // END android-changed
        /*printf("canonical name : %s  at %i\n", name,i); */
        canonicalName[0]='\0';/* nul terminate */
    }
    return (ret);
}

static jint countAliases(JNIEnv *env, jclass jClass,jstring enc) {

    UErrorCode error = U_ZERO_ERROR;
    jint num =0;
    const char* encName = (*env)->GetStringUTFChars(env,enc,NULL);

    if(encName) {
        num = ucnv_countAliases(encName,&error);
    }

    (*env)->ReleaseStringUTFChars(env,enc,encName);

    return num;
}


static jobjectArray getAliases(JNIEnv *env, jclass jClass, jstring enc) {

    jobjectArray ret=NULL;
    int32_t aliasNum = 0;
    UErrorCode error = U_ZERO_ERROR;
    const char* encName = (*env)->GetStringUTFChars(env,enc,NULL);
    int i=0;
    int j=0;
    const char* aliasArray[50];
    // BEGIN android-removed
    // int32_t utf16AliasNum = 0;
    // END android-removed


    if(encName) {
        const char* myEncName = encName;
        aliasNum = ucnv_countAliases(myEncName,&error);

        // BEGIN android-removed
        // /* special case for UTF-16. In java UTF-16 is always BE*/
        // if(strcmp(myEncName, UTF_16BE)==0) {
        //     utf16AliasNum=ucnv_countAliases(UTF_16,&error);
        // }
        // END android-removed

        if(aliasNum==0 && encName[0] == 0x78 /*x*/ && encName[1]== 0x2d /*-*/) {
            myEncName = encName+2;
            aliasNum = ucnv_countAliases(myEncName,&error);
        }
        if(U_SUCCESS(error)) {
            for(i=0,j=0;i<aliasNum;i++) {
                const char* name = ucnv_getAlias(myEncName,(uint16_t)i,&error);
                if(strchr(name,'+')==0 && strchr(name,',')==0) {
                    aliasArray[j++]= name;
                }
            }

            // BEGIN android-removed
            // if(utf16AliasNum>0) {
            //     for(i=0;i<utf16AliasNum;i++) {
            //         const char* name = ucnv_getAlias(UTF_16,(uint16_t)i,&error);
            //         if(strchr(name,'+')==0 && strchr(name,',')==0) {
            //             aliasArray[j++]= name;
            //         }
            //     }
            // }
            // END android-removed

            ret =  (jobjectArray)(*env)->NewObjectArray(env,j,
                                                        (*env)->FindClass(env,"java/lang/String"),
                                                        (*env)->NewStringUTF(env,""));
            for(;--j>=0;) {
                 // BEGIN android-changed
                 jstring alias = (*env)->NewStringUTF(env, aliasArray[j]);
                 (*env)->SetObjectArrayElement(env, ret, j, alias);
                 (*env)->DeleteLocalRef(env, alias);
                 // END android-changed
            }
        }
    }
    (*env)->ReleaseStringUTFChars(env,enc,encName);

    return (ret);
}

static jstring getCanonicalName(JNIEnv *env, jclass jClass,jstring enc) {

    UErrorCode error = U_ZERO_ERROR;
    const char* encName = (*env)->GetStringUTFChars(env,enc,NULL);
    const char* canonicalName = "";
    // BEGIN android-changed
    jstring ret = NULL;
    if(encName) {
        canonicalName = ucnv_getAlias(encName,0,&error);
        if(canonicalName !=NULL && strstr(canonicalName,",")!=0) {
            canonicalName = ucnv_getAlias(canonicalName,1,&error);
        }
        ret = ((*env)->NewStringUTF(env, canonicalName));
        (*env)->ReleaseStringUTFChars(env,enc,encName);
    }
    // END android-changed
    return ret;
}

static jstring getICUCanonicalName(JNIEnv *env, jclass jClass, jstring enc) {

    UErrorCode error = U_ZERO_ERROR;
    const char* encName = (*env)->GetStringUTFChars(env,enc,NULL);
    const char* canonicalName = NULL;
    jstring ret = NULL;
    if(encName) {
        // BEGIN android-removed
        // if(strcmp(encName,"UTF-16")==0) {
        //     ret = ((*env)->NewStringUTF(env,UTF_16BE));
        // }else
        // END android-removed
        if((canonicalName = ucnv_getCanonicalName(encName, "MIME", &error))!=NULL) {
            ret = ((*env)->NewStringUTF(env, canonicalName));
        }else if((canonicalName = ucnv_getCanonicalName(encName, "IANA", &error))!=NULL) {
            ret = ((*env)->NewStringUTF(env, canonicalName));
        }else if((canonicalName = ucnv_getCanonicalName(encName, "", &error))!=NULL) {
            ret = ((*env)->NewStringUTF(env, canonicalName));
        }else if((canonicalName =  ucnv_getAlias(encName, 0, &error)) != NULL) {
            /* we have some aliases in the form x-blah .. match those first */
            ret = ((*env)->NewStringUTF(env, canonicalName));
        }else if( ret ==NULL && strstr(encName, "x-") == encName) {
            /* check if the converter can be opened with the encName given */
            UConverter* conv = NULL;
            error = U_ZERO_ERROR;
            conv = ucnv_open(encName+2, &error);
            if(conv!=NULL) {
                ret = ((*env)->NewStringUTF(env, encName+2));
            }else{
                /* unsupported encoding */
                ret = ((*env)->NewStringUTF(env, ""));
            }
            ucnv_close(conv);
        }else{
            /* unsupported encoding */
           ret = ((*env)->NewStringUTF(env, ""));
        }
    }
    (*env)->ReleaseStringUTFChars(env,enc,encName);
    return ret;
}

static jstring getJavaCanonicalName2(JNIEnv *env, jclass jClass, jstring icuCanonName) {
 /*
 If a charset listed in the IANA Charset Registry is supported by an implementation
 of the Java platform then its canonical name must be the name listed in the registry.
 Many charsets are given more than one name in the registry, in which case the registry
 identifies one of the names as MIME-preferred. If a charset has more than one registry
 name then its canonical name must be the MIME-preferred name and the other names in
 the registry must be valid aliases. If a supported charset is not listed in the IANA
 registry then its canonical name must begin with one of the strings "X-" or "x-".
 */
    UErrorCode error = U_ZERO_ERROR;
    const char* icuCanonicalName = (*env)->GetStringUTFChars(env,icuCanonName,NULL);
    char cName[UCNV_MAX_CONVERTER_NAME_LENGTH] = {0};
    jstring ret;
    if(icuCanonicalName && icuCanonicalName[0] != 0) {
        getJavaCanonicalName1(icuCanonicalName, cName, UCNV_MAX_CONVERTER_NAME_LENGTH, &error);
    }
    ret = ((*env)->NewStringUTF(env, cName));
    (*env)->ReleaseStringUTFChars(env,icuCanonName,icuCanonicalName);
    return ret;
}

#define SUBS_ARRAY_CAPACITY 256
typedef struct{
    int length;
    char subChars[SUBS_ARRAY_CAPACITY];
    UConverterFromUCallback onUnmappableInput;
    UConverterFromUCallback onMalformedInput;
}EncoderCallbackContext;

void CHARSET_ENCODER_CALLBACK(const void *context,
                  UConverterFromUnicodeArgs *fromArgs,
                  const UChar* codeUnits,
                  int32_t length,
                  UChar32 codePoint,
                  UConverterCallbackReason reason,
                  UErrorCode * status) {
    if(context) {
        EncoderCallbackContext* ctx = (EncoderCallbackContext*)context;

        if(ctx) {
            UConverterFromUCallback realCB = NULL;
            switch(reason) {
                case UCNV_UNASSIGNED:
                    realCB = ctx->onUnmappableInput;
                    break;
                case UCNV_ILLEGAL:/*malformed input*/
                case UCNV_IRREGULAR:/*malformed input*/
                    realCB = ctx->onMalformedInput;
                    break;
                /*
                case UCNV_RESET:
                    ucnv_resetToUnicode(args->converter);
                    break;
                case UCNV_CLOSE:
                    ucnv_close(args->converter);
                    break;
                case UCNV_CLONE:
                    ucnv_clone(args->clone);
               */
                default:
                    *status = U_ILLEGAL_ARGUMENT_ERROR;
                    return;
            }
            if(realCB==NULL) {
                *status = U_INTERNAL_PROGRAM_ERROR;
            }
            realCB(context, fromArgs, codeUnits, length, codePoint, reason, status);
        }
    }
}

void JNI_FROM_U_CALLBACK_SUBSTITUTE_ENCODER(const void *context,
                                        UConverterFromUnicodeArgs *fromArgs,
                                        const UChar* codeUnits,
                                        int32_t length,
                                        UChar32 codePoint,
                                        UConverterCallbackReason reason,
                                        UErrorCode * err) {
    if(context) {
        EncoderCallbackContext* temp = (EncoderCallbackContext*)context;
        *err = U_ZERO_ERROR;
        ucnv_cbFromUWriteBytes(fromArgs,temp->subChars ,temp->length , 0, err);
    }
    return;
}

UConverterFromUCallback getFromUCallback(int32_t mode) {
    switch(mode) {
        default: /* falls through */
        case com_ibm_icu4jni_converters_NativeConverter_STOP_CALLBACK:
            return UCNV_FROM_U_CALLBACK_STOP;
        case com_ibm_icu4jni_converters_NativeConverter_SKIP_CALLBACK:
            return UCNV_FROM_U_CALLBACK_SKIP ;
        case com_ibm_icu4jni_converters_NativeConverter_SUBSTITUTE_CALLBACK:
            return JNI_FROM_U_CALLBACK_SUBSTITUTE_ENCODER;
    }
}

static jint setCallbackEncode(JNIEnv *env, jclass jClass, jlong handle, jint onMalformedInput, jint onUnmappableInput, jbyteArray subChars, jint length) {

    UConverter* conv = (UConverter*)handle;
    UErrorCode errorCode =U_ZERO_ERROR;

    if(conv) {

        UConverterFromUCallback fromUOldAction = NULL;
        void* fromUOldContext = NULL;
        EncoderCallbackContext* fromUNewContext=NULL;
        UConverterFromUCallback fromUNewAction=NULL;
        jbyte* sub = (jbyte*) (*env)->GetPrimitiveArrayCritical(env,subChars, NULL);
        ucnv_getFromUCallBack(conv, &fromUOldAction, &fromUOldContext);

        /* fromUOldContext can only be DecodeCallbackContext since
           the converter created is private data for the decoder
           and callbacks can only be set via this method!
        */
        if(fromUOldContext==NULL) {
            fromUNewContext = (EncoderCallbackContext*) malloc(sizeof(EncoderCallbackContext));
            fromUNewAction = CHARSET_ENCODER_CALLBACK;
        }else{
            fromUNewContext = fromUOldContext;
            fromUNewAction = fromUOldAction;
            fromUOldAction = NULL;
            fromUOldContext = NULL;
        }
        fromUNewContext->onMalformedInput = getFromUCallback(onMalformedInput);
        fromUNewContext->onUnmappableInput = getFromUCallback(onUnmappableInput);
        // BEGIN android-changed
        if(sub!=NULL) {
            fromUNewContext->length = length;
            strncpy(fromUNewContext->subChars, sub, length);
            (*env)->ReleasePrimitiveArrayCritical(env,subChars, sub, 0);
        }else{
            errorCode = U_ILLEGAL_ARGUMENT_ERROR;
        }
        // END android-changed

        ucnv_setFromUCallBack(conv,
           fromUNewAction,
           fromUNewContext,
           &fromUOldAction,
           (const void**)&fromUOldContext,
           &errorCode);


        return errorCode;
    }
    return U_ILLEGAL_ARGUMENT_ERROR;
}

typedef struct{
    int length;
    UChar subUChars[256];
    UConverterToUCallback onUnmappableInput;
    UConverterToUCallback onMalformedInput;
}DecoderCallbackContext;

void JNI_TO_U_CALLBACK_SUBSTITUTE_DECODER(const void *context,
                                    UConverterToUnicodeArgs *toArgs,
                                    const char* codeUnits,
                                    int32_t length,
                                    UConverterCallbackReason reason,
                                    UErrorCode * err) {
    if(context) {
        DecoderCallbackContext* temp = (DecoderCallbackContext*)context;
        *err = U_ZERO_ERROR;
        ucnv_cbToUWriteUChars(toArgs,temp->subUChars ,temp->length , 0, err);
    }
    return;
}

UConverterToUCallback getToUCallback(int32_t mode) {
    switch(mode) {
        default: /* falls through */
        case com_ibm_icu4jni_converters_NativeConverter_STOP_CALLBACK:
            return UCNV_TO_U_CALLBACK_STOP;
        case com_ibm_icu4jni_converters_NativeConverter_SKIP_CALLBACK:
            return UCNV_TO_U_CALLBACK_SKIP ;
        case com_ibm_icu4jni_converters_NativeConverter_SUBSTITUTE_CALLBACK:
            return JNI_TO_U_CALLBACK_SUBSTITUTE_DECODER;
    }
}

void  CHARSET_DECODER_CALLBACK(const void *context,
                               UConverterToUnicodeArgs *args,
                               const char* codeUnits,
                               int32_t length,
                               UConverterCallbackReason reason,
                               UErrorCode *status ) {

    if(context) {
        DecoderCallbackContext* ctx = (DecoderCallbackContext*)context;

        if(ctx) {
            UConverterToUCallback realCB = NULL;
            switch(reason) {
                case UCNV_UNASSIGNED:
                    realCB = ctx->onUnmappableInput;
                    break;
                case UCNV_ILLEGAL:/*malformed input*/
                case UCNV_IRREGULAR:/*malformed input*/
                    realCB = ctx->onMalformedInput;
                    break;
                /*
                case UCNV_RESET:
                    ucnv_resetToUnicode(args->converter);
                    break;
                case UCNV_CLOSE:
                    ucnv_close(args->converter);
                    break;
                case UCNV_CLONE:
                    ucnv_clone(args->clone);
               */
                default:
                    *status = U_ILLEGAL_ARGUMENT_ERROR;
                    return;
            }
            if(realCB==NULL) {
                *status = U_INTERNAL_PROGRAM_ERROR;
            }
            realCB(context, args, codeUnits, length, reason, status);
        }
    }
}

static jint setCallbackDecode(JNIEnv *env, jclass jClass, jlong handle, jint onMalformedInput, jint onUnmappableInput, jcharArray subChars, jint length) {

    UConverter* conv = (UConverter*)handle;
    UErrorCode errorCode =U_ZERO_ERROR;
    if(conv) {

        UConverterToUCallback toUOldAction ;
        void* toUOldContext;
        DecoderCallbackContext* toUNewContext = NULL;
        UConverterToUCallback toUNewAction = NULL;
        jchar* sub = (jchar*) (*env)->GetPrimitiveArrayCritical(env,subChars, NULL);

        ucnv_getToUCallBack(conv, &toUOldAction, &toUOldContext);

        /* toUOldContext can only be DecodeCallbackContext since
           the converter created is private data for the decoder
           and callbacks can only be set via this method!
        */
        if(toUOldContext==NULL) {
            toUNewContext = (DecoderCallbackContext*) malloc(sizeof(DecoderCallbackContext));
            toUNewAction = CHARSET_DECODER_CALLBACK;
        }else{
            toUNewContext = toUOldContext;
            toUNewAction = toUOldAction;
            toUOldAction = NULL;
            toUOldContext = NULL;
        }
        toUNewContext->onMalformedInput = getToUCallback(onMalformedInput);
        toUNewContext->onUnmappableInput = getToUCallback(onUnmappableInput);
        // BEGIN android-changed
        if(sub!=NULL) {
            toUNewContext->length = length;
            u_strncpy(toUNewContext->subUChars, sub, length);
            (*env)->ReleasePrimitiveArrayCritical(env,subChars, sub, 0);
        }else{
            errorCode =  U_ILLEGAL_ARGUMENT_ERROR;
        }
        // END android-changed
        ucnv_setToUCallBack(conv,
           toUNewAction,
           toUNewContext,
           &toUOldAction,
           (const void**)&toUOldContext,
           &errorCode);

        return errorCode;
    }
    return U_ILLEGAL_ARGUMENT_ERROR;
}

static jlong safeClone(JNIEnv *env, jclass jClass, jlong src) {

    UErrorCode status = U_ZERO_ERROR;

    jint buffersize = U_CNV_SAFECLONE_BUFFERSIZE;

    UConverter* conv=NULL;
    UErrorCode errorCode = U_ZERO_ERROR;
    UConverter* source = (UConverter*) src;

    if(source) {
        conv = ucnv_safeClone(source, NULL, &buffersize, &errorCode);
    }

    if (icu4jni_error(env, errorCode) != FALSE) {
        return NULL;
    }

    return conv;
}

static jint getMaxCharsPerByte(JNIEnv *env, jclass jClass, jlong handle) {
    /*
     * currently we know that max number of chars per byte is 2
     */
    return 2;
}

static jfloat getAveCharsPerByte(JNIEnv *env, jclass jClass, jlong handle) {
    jfloat ret = 0;
    ret = (jfloat)( 1/(jfloat)getMaxBytesPerChar(env, jClass, handle));
    return ret;
}

void toUChars(const char* cs, UChar* us, int32_t length) {
    char c;
    while(length>0) {
        c=*cs++;
        *us++=(char)c;
        --length;
    }
}

static jbyteArray getSubstitutionBytes(JNIEnv *env, jclass jClass, jlong handle) {

    const UConverter * cnv = (const UConverter *) handle;
    UErrorCode status = U_ZERO_ERROR;
    char subBytes[10];
    int8_t len =(char)10;
    jbyteArray arr;
    if(cnv) {
        ucnv_getSubstChars(cnv,subBytes,&len,&status);
        if(U_SUCCESS(status)) {
            arr = ((*env)->NewByteArray(env, len));
            if(arr) {
                (*env)->SetByteArrayRegion(env,arr,0,len,(jbyte*)subBytes);
            }
            return arr;
        }
    }
    return ((*env)->NewByteArray(env, 0));
}

static jboolean contains( JNIEnv *env, jclass jClass, jlong handle1, jlong handle2) {
    UErrorCode status = U_ZERO_ERROR;
    const UConverter * cnv1 = (const UConverter *) handle1;
    const UConverter * cnv2 = (const UConverter *) handle2;
    USet* set1;
    USet* set2;
    UBool bRet = 0;

    if(cnv1 != NULL && cnv2 != NULL) {
	    /* open charset 1 */
        set1 = uset_open(1, 2);
        ucnv_getUnicodeSet(cnv1, set1, UCNV_ROUNDTRIP_SET, &status);

        if(U_SUCCESS(status)) {
            /* open charset 2 */
            status = U_ZERO_ERROR;
            set2 = uset_open(1, 2);
            ucnv_getUnicodeSet(cnv2, set2, UCNV_ROUNDTRIP_SET, &status);

            /* contains?      */
            if(U_SUCCESS(status)) {
                bRet = uset_containsAll(set1, set2);
	            uset_close(set2);
            }
            uset_close(set1);
        }
    }
	return bRet;
}

/*
 * JNI registration
 */
static JNINativeMethod gMethods[] = {
    /* name, signature, funcPtr */
    { "convertByteToChar", "(J[BI[CI[IZ)I", (void*) convertByteToChar },
    { "decode", "(J[BI[CI[IZ)I", (void*) decode },
    { "convertCharToByte", "(J[CI[BI[IZ)I", (void*) convertCharToByte },
    { "encode", "(J[CI[BI[IZ)I", (void*) encode },
    { "flushCharToByte", "(J[BI[I)I", (void*) flushCharToByte },
    { "flushByteToChar", "(J[CI[I)I", (void*) flushByteToChar },
    { "openConverter", "(Ljava/lang/String;)J", (void*) openConverter },
    { "resetByteToChar", "(J)V", (void*) resetByteToChar },
    { "resetCharToByte", "(J)V", (void*) resetCharToByte },
    { "closeConverter", "(J)V", (void*) closeConverter },
    { "setSubstitutionChars", "(J[CI)I", (void*) setSubstitutionChars },
    { "setSubstitutionBytes", "(J[BI)I", (void*) setSubstitutionBytes },
    { "setSubstitutionModeCharToByte", "(JZ)I", (void*) setSubstitutionModeCharToByte },
    { "setSubstitutionModeByteToChar", "(JZ)I", (void*) setSubstitutionModeByteToChar },
    { "countInvalidBytes", "(J[I)I", (void*) countInvalidBytes },
    { "countInvalidChars", "(J[I)I", (void*) countInvalidChars },
    { "getMaxBytesPerChar", "(J)I", (void*) getMaxBytesPerChar },
    { "getMinBytesPerChar", "(J)I", (void*) getMinBytesPerChar },
    { "getAveBytesPerChar", "(J)F", (void*) getAveBytesPerChar },
    { "getMaxCharsPerByte", "(J)I", (void*) getMaxCharsPerByte },
    { "getAveCharsPerByte", "(J)F", (void*) getAveCharsPerByte },
    { "contains", "(JJ)Z", (void*) contains },
    { "getSubstitutionBytes", "(J)[B", (void*) getSubstitutionBytes },
    { "canEncode", "(JI)Z", (void*) canEncode },
    { "canDecode", "(J[B)Z", (void*) canDecode },
    { "countAvailable", "()I", (void*) countAvailable },
    { "getAvailable", "()[Ljava/lang/String;", (void*) getAvailable },
    { "countAliases", "(Ljava/lang/String;)I", (void*) countAliases },
    { "getAliases", "(Ljava/lang/String;)[Ljava/lang/String;", (void*) getAliases },
    { "getCanonicalName", "(Ljava/lang/String;)Ljava/lang/String;", (void*) getCanonicalName },
    { "getICUCanonicalName", "(Ljava/lang/String;)Ljava/lang/String;", (void*) getICUCanonicalName },
    { "getJavaCanonicalName", "(Ljava/lang/String;)Ljava/lang/String;", (void*) getJavaCanonicalName2 },
    { "setCallbackDecode", "(JII[CI)I", (void*) setCallbackDecode },
    { "setCallbackEncode", "(JII[BI)I", (void*) setCallbackEncode },
    { "safeClone", "(J)J", (void*) safeClone }
};

int register_com_ibm_icu4jni_converters_NativeConverter(JNIEnv *_env) {
    return jniRegisterNativeMethods(_env, "com/ibm/icu4jni/charset/NativeConverter",
                gMethods, NELEM(gMethods));
}