aboutsummaryrefslogtreecommitdiffstats
path: root/native/jni/com_android_inputmethod_latin_BinaryDictionary.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'native/jni/com_android_inputmethod_latin_BinaryDictionary.cpp')
-rw-r--r--native/jni/com_android_inputmethod_latin_BinaryDictionary.cpp205
1 files changed, 120 insertions, 85 deletions
diff --git a/native/jni/com_android_inputmethod_latin_BinaryDictionary.cpp b/native/jni/com_android_inputmethod_latin_BinaryDictionary.cpp
index 6e2efbec1..5a287a122 100644
--- a/native/jni/com_android_inputmethod_latin_BinaryDictionary.cpp
+++ b/native/jni/com_android_inputmethod_latin_BinaryDictionary.cpp
@@ -14,15 +14,12 @@
* limitations under the License.
*/
+
+#include <cstring> // for memset()
+
#define LOG_TAG "LatinIME: jni: BinaryDictionary"
-#include "binary_format.h"
-#include "com_android_inputmethod_latin_BinaryDictionary.h"
-#include "correction.h"
-#include "defines.h"
-#include "dictionary.h"
-#include "jni.h"
-#include "jni_common.h"
+#include "defines.h" // for macros below
#ifdef USE_MMAP_FOR_DICTIONARY
#include <cerrno>
@@ -32,6 +29,13 @@
#include <cstdlib>
#endif // USE_MMAP_FOR_DICTIONARY
+#include "binary_format.h"
+#include "com_android_inputmethod_latin_BinaryDictionary.h"
+#include "correction.h"
+#include "dictionary.h"
+#include "jni.h"
+#include "jni_common.h"
+
namespace latinime {
class ProximityInfo;
@@ -71,7 +75,7 @@ static jlong latinime_BinaryDictionary_open(JNIEnv *env, jobject object,
AKLOGE("DICT: Can't mmap dictionary. errno=%d", errno);
return 0;
}
- dictBuf = (void *)((char *)dictBuf + adjust);
+ dictBuf = reinterpret_cast<void *>(reinterpret_cast<char *>(dictBuf) + adjust);
#else // USE_MMAP_FOR_DICTIONARY
/* malloc version */
FILE *file = 0;
@@ -106,10 +110,11 @@ static jlong latinime_BinaryDictionary_open(JNIEnv *env, jobject object,
return 0;
}
Dictionary *dictionary = 0;
- if (BinaryFormat::UNKNOWN_FORMAT == BinaryFormat::detectFormat((uint8_t*)dictBuf)) {
+ if (BinaryFormat::UNKNOWN_FORMAT
+ == BinaryFormat::detectFormat(reinterpret_cast<uint8_t *>(dictBuf))) {
AKLOGE("DICT: dictionary format is unknown, bad magic number");
#ifdef USE_MMAP_FOR_DICTIONARY
- releaseDictBuf(((char*)dictBuf) - adjust, adjDictSize, fd);
+ releaseDictBuf(reinterpret_cast<char *>(dictBuf) - adjust, adjDictSize, fd);
#else // USE_MMAP_FOR_DICTIONARY
releaseDictBuf(dictBuf, 0, 0);
#endif // USE_MMAP_FOR_DICTIONARY
@@ -124,106 +129,132 @@ static jlong latinime_BinaryDictionary_open(JNIEnv *env, jobject object,
static int latinime_BinaryDictionary_getSuggestions(JNIEnv *env, jobject object, jlong dict,
jlong proximityInfo, jlong dicTraverseSession, jintArray xCoordinatesArray,
- jintArray yCoordinatesArray, jintArray timesArray, jintArray pointerIdArray,
- jintArray inputArray, jint arraySize, jint commitPoint, jboolean isGesture,
- jintArray prevWordForBigrams, jboolean useFullEditDistance, jcharArray outputArray,
- jintArray frequencyArray, jintArray spaceIndexArray, jintArray outputTypesArray) {
+ jintArray yCoordinatesArray, jintArray timesArray, jintArray pointerIdsArray,
+ jintArray inputCodePointsArray, jint arraySize, jint commitPoint, jboolean isGesture,
+ jintArray prevWordCodePointsForBigrams, jboolean useFullEditDistance,
+ jcharArray outputCharsArray, jintArray scoresArray, jintArray spaceIndicesArray,
+ jintArray outputTypesArray) {
Dictionary *dictionary = reinterpret_cast<Dictionary*>(dict);
if (!dictionary) return 0;
ProximityInfo *pInfo = reinterpret_cast<ProximityInfo*>(proximityInfo);
void *traverseSession = reinterpret_cast<void*>(dicTraverseSession);
- int *xCoordinates = env->GetIntArrayElements(xCoordinatesArray, 0);
- int *yCoordinates = env->GetIntArrayElements(yCoordinatesArray, 0);
- int *times = env->GetIntArrayElements(timesArray, 0);
- int *pointerIds = env->GetIntArrayElements(pointerIdArray, 0);
- int *frequencies = env->GetIntArrayElements(frequencyArray, 0);
- int *inputCodes = env->GetIntArrayElements(inputArray, 0);
- jchar *outputChars = env->GetCharArrayElements(outputArray, 0);
- int *spaceIndices = env->GetIntArrayElements(spaceIndexArray, 0);
- int *outputTypes = env->GetIntArrayElements(outputTypesArray, 0);
- jint *prevWordChars = prevWordForBigrams
- ? env->GetIntArrayElements(prevWordForBigrams, 0) : 0;
- jsize prevWordLength = prevWordChars ? env->GetArrayLength(prevWordForBigrams) : 0;
+
+ // Input values
+ int xCoordinates[arraySize];
+ int yCoordinates[arraySize];
+ int times[arraySize];
+ int pointerIds[arraySize];
+ const jsize inputCodePointsLength = env->GetArrayLength(inputCodePointsArray);
+ int inputCodePoints[inputCodePointsLength];
+ const jsize prevWordCodePointsLength =
+ prevWordCodePointsForBigrams ? env->GetArrayLength(prevWordCodePointsForBigrams) : 0;
+ int prevWordCodePointsInternal[prevWordCodePointsLength];
+ int *prevWordCodePoints = 0;
+ env->GetIntArrayRegion(xCoordinatesArray, 0, arraySize, xCoordinates);
+ env->GetIntArrayRegion(yCoordinatesArray, 0, arraySize, yCoordinates);
+ env->GetIntArrayRegion(timesArray, 0, arraySize, times);
+ env->GetIntArrayRegion(pointerIdsArray, 0, arraySize, pointerIds);
+ env->GetIntArrayRegion(inputCodePointsArray, 0, inputCodePointsLength, inputCodePoints);
+ if (prevWordCodePointsForBigrams) {
+ env->GetIntArrayRegion(prevWordCodePointsForBigrams, 0, prevWordCodePointsLength,
+ prevWordCodePointsInternal);
+ prevWordCodePoints = prevWordCodePointsInternal;
+ }
+
+ // Output values
+ // TODO: Should be "outputCodePointsLength" and "int outputCodePoints[]"
+ const jsize outputCharsLength = env->GetArrayLength(outputCharsArray);
+ unsigned short outputChars[outputCharsLength];
+ const jsize scoresLength = env->GetArrayLength(scoresArray);
+ int scores[scoresLength];
+ const jsize spaceIndicesLength = env->GetArrayLength(spaceIndicesArray);
+ int spaceIndices[spaceIndicesLength];
+ const jsize outputTypesLength = env->GetArrayLength(outputTypesArray);
+ int outputTypes[outputTypesLength];
+ memset(outputChars, 0, outputCharsLength * sizeof(outputChars[0]));
+ memset(scores, 0, scoresLength * sizeof(scores[0]));
+ memset(spaceIndices, 0, spaceIndicesLength * sizeof(spaceIndices[0]));
+ memset(outputTypes, 0, outputTypesLength * sizeof(outputTypes[0]));
int count;
if (isGesture || arraySize > 1) {
count = dictionary->getSuggestions(pInfo, traverseSession, xCoordinates, yCoordinates,
- times, pointerIds, inputCodes, arraySize, prevWordChars, prevWordLength,
- commitPoint, isGesture, useFullEditDistance, (unsigned short*) outputChars,
- frequencies, spaceIndices, outputTypes);
+ times, pointerIds, inputCodePoints, arraySize, prevWordCodePoints,
+ prevWordCodePointsLength, commitPoint, isGesture, useFullEditDistance, outputChars,
+ scores, spaceIndices, outputTypes);
} else {
- count = dictionary->getBigrams(prevWordChars, prevWordLength, inputCodes,
- arraySize, (unsigned short*) outputChars, frequencies, outputTypes);
+ count = dictionary->getBigrams(prevWordCodePoints, prevWordCodePointsLength,
+ inputCodePoints, arraySize, outputChars, scores, outputTypes);
}
- if (prevWordChars) {
- env->ReleaseIntArrayElements(prevWordForBigrams, prevWordChars, JNI_ABORT);
- }
- env->ReleaseIntArrayElements(outputTypesArray, outputTypes, 0);
- env->ReleaseIntArrayElements(spaceIndexArray, spaceIndices, 0);
- env->ReleaseCharArrayElements(outputArray, outputChars, 0);
- env->ReleaseIntArrayElements(inputArray, inputCodes, JNI_ABORT);
- env->ReleaseIntArrayElements(frequencyArray, frequencies, 0);
- env->ReleaseIntArrayElements(pointerIdArray, pointerIds, 0);
- env->ReleaseIntArrayElements(timesArray, times, 0);
- env->ReleaseIntArrayElements(yCoordinatesArray, yCoordinates, 0);
- env->ReleaseIntArrayElements(xCoordinatesArray, xCoordinates, 0);
+ // Copy back the output values
+ // TODO: Should be SetIntArrayRegion()
+ env->SetCharArrayRegion(outputCharsArray, 0, outputCharsLength, outputChars);
+ env->SetIntArrayRegion(scoresArray, 0, scoresLength, scores);
+ env->SetIntArrayRegion(spaceIndicesArray, 0, spaceIndicesLength, spaceIndices);
+ env->SetIntArrayRegion(outputTypesArray, 0, outputTypesLength, outputTypes);
+
return count;
}
static jint latinime_BinaryDictionary_getFrequency(JNIEnv *env, jobject object, jlong dict,
- jintArray wordArray, jint wordLength) {
- Dictionary *dictionary = (Dictionary*)dict;
- if (!dictionary) return (jboolean) false;
- jint *word = env->GetIntArrayElements(wordArray, 0);
- jint result = dictionary->getFrequency(word, wordLength);
- env->ReleaseIntArrayElements(wordArray, word, JNI_ABORT);
- return result;
+ jintArray wordArray) {
+ Dictionary *dictionary = reinterpret_cast<Dictionary*>(dict);
+ if (!dictionary) return 0;
+ const jsize codePointLength = env->GetArrayLength(wordArray);
+ int codePoints[codePointLength];
+ env->GetIntArrayRegion(wordArray, 0, codePointLength, codePoints);
+ return dictionary->getFrequency(codePoints, codePointLength);
}
static jboolean latinime_BinaryDictionary_isValidBigram(JNIEnv *env, jobject object, jlong dict,
jintArray wordArray1, jintArray wordArray2) {
- Dictionary *dictionary = (Dictionary*)dict;
+ Dictionary *dictionary = reinterpret_cast<Dictionary*>(dict);
if (!dictionary) return (jboolean) false;
- jint *word1 = env->GetIntArrayElements(wordArray1, 0);
- jint *word2 = env->GetIntArrayElements(wordArray2, 0);
- jsize length1 = word1 ? env->GetArrayLength(wordArray1) : 0;
- jsize length2 = word2 ? env->GetArrayLength(wordArray2) : 0;
- jboolean result = dictionary->isValidBigram(word1, length1, word2, length2);
- env->ReleaseIntArrayElements(wordArray2, word2, JNI_ABORT);
- env->ReleaseIntArrayElements(wordArray1, word1, JNI_ABORT);
- return result;
+ const jsize codePointLength1 = env->GetArrayLength(wordArray1);
+ const jsize codePointLength2 = env->GetArrayLength(wordArray2);
+ int codePoints1[codePointLength1];
+ int codePoints2[codePointLength2];
+ env->GetIntArrayRegion(wordArray1, 0, codePointLength1, codePoints1);
+ env->GetIntArrayRegion(wordArray2, 0, codePointLength2, codePoints2);
+ return dictionary->isValidBigram(codePoints1, codePointLength1, codePoints2, codePointLength2);
}
static jfloat latinime_BinaryDictionary_calcNormalizedScore(JNIEnv *env, jobject object,
- jcharArray before, jint beforeLength, jcharArray after, jint afterLength, jint score) {
- jchar *beforeChars = env->GetCharArrayElements(before, 0);
- jchar *afterChars = env->GetCharArrayElements(after, 0);
- jfloat result = Correction::RankingAlgorithm::calcNormalizedScore((unsigned short*)beforeChars,
- beforeLength, (unsigned short*)afterChars, afterLength, score);
- env->ReleaseCharArrayElements(after, afterChars, JNI_ABORT);
- env->ReleaseCharArrayElements(before, beforeChars, JNI_ABORT);
- return result;
+ jcharArray before, jcharArray after, jint score) {
+ jsize beforeLength = env->GetArrayLength(before);
+ jsize afterLength = env->GetArrayLength(after);
+ jchar beforeChars[beforeLength];
+ jchar afterChars[afterLength];
+ env->GetCharArrayRegion(before, 0, beforeLength, beforeChars);
+ env->GetCharArrayRegion(after, 0, afterLength, afterChars);
+ return Correction::RankingAlgorithm::calcNormalizedScore(
+ reinterpret_cast<unsigned short *>(beforeChars), beforeLength,
+ reinterpret_cast<unsigned short *>(afterChars), afterLength, score);
}
static jint latinime_BinaryDictionary_editDistance(JNIEnv *env, jobject object,
- jcharArray before, jint beforeLength, jcharArray after, jint afterLength) {
- jchar *beforeChars = env->GetCharArrayElements(before, 0);
- jchar *afterChars = env->GetCharArrayElements(after, 0);
- jint result = Correction::RankingAlgorithm::editDistance(
- (unsigned short*)beforeChars, beforeLength, (unsigned short*)afterChars, afterLength);
- env->ReleaseCharArrayElements(after, afterChars, JNI_ABORT);
- env->ReleaseCharArrayElements(before, beforeChars, JNI_ABORT);
- return result;
+ jcharArray before, jcharArray after) {
+ jsize beforeLength = env->GetArrayLength(before);
+ jsize afterLength = env->GetArrayLength(after);
+ jchar beforeChars[beforeLength];
+ jchar afterChars[afterLength];
+ env->GetCharArrayRegion(before, 0, beforeLength, beforeChars);
+ env->GetCharArrayRegion(after, 0, afterLength, afterChars);
+ return Correction::RankingAlgorithm::editDistance(
+ reinterpret_cast<unsigned short *>(beforeChars), beforeLength,
+ reinterpret_cast<unsigned short *>(afterChars), afterLength);
}
static void latinime_BinaryDictionary_close(JNIEnv *env, jobject object, jlong dict) {
- Dictionary *dictionary = (Dictionary*)dict;
+ Dictionary *dictionary = reinterpret_cast<Dictionary*>(dict);
if (!dictionary) return;
void *dictBuf = dictionary->getDict();
if (!dictBuf) return;
#ifdef USE_MMAP_FOR_DICTIONARY
- releaseDictBuf((void *)((char *)dictBuf - dictionary->getDictBufAdjust()),
+ releaseDictBuf(
+ reinterpret_cast<void *>(
+ reinterpret_cast<char *>(dictBuf) - dictionary->getDictBufAdjust()),
dictionary->getDictSize() + dictionary->getDictBufAdjust(), dictionary->getMmapFd());
#else // USE_MMAP_FOR_DICTIONARY
releaseDictBuf(dictBuf, 0, 0);
@@ -247,15 +278,19 @@ static void releaseDictBuf(void *dictBuf, const size_t length, int fd) {
}
static JNINativeMethod sMethods[] = {
- {"openNative", "(Ljava/lang/String;JJIIIII)J", (void*)latinime_BinaryDictionary_open},
- {"closeNative", "(J)V", (void*)latinime_BinaryDictionary_close},
+ {"openNative", "(Ljava/lang/String;JJIIIII)J",
+ reinterpret_cast<void *>(latinime_BinaryDictionary_open)},
+ {"closeNative", "(J)V", reinterpret_cast<void *>(latinime_BinaryDictionary_close)},
{"getSuggestionsNative", "(JJJ[I[I[I[I[IIIZ[IZ[C[I[I[I)I",
- (void*) latinime_BinaryDictionary_getSuggestions},
- {"getFrequencyNative", "(J[II)I", (void*)latinime_BinaryDictionary_getFrequency},
- {"isValidBigramNative", "(J[I[I)Z", (void*)latinime_BinaryDictionary_isValidBigram},
- {"calcNormalizedScoreNative", "([CI[CII)F",
- (void*)latinime_BinaryDictionary_calcNormalizedScore},
- {"editDistanceNative", "([CI[CI)I", (void*)latinime_BinaryDictionary_editDistance}
+ reinterpret_cast<void *>(latinime_BinaryDictionary_getSuggestions)},
+ {"getFrequencyNative", "(J[I)I",
+ reinterpret_cast<void *>(latinime_BinaryDictionary_getFrequency)},
+ {"isValidBigramNative", "(J[I[I)Z",
+ reinterpret_cast<void *>(latinime_BinaryDictionary_isValidBigram)},
+ {"calcNormalizedScoreNative", "([C[CI)F",
+ reinterpret_cast<void *>(latinime_BinaryDictionary_calcNormalizedScore)},
+ {"editDistanceNative", "([C[C)I",
+ reinterpret_cast<void *>(latinime_BinaryDictionary_editDistance)}
};
int register_BinaryDictionary(JNIEnv *env) {
generated by cgit v1.2.3-83-g751a (git 2.47.1) at 2025-05-17 15:54:08 +0000