/*
* Copyright (C) 2008-2012 OMRON SOFTWARE Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni.h"
#include "nj_lib.h"
#include "nj_err.h"
#include "nj_ext.h"
#include "nj_dic.h"
#include <stdlib.h>
#include <string.h>
#include <dlfcn.h>
#include "OpenWnnJni.h"
#include "predef_table.h"
/**
* functions for internal use
*/
static void clearDictionaryStructure( NJ_DIC_INFO* dicInfo ) {
dicInfo->type = 0;
dicInfo->handle = NULL;
/* dicInfo->srhCache = NULL; */
dicInfo->dic_freq[ NJ_MODE_TYPE_HENKAN ].base = 0;
dicInfo->dic_freq[ NJ_MODE_TYPE_HENKAN ].high = 0;
}
static NJ_CHAR convertUTFCharToNjChar( NJ_UINT8* src )
{
NJ_CHAR ret;
NJ_UINT8* dst;
/* convert UTF-16BE character to NJ_CHAR format */
dst = ( NJ_UINT8* )&ret;
dst[ 0 ] = src[ 0 ];
dst[ 1 ] = src[ 1 ];
return ret;
}
static int convertStringToNjChar( JNIEnv *env, NJ_CHAR* dst, jstring srcJ, int maxChars )
{
const unsigned char* src;
src = ( const unsigned char* )( ( *env )->GetStringUTFChars( env, srcJ, NULL ) );
if( src != NULL ) {
int i, o;
/* convert UTF-8 to UTF-16BE */
for( i = o = 0 ; src[ i ] != 0x00 && o < maxChars ; ) {
NJ_UINT8* dst_tmp;
dst_tmp = ( NJ_UINT8* )&( dst[ o ] );
if( ( src[ i ] & 0x80 ) == 0x00 ) {
/* U+0000 ... U+007f */
/* 8[0xxxxxxx] -> 16BE[00000000 0xxxxxxx] */
dst_tmp[ 0 ] = 0x00;
dst_tmp[ 1 ] = src[ i + 0 ] & 0x7f;
i++;
o++;
} else if( ( src[ i ] & 0xe0 ) == 0xc0 ) {
/* U+0080 ... U+07ff */
/* 8[110xxxxx 10yyyyyy] -> 16BE[00000xxx xxyyyyyy] */
if( src[ i + 1 ] == 0x00 ) {
break;
}
dst_tmp[ 0 ] = ( ( src[ i + 0 ] & 0x1f ) >> 2 );
dst_tmp[ 1 ] = ( ( src[ i + 0 ] & 0x1f ) << 6 ) | ( src[ i + 1 ] & 0x3f );
i += 2;
o++;
} else if( ( src[ i ] & 0xf0 ) == 0xe0 ) {
/* U+0800 ... U+ffff */
/* 8[1110xxxx 10yyyyyy 10zzzzzz] -> 16BE[xxxxyyyy yyzzzzzz] */
if( src[ i + 1 ] == 0x00 || src[ i + 2 ] == 0x00 ) {
break;
}
dst_tmp[ 0 ] = ( ( src[ i + 0 ] & 0x0f ) << 4 ) | ( ( src[ i + 1 ] & 0x3f ) >> 2 );
dst_tmp[ 1 ] = ( ( src[ i + 1 ] & 0x3f ) << 6 ) | ( src[ i + 2 ] & 0x3f );
i += 3;
o++;
} else if( ( src[ i ] & 0xf8 ) == 0xf0 ) {
NJ_UINT8 dst1, dst2, dst3;
/* U+10000 ... U+10ffff */
/* 8[11110www 10xxxxxx 10yyyyyy 10zzzzzz] -> 32BE[00000000 000wwwxx xxxxyyyy yyzzzzzz] */
/* -> 16BE[110110WW XXxxxxyy 110111yy yyzzzzzz] */
/* -- --====== == -------- */
/* dst1 dst2 dst3 */
/* "wwwxx"(00001-10000) - 1 = "WWXX"(0000-1111) */
if( !( o < maxChars - 1 ) ) {
/* output buffer is full */
break;
}
if( src[ i + 1 ] == 0x00 || src[ i + 2 ] == 0x00 || src[ i + 3 ] == 0x00 ) {
break;
}
dst1 = ( ( ( src[ i + 0 ] & 0x07 ) << 2 ) | ( ( src[ i + 1 ] & 0x3f ) >> 4 ) ) - 1;
dst2 = ( ( src[ i + 1 ] & 0x3f ) << 4 ) | ( ( src[ i + 2 ] & 0x3f ) >> 2 );
dst3 = ( ( src[ i + 2 ] & 0x3f ) << 6 ) | ( src[ i + 3 ] & 0x3f );
dst_tmp[ 0 ] = 0xd8 | ( ( dst1 & 0x0c ) >> 2 );
dst_tmp[ 1 ] = ( ( dst1 & 0x03 ) << 6 ) | ( ( dst2 & 0xfc ) >> 2 );
dst_tmp[ 2 ] = 0xdc | ( ( dst2 & 0x03 ) );
dst_tmp[ 3 ] = dst3;
i += 4;
o += 2;
} else { /* Broken code */
break;
}
}
dst[ o ] = NJ_CHAR_NUL;
( *env )->ReleaseStringUTFChars( env, srcJ, ( const char* )src );
return 0;
}
/* If retrieveing the string failed, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_CONVERT_STR_TO_NJC, NJ_ERR_JNI_FUNC_FAILED);
}
static int convertNjCharToString( JNIEnv* env, jstring* dstJ, NJ_CHAR* src, int maxChars )
{
char dst[ (NJ_MAX_LEN + NJ_MAX_RESULT_LEN + NJ_TERM_LEN ) * 3 + 1 ];
int i, o;
/* convert UTF-16BE to a UTF-8 */
for( i = o = 0 ; src[ i ] != 0x0000 && i < maxChars ; ) {
NJ_UINT8* src_tmp;
src_tmp = ( NJ_UINT8* )&( src[ i ] );
if( src_tmp[ 0 ] == 0x00 && src_tmp[ 1 ] <= 0x7f ) {
/* U+0000 ... U+007f */
/* 16BE[00000000 0xxxxxxx] -> 8[0xxxxxxx] */
dst[ o + 0 ] = src_tmp[ 1 ] & 0x007f;
i++;
o++;
} else if ( src_tmp[ 0 ] <= 0x07 ) {
/* U+0080 ... U+07ff */
/* 16BE[00000xxx xxyyyyyy] -> 8[110xxxxx 10yyyyyy] */
dst[ o + 0 ] = 0xc0 | ( ( src_tmp[ 0 ] & 0x07 ) << 2 ) | ( ( src_tmp[ 1 ] & 0xc0 ) >> 6 );
dst[ o + 1 ] = 0x80 | ( ( src_tmp[ 1 ] & 0x3f ) );
i++;
o += 2;
} else if ( src_tmp[ 0 ] >= 0xd8 && src_tmp[ 0 ] <= 0xdb ) {
NJ_UINT8 src1, src2, src3;
/* U+10000 ... U+10ffff (surrogate pair) */
/* 32BE[00000000 000wwwxx xxxxyyyy yyzzzzzz] -> 8[11110www 10xxxxxx 10yyyyyy 10zzzzzz] */
/* 16BE[110110WW XXxxxxyy 110111yy yyzzzzzz] */
/* -- --====== == -------- */
/* src1 src2 src3 */
/* "WWXX"(0000-1111) + 1 = "wwwxx"(0001-10000) */
if( !( i < maxChars - 1 ) || src_tmp[ 2 ] < 0xdc || src_tmp[ 2 ] > 0xdf ) {
/* That is broken code */
break;
}
src1 = ( ( ( src_tmp[ 0 ] & 0x03 ) << 2 ) | ( ( src_tmp[ 1 ] & 0xc0 ) >> 6 ) ) + 1;
src2 = ( ( src_tmp[ 1 ] & 0x3f ) << 2 ) | ( ( src_tmp[ 2 ] & 0x03 ) );
src3 = src_tmp[ 3 ];
dst[ o + 0 ] = 0xf0 | ( ( src1 & 0x1c ) >> 2 );
dst[ o + 1 ] = 0x80 | ( ( src1 & 0x03 ) << 4 ) | ( ( src2 & 0xf0 ) >> 4 );
dst[ o + 2 ] = 0x80 | ( ( src2 & 0x0f ) << 2 ) | ( ( src3 & 0xc0 ) >> 6 );
dst[ o + 3 ] = 0x80 | ( src3 & 0x3f );
i += 2;
o += 4;
} else {
/* U+0800 ... U+ffff (except range of surrogate pair) */
/* 16BE[xxxxyyyy yyzzzzzz] -> 8[1110xxxx 10yyyyyy 10zzzzzz] */
dst[ o + 0 ] = 0xe0 | ( ( src_tmp[ 0 ] & 0xf0 ) >> 4 );
dst[ o + 1 ] = 0x80 | ( ( src_tmp[ 0 ] & 0x0f ) << 2 ) | ( ( src_tmp[ 1 ] & 0xc0 ) >> 6 );
dst[ o + 2 ] = 0x80 | ( ( src_tmp[ 1 ] & 0x3f ) );
i++;
o += 3;
}
}
dst[ o ] = 0x00;
*dstJ = ( *env )->NewStringUTF( env, dst );
/* If NewString() failed, return an error code */
return ( *dstJ == NULL ) ? NJ_SET_ERR_VAL(NJ_FUNC_JNI_CONVERT_NJC_TO_STR, NJ_ERR_JNI_FUNC_FAILED) : 0;
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: createWnnWork
* Signature: (Ljava/lang/String;)J
*/
JNIEXPORT jlong JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_createWnnWork
(JNIEnv *env, jobject obj, jstring dicLibPathJ)
{
NJ_JNIWORK* work;
/* Allocating the internal work area */
work = ( NJ_JNIWORK* )malloc( sizeof( NJ_JNIWORK ) );
if( work != NULL ) {
NJ_UINT32* dic_size;
NJ_UINT8* dic_type;
NJ_UINT8** dic_data;
NJ_UINT8** con_data;
const char* dicLibPath;
NJ_INT16 result;
int i;
/* Initialize the work area */
memset( work, 0x00, sizeof( NJ_JNIWORK ) );
/* Load the dictionary library which is specified by dicLibPathJ */
if( dicLibPathJ == NULL ||
( dicLibPath = ( *env )->GetStringUTFChars( env, dicLibPathJ, 0 ) ) == NULL ) {
free( work );
return 0;
}
work->dicLibHandle = ( void* )dlopen( dicLibPath, RTLD_LAZY );
( *env )->ReleaseStringUTFChars( env, dicLibPathJ, dicLibPath );
if( work->dicLibHandle == NULL ) {
free( work );
return 0;
}
/* Retrieve data pointers of dictionary from the dictionary library, and put to internal work area */
dic_size = ( NJ_UINT32* )dlsym( work->dicLibHandle, "dic_size" );
dic_type = ( NJ_UINT8* )dlsym( work->dicLibHandle, "dic_type" );
dic_data = ( NJ_UINT8** )dlsym( work->dicLibHandle, "dic_data" );
if( dic_size == NULL || dic_type == NULL || dic_data == NULL ) {
dlclose( work->dicLibHandle );
free( work );
return 0;
}
for( i = 0 ; i < NJ_MAX_DIC ; i++ ) {
work->dicHandle[ i ] = dic_data[ i ];
work->dicSize[ i ] = dic_size[ i ];
work->dicType[ i ] = dic_type[ i ];
}
/* Set the rule dictionary if the rule data exist */
con_data = ( NJ_UINT8** )dlsym( work->dicLibHandle, "con_data" );
if( con_data != NULL ) {
work->dicSet.rHandle[ NJ_MODE_TYPE_HENKAN ] = con_data[ 0 ];
}
/* Execute the initialize method to initialize the internal work area */
result = njx_init( &( work->wnnClass ) );
if( result >= 0 ) {
jlong jresult;
*( NJ_JNIWORK** )&jresult = work;
return jresult;
}
/* If allocating a byte array failed, free all resource, and return NULL */
dlclose( work->dicLibHandle );
free( work );
}
/* If allocating the internal work area failed, return NULL */
return 0;
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: freeWnnWork
* Signature: (J)I
*/
JNIEXPORT jint JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_freeWnnWork
(JNIEnv *env, jobject obj, jlong wnnWork)
{
NJ_JNIWORK* work;
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
/* If the internal work area was not yet released, remove that */
if( work->dicLibHandle != NULL ) {
dlclose( work->dicLibHandle );
work->dicLibHandle = NULL;
}
free( work );
return 0;
}
/* freeWnnWork() is always successful even if the internal work area was already released */
return 0;
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: clearDictionaryParameters
* Signature: (J)I
*/
JNIEXPORT jint JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_clearDictionaryParameters
(JNIEnv *env, jobject obj, jlong wnnWork)
{
NJ_JNIWORK* work;
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
int index;
/* Clear all dictionary set information structure and reset search state */
for( index = 0 ; index < NJ_MAX_DIC ; index++ ) {
clearDictionaryStructure( &( work->dicSet.dic[ index ] ) );
}
work->flag = NJ_JNI_FLAG_NONE;
/* Clear the cache information */
memset( work->dicSet.keyword, 0x00, sizeof( work->dicSet.keyword ) );
return 0;
}
/* If the internal work area was already released, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_CLEAR_DICTIONARY_PARAMETERS, NJ_ERR_NOT_ALLOCATED);
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: setDictionaryParameter
* Signature: (JIII)I
*/
JNIEXPORT jint JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_setDictionaryParameter
(JNIEnv *env, jobject obj, jlong wnnWork, jint index, jint base, jint high)
{
NJ_JNIWORK* work;
if( ( index < 0 || index > NJ_MAX_DIC-1 ) ||
( base < -1 || base > 1000 ) ||
( high < -1 || high > 1000 ) ) {
/* If a invalid parameter was specified, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SET_DICTIONARY_PARAMETERS, NJ_ERR_INVALID_PARAM);
}
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
/* Create the dictionary set information structure */
if( base < 0 || high < 0 || base > high ) {
/* If -1 was specified to base or high, clear that dictionary information structure */
/* If base is larger than high, clear that dictionary information structure */
clearDictionaryStructure( &( work->dicSet.dic[ index ] ) );
} else {
/* Set the dictionary informatin structure */
work->dicSet.dic[ index ].type = work->dicType[ index ];
work->dicSet.dic[ index ].handle = work->dicHandle[ index ];
work->dicSet.dic[ index ].srhCache = &( work->srhCache[ index ] );
work->dicSet.dic[ index ].dic_freq[ NJ_MODE_TYPE_HENKAN ].base = base;
work->dicSet.dic[ index ].dic_freq[ NJ_MODE_TYPE_HENKAN ].high = high;
}
/* Reset search state because the dicionary information was changed */
work->flag = NJ_JNI_FLAG_NONE;
return 0;
}
/* If the internal work area was already released, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SET_DICTIONARY_PARAMETERS, NJ_ERR_NOT_ALLOCATED);
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: searchWord
* Signature: (JIILjava/lang/String;)I
*/
JNIEXPORT jint JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_searchWord
(JNIEnv *env, jobject obj, jlong wnnWork, jint operation, jint order, jstring keyString)
{
NJ_JNIWORK* work;
if( !( operation == jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_SEARCH_EXACT ||
operation == jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_SEARCH_PREFIX ||
operation == jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_SEARCH_LINK ) ||
!( order == jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_ORDER_BY_FREQUENCY ||
order == jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_ORDER_BY_KEY ) ||
keyString == NULL ) {
/* If a invalid parameter was specified, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SEARCH_WORD, NJ_ERR_INVALID_PARAM);
}
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
if( ( *env )->GetStringLength( env, keyString ) > NJ_MAX_LEN ) {
/* If too long key string was specified, return "No result is found" */
work->flag &= ~NJ_JNI_FLAG_ENABLE_CURSOR;
work->flag &= ~NJ_JNI_FLAG_ENABLE_RESULT;
return 0;
}
if( convertStringToNjChar( env, work->keyString, keyString, NJ_MAX_LEN ) >= 0 ) {
jint result;
/* Set the structure for search */
memset( &( work->cursor ), 0x00, sizeof( NJ_CURSOR ) );
work->cursor.cond.operation = operation;
work->cursor.cond.mode = order;
work->cursor.cond.ds = &( work->dicSet );
work->cursor.cond.yomi = work->keyString;
work->cursor.cond.charset = &( work->approxSet );
/* If the link search feature is specified, set the predict search information to structure */
if( operation == jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_SEARCH_LINK ) {
work->cursor.cond.yomi = work->previousStroke;
work->cursor.cond.kanji = work->previousCandidate;
}
/* Search a specified word */
memcpy( &( work->wnnClass.dic_set ), &( work->dicSet ), sizeof( NJ_DIC_SET ) );
result = ( jint )njx_search_word( &( work->wnnClass ), &( work->cursor ) );
/* If a result is found, enable getNextWord method */
if( result == 1 ) {
work->flag |= NJ_JNI_FLAG_ENABLE_CURSOR;
} else {
work->flag &= ~NJ_JNI_FLAG_ENABLE_CURSOR;
}
work->flag &= ~NJ_JNI_FLAG_ENABLE_RESULT;
return result;
}
/* If converting the string failed, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SEARCH_WORD, NJ_ERR_INTERNAL);
}
/* If the internal work area was already released, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SEARCH_WORD, NJ_ERR_NOT_ALLOCATED);
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: getNextWord
* Signature: (JI)I
*/
JNIEXPORT jint JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_getNextWord
(JNIEnv *env, jclass obj, jlong wnnWork, jint length)
{
NJ_JNIWORK* work;
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
if( work->flag & NJ_JNI_FLAG_ENABLE_CURSOR ) {
jint result;
/* Get a specified word and search a next word */
if( length <= 0 ) {
result = ( jint )njx_get_word( &( work->wnnClass ), &( work->cursor ), &( work->result ) );
} else {
do {
result = ( jint )njx_get_word( &( work->wnnClass ), &( work->cursor ), &( work->result ) );
if( length == ( NJ_GET_YLEN_FROM_STEM( &( work->result.word ) ) + NJ_GET_YLEN_FROM_FZK( &( work->result.word ) ) ) ) {
break;
}
} while( result > 0 );
}
/* If a result is found, enable getStroke, getCandidate, getFrequency methods */
if( result > 0 ) {
work->flag |= NJ_JNI_FLAG_ENABLE_RESULT;
} else {
work->flag &= ~NJ_JNI_FLAG_ENABLE_RESULT;
}
return result;
} else {
/* When njx_search_word() was not yet called, return "No result is found" */
return 0;
}
}
/* If the internal work area was already released, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_GET_WORD, NJ_ERR_NOT_ALLOCATED);
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: getStroke
* Signature: (J)Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_getStroke
(JNIEnv *env, jobject obj, jlong wnnWork)
{
NJ_JNIWORK* work;
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
jstring str;
if( work->flag & NJ_JNI_FLAG_ENABLE_RESULT ) {
NJ_CHAR stroke[ NJ_MAX_LEN + NJ_TERM_LEN ];
if( njx_get_stroke( &( work->wnnClass ), &( work->result ), stroke, sizeof( NJ_CHAR ) * ( NJ_MAX_LEN + NJ_TERM_LEN ) ) >= 0 &&
convertNjCharToString( env, &str, stroke, NJ_MAX_LEN ) >= 0 ) {
return str;
}
} else {
/* When njx_get_word() was not yet called, return "No result is found" */
if( convertNjCharToString( env, &str, ( NJ_CHAR* )"\x00\x00", NJ_MAX_LEN ) >= 0 ) {
return str;
}
}
}
/* If the internal work area was already released, return an error status */
return NULL;
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: getCandidate
* Signature: (J)Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_getCandidate
(JNIEnv *env, jobject obj, jlong wnnWork)
{
NJ_JNIWORK* work;
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
jstring str;
if( work->flag & NJ_JNI_FLAG_ENABLE_RESULT ) {
NJ_CHAR candidate[ NJ_MAX_LEN + NJ_TERM_LEN ];
if( njx_get_candidate( &( work->wnnClass ), &( work->result ), candidate, sizeof( NJ_CHAR ) * ( NJ_MAX_RESULT_LEN + NJ_TERM_LEN ) ) >= 0 &&
convertNjCharToString( env, &str, candidate, NJ_MAX_RESULT_LEN ) >= 0 ) {
return str;
}
} else {
/* When njx_get_word() was not yet called, return "No result is found" */
if( convertNjCharToString( env, &str, ( NJ_CHAR* )"\x00\x00", NJ_MAX_RESULT_LEN ) >= 0 ) {
return str;
}
}
}
/* If the internal work area was already released, return an error status */
return NULL;
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: getFrequency
* Signature: (J)I
*/
JNIEXPORT jint JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_getFrequency
(JNIEnv *env, jobject obj, jlong wnnWork)
{
NJ_JNIWORK* work;
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
if( work->flag & NJ_JNI_FLAG_ENABLE_RESULT ) {
return ( jint )( work->result.word.stem.hindo );
} else {
/* When njx_get_word() was not yet called, return "No result is found" */
return 0;
}
}
/* If the internal work area was already released, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_GET_FREQUENCY, NJ_ERR_NOT_ALLOCATED);
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: clearApproxPatterns
* Signature: (J)V
*/
JNIEXPORT void JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_clearApproxPatterns
(JNIEnv *env, jobject obj, jlong wnnWork)
{
NJ_JNIWORK* work;
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
int i;
/* Clear state */
work->flag = NJ_JNI_FLAG_NONE;
/* Clear approximate patterns */
work->approxSet.charset_count = 0;
for( i = 0 ; i < NJ_MAX_CHARSET ; i++ ) {
work->approxSet.from[ i ] = NULL;
work->approxSet.to[ i ] = NULL;
}
/* Clear the cache information */
memset( work->dicSet.keyword, 0x00, sizeof( work->dicSet.keyword ) );
}
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: setApproxPattern
* Signature: (JLjava/lang/String;Ljava/lang/String;)I
*/
JNIEXPORT jint JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_setApproxPattern__JLjava_lang_String_2Ljava_lang_String_2
(JNIEnv *env, jobject obj, jlong wnnWork, jstring srcJ, jstring dstJ)
{
NJ_JNIWORK* work;
if( srcJ == NULL || ( *env )->GetStringLength( env, srcJ ) == 0 || ( *env )->GetStringLength( env, srcJ ) > 1 ||
dstJ == NULL || ( *env )->GetStringLength( env, dstJ ) == 0 || ( *env )->GetStringLength( env, dstJ ) > 3 ) {
/* If a invalid parameter was specified, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SET_APPROX_PATTERN, NJ_ERR_INVALID_PARAM);
}
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
if( work->approxSet.charset_count < NJ_MAX_CHARSET ) {
NJ_CHAR* from;
NJ_CHAR* to;
/* Set pointers of string to store approximate informations */
from = work->approxStr + NJ_APPROXSTORE_SIZE * work->approxSet.charset_count;
to = work->approxStr + NJ_APPROXSTORE_SIZE * work->approxSet.charset_count + NJ_MAX_CHARSET_FROM_LEN + NJ_TERM_LEN;
work->approxSet.from[ work->approxSet.charset_count ] = from;
work->approxSet.to[ work->approxSet.charset_count ] = to;
/* Convert approximate informations to internal format */
if( convertStringToNjChar( env, from, srcJ, NJ_MAX_CHARSET_FROM_LEN ) >= 0 &&
convertStringToNjChar( env, to, dstJ, NJ_MAX_CHARSET_TO_LEN ) >= 0 ) {
work->approxSet.charset_count++;
/* Reset search state because the seach condition was changed */
work->flag = NJ_JNI_FLAG_NONE;
return 0;
}
/* If converting informations failed, reset pointers, and return an error code */
work->approxSet.from[ work->approxSet.charset_count ] = NULL;
work->approxSet.to[ work->approxSet.charset_count ] = NULL;
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SET_APPROX_PATTERN, NJ_ERR_INTERNAL);
}
/* If the approx pattern registration area was full, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SET_APPROX_PATTERN, NJ_ERR_APPROX_PATTERN_IS_FULL);
}
/* If the internal work area was already released, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SET_APPROX_PATTERN, NJ_ERR_NOT_ALLOCATED);
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: setApproxPattern
* Signature: (JI)I
*/
JNIEXPORT jint JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_setApproxPattern__JI
(JNIEnv *env, jclass obj, jlong wnnWork, jint approxPattern)
{
NJ_JNIWORK *work;
if( !( approxPattern == jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_APPROX_PATTERN_EN_TOUPPER ||
approxPattern == jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_APPROX_PATTERN_EN_TOLOWER ||
approxPattern == jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_APPROX_PATTERN_EN_QWERTY_NEAR ||
approxPattern == jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_APPROX_PATTERN_EN_QWERTY_NEAR_UPPER ||
approxPattern == jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_APPROX_PATTERN_JAJP_12KEY_NORMAL ) ) {
/* If a invalid parameter was specified, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SET_APPROX_PATTERN, NJ_ERR_INVALID_PARAM);
}
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
const PREDEF_APPROX_PATTERN* pattern;
pattern = predefinedApproxPatterns[ approxPattern ];
if( work->approxSet.charset_count + pattern->size <= NJ_MAX_CHARSET ) {
int i;
for( i = 0 ; i < pattern->size ; i++ ) {
NJ_CHAR* from;
NJ_CHAR* to;
/* Set pointers of string to store approximate informations */
from = work->approxStr + NJ_APPROXSTORE_SIZE * ( work->approxSet.charset_count + i );
to = work->approxStr + NJ_APPROXSTORE_SIZE * ( work->approxSet.charset_count + i ) + NJ_MAX_CHARSET_FROM_LEN + NJ_TERM_LEN;
work->approxSet.from[ work->approxSet.charset_count + i ] = from;
work->approxSet.to[ work->approxSet.charset_count + i ] = to;
/* Set approximate pattern */
from[ 0 ] = convertUTFCharToNjChar( pattern->from + i * 2 ); /* "2" means the size of UTF-16BE */
from[ 1 ] = 0x0000;
to[ 0 ] = convertUTFCharToNjChar( pattern->to + i * 2 ); /* "2" means the size of UTF-16BE */
to[ 1 ] = 0x0000;
}
work->approxSet.charset_count += pattern->size;
/* Reset search state because the seach condition was changed */
work->flag = NJ_JNI_FLAG_NONE;
return 0;
}
/* If the approx pattern registration area was full, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SET_APPROX_PATTERN, NJ_ERR_APPROX_PATTERN_IS_FULL);
}
/* If the internal work area was already released, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SET_APPROX_PATTERN, NJ_ERR_NOT_ALLOCATED);
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: getLeftPartOfSpeech
* Signature: (J)I
*/
JNIEXPORT jint JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_getLeftPartOfSpeech
(JNIEnv *env, jclass obj, jlong wnnWork)
{
NJ_JNIWORK* work;
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
return NJ_GET_FPOS_FROM_STEM( &( work->result.word ) );
}
/* If the internal work area was already released, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_GET_LEFT_PART_OF_SPEECH, NJ_ERR_NOT_ALLOCATED);
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: getRightPartOfSpeech
* Signature: (J)I
*/
JNIEXPORT jint JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_getRightPartOfSpeech
(JNIEnv *env, jclass obj, jlong wnnWork)
{
NJ_JNIWORK* work;
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
return NJ_GET_BPOS_FROM_STEM( &( work->result.word ) );
}
/* If the internal work area was already released, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_GET_RIGHT_PART_OF_SPEECH, NJ_ERR_NOT_ALLOCATED);
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: clearResult
* Signature: (J)V
*/
JNIEXPORT void JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_clearResult
(JNIEnv *env, jclass obj, jlong wnnWork)
{
NJ_JNIWORK* work;
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
/* Clear the current word information */
memset( &( work->result ), 0x00, sizeof( NJ_RESULT ) );
memset( &( work->previousStroke ), 0x00, sizeof( work->previousStroke ) );
memset( &( work->previousCandidate ), 0x00, sizeof( work->previousCandidate ) );
}
/* In this method, No error reports. */
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: setLeftPartOfSpeech
* Signature: (JI)I
*/
JNIEXPORT jint JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_setLeftPartOfSpeech
(JNIEnv *env, jclass obj, jlong wnnWork, jint leftPartOfSpeech)
{
NJ_JNIWORK* work;
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
NJ_UINT16 lcount = 0, rcount = 0;
if( work->dicSet.rHandle[ NJ_MODE_TYPE_HENKAN ] == NULL ) {
/* No rule dictionary was set */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SET_LEFT_PART_OF_SPEECH, NJ_ERR_NO_RULEDIC);
}
njd_r_get_count( work->dicSet.rHandle[ NJ_MODE_TYPE_HENKAN ], &lcount, &rcount );
if( leftPartOfSpeech < 1 || leftPartOfSpeech > lcount ) {
/* If a invalid parameter was specified, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SET_LEFT_PART_OF_SPEECH, NJ_ERR_INVALID_PARAM);
}
NJ_SET_FPOS_TO_STEM( &( work->result.word ), leftPartOfSpeech );
return 0;
}
/* If the internal work area was already released, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SET_LEFT_PART_OF_SPEECH, NJ_ERR_NOT_ALLOCATED);
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: setRightPartOfSpeech
* Signature: (JI)I
*/
JNIEXPORT jint JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_setRightPartOfSpeech
(JNIEnv *env, jclass obj, jlong wnnWork, jint rightPartOfSpeech)
{
NJ_JNIWORK* work;
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
NJ_UINT16 lcount = 0, rcount = 0;
if( work->dicSet.rHandle[ NJ_MODE_TYPE_HENKAN ] == NULL ) {
/* No rule dictionary was set */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SET_RIGHT_PART_OF_SPEECH, NJ_ERR_NO_RULEDIC);
}
njd_r_get_count( work->dicSet.rHandle[ NJ_MODE_TYPE_HENKAN ], &lcount, &rcount );
if( rightPartOfSpeech < 1 || rightPartOfSpeech > rcount ) {
/* If a invalid parameter was specified, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SET_RIGHT_PART_OF_SPEECH, NJ_ERR_INVALID_PARAM);
}
NJ_SET_BPOS_TO_STEM( &( work->result.word ), rightPartOfSpeech );
return 0;
}
/* If the internal work area was already released, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SET_RIGHT_PART_OF_SPEECH, NJ_ERR_NOT_ALLOCATED);
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: setStroke
* Signature: (JLjava/lang/String;)I
*/
JNIEXPORT jint JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_setStroke
(JNIEnv *env, jclass obj, jlong wnnWork, jstring stroke)
{
NJ_JNIWORK* work;
if( stroke == NULL ) {
/* If a invalid parameter was specified, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SET_STROKE, NJ_ERR_INVALID_PARAM);
}
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
if( ( *env )->GetStringLength( env, stroke ) > NJ_MAX_LEN ) {
/* If a invalid parameter was specified, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SET_STROKE, NJ_ERR_YOMI_TOO_LONG);
}
/* Store stroke string */
if( convertStringToNjChar( env, work->previousStroke, stroke, NJ_MAX_LEN ) >= 0 ) {
return 0;
}
/* If converting the string failed, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SET_STROKE, NJ_ERR_INTERNAL);
}
/* If the internal work area was already released, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SET_STROKE, NJ_ERR_NOT_ALLOCATED);
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: setCandidate
* Signature: (JLjava/lang/String;)I
*/
JNIEXPORT jint JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_setCandidate
(JNIEnv *env, jclass obj, jlong wnnWork, jstring candidate)
{
NJ_JNIWORK* work;
if( candidate == NULL ) {
/* If a invalid parameter was specified, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SET_CANDIDATE, NJ_ERR_INVALID_PARAM);
}
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
if( ( *env )->GetStringLength( env, candidate ) > NJ_MAX_RESULT_LEN ) {
/* If a invalid parameter was specified, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SET_CANDIDATE, NJ_ERR_CANDIDATE_TOO_LONG);
}
/* Store candidate string */
if( convertStringToNjChar( env, work->previousCandidate, candidate, NJ_MAX_RESULT_LEN ) >= 0 ) {
return 0;
}
/* If converting the string failed, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SET_CANDIDATE, NJ_ERR_INTERNAL);
}
/* If the internal work area was already released, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SET_CANDIDATE, NJ_ERR_NOT_ALLOCATED);
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: selectWord
* Signature: (J)I
*/
JNIEXPORT jint JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_selectWord
(JNIEnv *env, jclass obj, jlong wnnWork)
{
NJ_JNIWORK* work;
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
/* Put the previous word information to engine */
memcpy( &( work->wnnClass.dic_set ), &( work->dicSet ), sizeof( NJ_DIC_SET ) );
return ( jint )njx_select( &( work->wnnClass ), &( work->result ) );
}
/* If the internal work area was already released, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_SELECT_WORD, NJ_ERR_NOT_ALLOCATED);
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: getLeftPartOfSpeechSpecifiedType
* Signature: (JI)I
*/
JNIEXPORT jint JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_getLeftPartOfSpeechSpecifiedType
(JNIEnv *env, jclass obj, jlong wnnWork, jint type)
{
NJ_JNIWORK* work;
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
switch( type ) {
case jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_POS_TYPE_V1:
type = NJ_HINSI_V1_F;
break;
case jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_POS_TYPE_V2:
type = NJ_HINSI_V2_F;
break;
case jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_POS_TYPE_V3:
type = NJ_HINSI_V3_F;
break;
case jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_POS_TYPE_BUNTOU:
/* No part of speech is defined at this type */
return 0;
case jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_POS_TYPE_TANKANJI:
type = NJ_HINSI_TANKANJI_F;
break;
case jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_POS_TYPE_SUUJI:
/* No part of speech is defined at this type */
return 0;
case jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_POS_TYPE_MEISI:
type = NJ_HINSI_MEISI_F;
break;
case jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_POS_TYPE_JINMEI:
type = NJ_HINSI_JINMEI_F;
break;
case jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_POS_TYPE_CHIMEI:
type = NJ_HINSI_CHIMEI_F;
break;
case jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_POS_TYPE_KIGOU:
type = NJ_HINSI_KIGOU_F;
break;
default:
/* If a invalid parameter was specified, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_GET_LEFT_PART_OF_SPEECH_SPECIFIED_TYPE, NJ_ERR_INVALID_PARAM);
}
return ( jint )njd_r_get_hinsi( work->dicSet.rHandle[ NJ_MODE_TYPE_HENKAN ], type );
}
/* If the internal work area was already released, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_GET_LEFT_PART_OF_SPEECH_SPECIFIED_TYPE, NJ_ERR_NOT_ALLOCATED);
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: getRightPartOfSpeechSpecifiedType
* Signature: (JI)I
*/
JNIEXPORT jint JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_getRightPartOfSpeechSpecifiedType
(JNIEnv *env, jclass obj, jlong wnnWork, jint type)
{
NJ_JNIWORK* work;
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
switch( type ) {
case jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_POS_TYPE_V1:
/* No part of speech is defined at this type */
return 0;
case jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_POS_TYPE_V2:
/* No part of speech is defined at this type */
return 0;
case jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_POS_TYPE_V3:
/* No part of speech is defined at this type */
return 0;
case jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_POS_TYPE_BUNTOU:
type = NJ_HINSI_BUNTOU_B;
break;
case jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_POS_TYPE_TANKANJI:
type = NJ_HINSI_TANKANJI_B;
break;
case jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_POS_TYPE_SUUJI:
type = NJ_HINSI_SUUJI_B;
break;
case jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_POS_TYPE_MEISI:
type = NJ_HINSI_MEISI_B;
break;
case jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_POS_TYPE_JINMEI:
type = NJ_HINSI_JINMEI_B;
break;
case jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_POS_TYPE_CHIMEI:
type = NJ_HINSI_CHIMEI_B;
break;
case jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_POS_TYPE_KIGOU:
type = NJ_HINSI_KIGOU_B;
break;
default:
/* If a invalid parameter was specified, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_GET_LEFT_PART_OF_SPEECH_SPECIFIED_TYPE, NJ_ERR_INVALID_PARAM);
}
return ( jint )njd_r_get_hinsi( work->dicSet.rHandle[ NJ_MODE_TYPE_HENKAN ], type );
}
/* If the internal work area was already released, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_GET_RIGHT_PART_OF_SPEECH_SPECIFIED_TYPE, NJ_ERR_NOT_ALLOCATED);
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: getConnectArray
* Signature: (JI)[B
*/
JNIEXPORT jbyteArray JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_getConnectArray
(JNIEnv *env, jclass obj, jlong wnnWork, jint leftPartOfSpeech)
{
NJ_JNIWORK* work;
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
NJ_UINT16 lcount = 0, rcount = 0;
jbyteArray resultJ;
if( work->dicSet.rHandle[ NJ_MODE_TYPE_HENKAN ] == NULL ) {
/* No rule dictionary was set */
return NULL;
}
njd_r_get_count( work->dicSet.rHandle[ NJ_MODE_TYPE_HENKAN ], &lcount, &rcount );
if( leftPartOfSpeech < 0 || leftPartOfSpeech > lcount ) {
/* Invalid POS is specified */
return NULL;
}
/* 1-origin */
resultJ = ( *env )->NewByteArray( env, rcount + 1 );
if( resultJ != NULL ) {
jbyte *result;
result = ( *env )->GetByteArrayElements( env, resultJ, NULL );
if( result != NULL ) {
int i;
NJ_UINT8* connect;
if( leftPartOfSpeech == 0 ) {
for( i = 0 ; i < rcount + 1 ; i++ ) {
result[ i ] = 0;
}
} else {
/* Get the packed connect array */
njd_r_get_connect( work->dicSet.rHandle[ NJ_MODE_TYPE_HENKAN ], leftPartOfSpeech, NJ_RULE_TYPE_FTOB, &connect );
/* Extract connect array from bit field */
result[ 0 ] = 0;
for( i = 0 ; i < rcount ; i++ ) {
if( connect[ i / 8 ] & (0x80 >> (i % 8))) {
result[ i + 1 ] = 1;
} else {
result[ i + 1 ] = 0;
}
}
}
( *env )->ReleaseByteArrayElements( env, resultJ, result, 0 );
return resultJ;
}
}
/* If allocating the return area failed, return an error code */
return NULL;
}
/* If the internal work area was already released, return an error code */
return NULL;
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: getNumberOfLeftPOS
* Signature: (J)I
*/
JNIEXPORT jint JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_getNumberOfLeftPOS
(JNIEnv *env, jclass obj, jlong wnnWork)
{
NJ_JNIWORK* work;
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
if( work->dicSet.rHandle[ NJ_MODE_TYPE_HENKAN ] == NULL ) {
/* No rule dictionary was set */
return 0;
} else {
NJ_UINT16 lcount = 0, rcount = 0;
njd_r_get_count( work->dicSet.rHandle[ NJ_MODE_TYPE_HENKAN ], &lcount, &rcount );
return lcount;
}
}
/* If the internal work area was already released, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_GET_NUMBER_OF_LEFT_POS, NJ_ERR_NOT_ALLOCATED);
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: getNumberOfRightPOS
* Signature: (J)I
*/
JNIEXPORT jint JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_getNumberOfRightPOS
(JNIEnv *env, jclass obj, jlong wnnWork)
{
NJ_JNIWORK* work;
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
if( work->dicSet.rHandle[ NJ_MODE_TYPE_HENKAN ] == NULL ) {
/* No rule dictionary was set */
return 0;
} else {
NJ_UINT16 lcount = 0, rcount = 0;
njd_r_get_count( work->dicSet.rHandle[ NJ_MODE_TYPE_HENKAN ], &lcount, &rcount );
return rcount;
}
}
/* If the internal work area was already released, return an error code */
return NJ_SET_ERR_VAL(NJ_FUNC_JNI_GET_NUMBER_OF_RIGHT_POS, NJ_ERR_NOT_ALLOCATED);
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: getApproxPattern
* Signature: (JLjava/lang/String;)[Ljava/lang/String;
*/
JNIEXPORT jobjectArray JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_getApproxPattern
(JNIEnv *env, jclass obj, jlong wnnWork, jstring srcJ)
{
NJ_JNIWORK* work;
if( srcJ == NULL || ( *env )->GetStringLength( env, srcJ ) == 0 || ( *env )->GetStringLength( env, srcJ ) > 1 ) {
/* If a invalid parameter was specified, return an error code */
return NULL;
}
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
int i, outIndex, outCount;
NJ_CHAR from[ NJ_MAX_CHARSET_FROM_LEN + NJ_TERM_LEN ];
if( convertStringToNjChar( env, from, srcJ, NJ_MAX_CHARSET_FROM_LEN ) >= 0 ) {
outCount = 0;
for( i = 0 ; i < work->approxSet.charset_count ; i++ ) {
if( nj_strcmp( from, work->approxSet.from[ i ] ) == 0 ) {
outCount++;
}
}
jclass strC = ( *env )->FindClass( env, "java/lang/String" );
if( strC != NULL ) {
jobjectArray retJ = ( *env )->NewObjectArray( env, outCount, strC, NULL );
if( retJ != NULL ) {
for( i = outIndex = 0 ; i < work->approxSet.charset_count ; i++ ) {
if( nj_strcmp( from, work->approxSet.from[ i ] ) == 0 ) {
jstring dstJ;
if( convertNjCharToString( env, &dstJ, work->approxSet.to[ i ], NJ_MAX_CHARSET_TO_LEN ) < 0 ) {
return NULL;
}
( *env )->SetObjectArrayElement( env, retJ, outIndex++, dstJ );
}
}
return retJ;
}
}
}
/* If the internal error occured, return an error code */
return NULL;
}
/* If the internal work area was already released, return an error code */
return NULL;
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: createBindArray
* Signature: (JLjava/lang/String;II)[Ljava/lang/String;
*/
JNIEXPORT jobjectArray JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_createBindArray
(JNIEnv *env, jclass obj, jlong wnnWork, jstring keyStringJ, jint maxBindsOfQuery, jint maxPatternOfApprox)
{
NJ_JNIWORK* work;
if( keyStringJ == NULL ) {
/* If a invalid parameter was specified, return an error code */
return NULL;
}
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
/* create the string array for result */
jclass strC = ( *env )->FindClass( env, "java/lang/String" );
if( strC != NULL ) {
jobjectArray retJ = ( *env )->NewObjectArray( env, maxBindsOfQuery * (maxPatternOfApprox+1), strC, NULL );
if( retJ != NULL ) {
NJ_CHAR keyString[ NJ_MAX_LEN + NJ_TERM_LEN ];
if( convertStringToNjChar( env, keyString, keyStringJ, NJ_MAX_LEN ) >= 0 ) {
int queryLen, outIndex, approxPattern;
NJ_CHAR baseStr[ NJ_MAX_LEN + NJ_MAX_CHARSET_TO_LEN + NJ_TERM_LEN ];
outIndex = 0;
baseStr[ 0 ] = NJ_CHAR_NUL;
for( queryLen = 0 ; queryLen < maxBindsOfQuery && keyString[ queryLen ] != NJ_CHAR_NUL ; queryLen++ ) {
int i;
for( i = -1, approxPattern = -1 ; i < work->approxSet.charset_count ; i++ ) {
if( i == -1 || keyString[ queryLen ] == work->approxSet.from[ i ][ 0 ] ) {
int tailOffset = 0;
if( i == -1 ) {
if( *( ( NJ_UINT8* )( &keyString[ queryLen ] ) + 0 ) == 0x00 &&
( *( ( NJ_UINT8* )( &keyString[ queryLen ] ) + 1 ) == 0x25 || /* '%' */
*( ( NJ_UINT8* )( &keyString[ queryLen ] ) + 1 ) == 0x5c || /* '\' */
*( ( NJ_UINT8* )( &keyString[ queryLen ] ) + 1 ) == 0x5f ) ) { /* '_' */
*( ( NJ_UINT8* )( &baseStr[ queryLen + 0 ] ) + 0 ) = 0x00;
*( ( NJ_UINT8* )( &baseStr[ queryLen + 0 ] ) + 1 ) = 0x5c; /* '\' */
baseStr[ queryLen + 1 ] = keyString[ queryLen ];
tailOffset = 2;
} else {
baseStr[ queryLen + 0 ] = keyString[ queryLen ];
tailOffset = 1;
}
} else {
nj_strcpy( &baseStr[ queryLen ], work->approxSet.to[ i ] );
tailOffset = nj_strlen( work->approxSet.to[ i ] );
}
*( ( NJ_UINT8* )( &baseStr[ queryLen + tailOffset ] ) + 0 ) = 0x00;
*( ( NJ_UINT8* )( &baseStr[ queryLen + tailOffset ] ) + 1 ) = 0x25; /* '%' */
baseStr[ queryLen + tailOffset + 1 ] = NJ_CHAR_NUL;
jstring dstJ;
if( convertNjCharToString( env, &dstJ, baseStr, NJ_MAX_LEN ) < 0 ) {
return NULL;
}
( *env )->SetObjectArrayElement( env, retJ, outIndex++, dstJ );
approxPattern++;
}
}
for( ; approxPattern < maxPatternOfApprox ; approxPattern++ ) {
jstring dstJ = ( *env )->NewStringUTF( env, "" );
if( dstJ == NULL ) {
return NULL;
}
( *env )->SetObjectArrayElement( env, retJ, outIndex++, dstJ );
}
*( ( NJ_UINT8* )( &baseStr[ queryLen ] ) + 0 ) = 0x00;
*( ( NJ_UINT8* )( &baseStr[ queryLen ] ) + 1 ) = 0x5f; /* '_' */
baseStr[ queryLen + 1 ] = NJ_CHAR_NUL;
}
for( ; queryLen < maxBindsOfQuery ; queryLen++ ) {
for( approxPattern = -1 ; approxPattern < maxPatternOfApprox ; approxPattern++ ) {
jstring dstJ = ( *env )->NewStringUTF( env, "%" );
if( dstJ == NULL ) {
return NULL;
}
( *env )->SetObjectArrayElement( env, retJ, outIndex++, dstJ );
}
}
return retJ;
}
}
}
/* If the internal error occured, return an error code */
return NULL;
}
/* If the internal work area was already released, return an error code */
return NULL;
}
/*
* Class: jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni
* Method: createQueryStringBase
* Signature: (JIILjava/lang/String;)Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL Java_jp_co_omronsoft_openwnn_OpenWnnDictionaryImplJni_createQueryStringBase
(JNIEnv *env, jclass obj, jlong wnnWork, jint maxBindsOfQuery, jint maxPatternOfApprox, jstring keyColumnNameJ)
{
NJ_JNIWORK* work;
jstring retJ = NULL;
if( keyColumnNameJ == NULL ) {
/* If a invalid parameter was specified, return an error code */
return NULL;
}
work = *( NJ_JNIWORK** )&wnnWork;
if( work != NULL ) {
const unsigned char* keyName = ( const unsigned char* )( ( *env )->GetStringUTFChars( env, keyColumnNameJ, NULL ) );
if( keyName != NULL ) {
int keyLength = strlen( ( char* )keyName );
char *dst = ( char* )malloc( maxBindsOfQuery * ( ( 1 + keyLength + 18 + 1 + 5 ) +
( ( 4 + keyLength + 18 ) * maxPatternOfApprox ) +
1 ) );
if( dst != NULL ) {
int queryLen, dstPtr;
for( queryLen = dstPtr = 0 ; queryLen < maxBindsOfQuery ; queryLen++ ) {
int approxPattern;
strcpy( &dst[ dstPtr ], "(" );
strcpy( &dst[ dstPtr + 1 ], ( char* )keyName );
strcpy( &dst[ dstPtr + 1 + keyLength ], " like ? escape '\x5c'" );
dstPtr += 1 + keyLength + 18;
for( approxPattern = 0 ; approxPattern < maxPatternOfApprox ; approxPattern++ ) {
strcpy( &dst[ dstPtr ], " or " );
strcpy( &dst[ dstPtr + 4 ], ( char* )keyName );
strcpy( &dst[ dstPtr + 4 + keyLength ], " like ? escape '\x5c'" );
dstPtr += 4 + keyLength + 18;
}
strcpy( &dst[ dstPtr ], ")" );
dstPtr++;
if( queryLen != maxBindsOfQuery-1 ) {
strcpy( &dst[ dstPtr ], " and " );
dstPtr += 5;
}
}
dst[ dstPtr ] = '\0';
retJ = ( *env )->NewStringUTF( env, dst );
free( dst );
}
( *env )->ReleaseStringUTFChars( env, keyColumnNameJ, ( const char* )keyName );
}
}
return retJ;
}