/*
* 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 "nj_lib.h"
#include "nj_err.h"
#include "nj_ext.h"
#include "nj_dic.h"
#include "njd.h"
#define NJ_DIC_UNCOMP_EXT_HEADER_SIZE 0x002C
#define CREATE_DIC_TYPE_USER 0
#define GET_HYOKI_INDEX_OFFSET(cnt) \
(NJ_LEARN_DIC_HEADER_SIZE + NJ_INDEX_SIZE * ((cnt)+1))
#define GET_DATA_AREA_OFFSET(cnt) \
(NJ_LEARN_DIC_HEADER_SIZE + NJ_INDEX_SIZE * ((cnt)+1) * 2)
#define GET_EXT_DATA_AREA_OFFSET(cnt) \
(NJ_LEARN_DIC_HEADER_SIZE + NJ_INDEX_SIZE * ((cnt)+1) * 2 + LEARN_DIC_QUE_SIZE * (cnt))
#define MIN_SIZE_OF_USER_DIC \
(NJ_LEARN_DIC_HEADER_SIZE + NJ_USER_QUE_SIZE + 2 * (NJ_INDEX_SIZE * (1+1)) + 4)
#define GET_MAX_WORD_NUM_IN_USER_DIC(size) \
(((size) - NJ_LEARN_DIC_HEADER_SIZE - (2 * NJ_INDEX_SIZE) - 4) \
/ (NJ_USER_QUE_SIZE + 2 * NJ_INDEX_SIZE))
static NJ_INT16 check_search_cursor(NJ_CLASS *iwnn, NJ_CURSOR *cursor);
static NJ_INT16 search_word(NJ_CLASS *iwnn, NJ_CURSOR *cursor, NJ_UINT8 comp_flg, NJ_UINT8 *exit_flag);
static void set_operation_id(NJ_SEARCH_LOCATION *dicinfo, NJ_UINT8 reverse, NJ_RESULT *result);
static NJ_INT16 get_word_and_search_next_word(NJ_CLASS *iwnn, NJ_CURSOR *cursor, NJ_RESULT *result, NJ_UINT8 comp_flg);
static NJ_INT16 njd_check_dic(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle);
static NJ_INT16 check_search_cursor(NJ_CLASS *iwnn, NJ_CURSOR *cursor) {
NJ_UINT16 i;
NJ_DIC_INFO *dicinfo;
NJ_SEARCH_LOCATION_SET *loctset;
if (cursor->cond.ds == NULL) {
return NJ_SET_ERR_VAL(NJ_FUNC_CHECK_SEARCH_CURSOR, NJ_ERR_PARAM_DIC_NULL);
}
for (i = 0; i < NJ_MAX_DIC; i++) {
loctset = &(cursor->loctset[i]);
dicinfo = &(cursor->cond.ds->dic[i]);
njd_init_search_location_set(loctset);
if (dicinfo->handle != NULL) {
if (
(dicinfo->dic_freq[NJ_MODE_TYPE_HENKAN].high > DIC_FREQ_HIGH) ) {
return NJ_SET_ERR_VAL(NJ_FUNC_CHECK_SEARCH_CURSOR, NJ_ERR_DIC_FREQ_INVALID);
}
loctset->loct.handle = dicinfo->handle;
loctset->loct.type = dicinfo->type;
loctset->loct.current_info = 0x10;
loctset->loct.status = NJ_ST_SEARCH_NO_INIT;
loctset->dic_freq = dicinfo->dic_freq[NJ_MODE_TYPE_HENKAN];
}
}
if (cursor->cond.yomi == NULL) {
return NJ_SET_ERR_VAL(NJ_FUNC_CHECK_SEARCH_CURSOR, NJ_ERR_PARAM_YOMI_NULL);
}
if (cursor->cond.ylen > NJ_MAX_LEN) {
return NJ_SET_ERR_VAL(NJ_FUNC_CHECK_SEARCH_CURSOR, NJ_ERR_YOMI_TOO_LONG);
}
if (cursor->cond.operation == NJ_CUR_OP_LINK) {
} else if (cursor->cond.kanji != NULL) {
if (nj_strlen(cursor->cond.kanji) > NJ_MAX_RESULT_LEN) {
return NJ_SET_ERR_VAL(NJ_FUNC_CHECK_SEARCH_CURSOR, NJ_ERR_CANDIDATE_TOO_LONG);
}
}
switch (cursor->cond.operation) {
case NJ_CUR_OP_COMP:
case NJ_CUR_OP_FORE:
case NJ_CUR_OP_LINK:
break;
default:
return NJ_SET_ERR_VAL(NJ_FUNC_CHECK_SEARCH_CURSOR, NJ_ERR_PARAM_OPERATION);
}
switch (cursor->cond.mode) {
case NJ_CUR_MODE_FREQ:
case NJ_CUR_MODE_YOMI:
break;
default:
return NJ_SET_ERR_VAL(NJ_FUNC_CHECK_SEARCH_CURSOR, NJ_ERR_PARAM_MODE);
}
return 0;
}
static NJ_INT16 search_word(NJ_CLASS *iwnn, NJ_CURSOR *cursor, NJ_UINT8 comp_flg,
NJ_UINT8 *exit_flag) {
NJ_UINT32 dic_type;
NJ_INT16 i;
NJ_INT16 ret = 0;
NJ_INT16 flag = 0;
NJ_SEARCH_LOCATION_SET *loctset;
*exit_flag = 1;
for (i = 0; i < NJ_MAX_DIC; i++) {
loctset = &(cursor->loctset[i]);
if (loctset->loct.handle == NULL) {
continue;
}
dic_type = NJ_GET_DIC_TYPE_EX(loctset->loct.type, loctset->loct.handle);
#ifdef IWNN_ERR_CHECK
if (iwnn->err_check_flg == 12) {
dic_type = 0x11111111;
}
#endif
switch (dic_type) {
case NJ_DIC_TYPE_JIRITSU:
case NJ_DIC_TYPE_FZK:
case NJ_DIC_TYPE_TANKANJI:
case NJ_DIC_TYPE_STDFORE:
case NJ_DIC_TYPE_CUSTOM_COMPRESS:
case NJ_DIC_TYPE_FORECONV:
ret = njd_b_search_word(&cursor->cond, loctset);
break;
case NJ_DIC_TYPE_USER:
case NJ_DIC_TYPE_CUSTOM_INCOMPRESS:
ret = njd_l_search_word(iwnn, &cursor->cond, loctset, comp_flg);
break;
case NJ_DIC_TYPE_YOMINASHI:
ret = njd_f_search_word(&cursor->cond, loctset);
break;
default:
return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_WORD, NJ_ERR_DIC_TYPE_INVALID);
}
if (ret < 0) {
return ret;
}
if (ret == 0) {
if ((GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_END)
&& (*exit_flag == 1)) {
*exit_flag = 0;
}
loctset->loct.status = NJ_ST_SEARCH_END;
} else {
flag = 1;
*exit_flag = 0;
}
}
return flag;
}
static NJ_INT16 get_word_and_search_next_word(NJ_CLASS *iwnn, NJ_CURSOR *cursor, NJ_RESULT *result,
NJ_UINT8 comp_flg) {
NJ_INT16 ret = -1;
NJ_INT32 i, next, first;
NJ_WORD tmp_word;
NJ_RESULT tmp_result;
NJ_CHAR tmp_stroke[NJ_MAX_LEN + NJ_TERM_LEN];
NJ_CHAR result_stroke[NJ_MAX_LEN + NJ_TERM_LEN];
NJ_INT32 j, max_len = 0;
NJ_UINT32 dic_type;
NJ_SEARCH_LOCATION_SET *loctset;
next = -1;
first= 0;
njd_init_word(&tmp_word);
result->word = tmp_word;
tmp_result.word = tmp_word;
for (i = 0; i < NJ_MAX_DIC; i++) {
loctset = &(cursor->loctset[i]);
if ((loctset->loct.handle == NULL) ||
(GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_END) ||
(GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_END_EXT)) {
continue;
}
dic_type = NJ_GET_DIC_TYPE_EX(loctset->loct.type, loctset->loct.handle);
switch (dic_type) {
case NJ_DIC_TYPE_JIRITSU:
case NJ_DIC_TYPE_FZK:
case NJ_DIC_TYPE_TANKANJI:
case NJ_DIC_TYPE_STDFORE:
case NJ_DIC_TYPE_CUSTOM_COMPRESS:
case NJ_DIC_TYPE_FORECONV:
tmp_word.yomi = cursor->cond.yomi;
tmp_word.stem.info1 = cursor->cond.ylen;
tmp_result.word.yomi = cursor->cond.yomi;
tmp_result.word.stem.info1 = cursor->cond.ylen;
break;
default:
break;
}
loctset->loct.status |= SET_LOCATION_OPERATION(cursor->cond.operation);
if (cursor->cond.mode == NJ_CUR_MODE_FREQ) {
if ((cursor->cond.ds->mode & (NJ_CACHE_MODE_VALID)) &&
(cursor->cond.ds->dic[i].srhCache != NULL) &&
(NJ_GET_AIMAI_FROM_SCACHE(cursor->cond.ds->dic[i].srhCache)) &&
(cursor->cond.operation == NJ_CUR_OP_FORE)) {
first = 1;
ret = njd_get_word_data(iwnn, cursor->cond.ds, loctset, (NJ_UINT16)i, &tmp_result.word);
if (ret < 0) {
return ret;
}
ret = njd_get_stroke(iwnn, &tmp_result, tmp_stroke, sizeof(tmp_stroke));
if (ret <= 0) {
if ((ret == 0) || (NJ_GET_ERR_CODE(ret) == NJ_ERR_BUFFER_NOT_ENOUGH)) {
return NJ_SET_ERR_VAL(NJ_FUNC_GET_WORD_AND_SEARCH_NEXT_WORD, NJ_ERR_INVALID_RESULT);
} else {
return ret;
}
}
for (j = 0; j < cursor->cond.ylen; j++) {
if (cursor->cond.yomi[j] != tmp_stroke[j]) {
break;
}
}
switch (dic_type) {
case NJ_DIC_TYPE_JIRITSU:
case NJ_DIC_TYPE_FZK:
case NJ_DIC_TYPE_TANKANJI:
case NJ_DIC_TYPE_STDFORE:
case NJ_DIC_TYPE_CUSTOM_COMPRESS:
case NJ_DIC_TYPE_FORECONV:
ret = njd_b_search_word(&cursor->cond, loctset);
break;
case NJ_DIC_TYPE_USER:
case NJ_DIC_TYPE_CUSTOM_INCOMPRESS:
ret = njd_l_search_word(iwnn, &cursor->cond, loctset, comp_flg);
break;
default:
return NJ_SET_ERR_VAL(NJ_FUNC_GET_WORD_AND_SEARCH_NEXT_WORD, NJ_ERR_DIC_TYPE_INVALID);
}
if (ret < 0) {
return ret;
}
} else {
ret = njd_get_word_data(iwnn, cursor->cond.ds, loctset, (NJ_UINT16)i, &tmp_result.word);
if (ret < 0) {
return ret;
}
j = cursor->cond.ylen;
}
if ((j > max_len) ||
((j == max_len) && (loctset->cache_freq > result->word.stem.hindo)) ||
(next == -1)) {
set_operation_id(&(loctset->loct), 0, result);
result->word = tmp_result.word;
next = i;
max_len = j;
}
} else {
ret = njd_get_word_data(iwnn, cursor->cond.ds, loctset, (NJ_UINT16)i, &(tmp_result.word));
if (ret < 0) {
return ret;
}
ret = njd_get_stroke(iwnn, &tmp_result, tmp_stroke, sizeof(tmp_stroke));
if (ret <= 0) {
if ((ret == 0) || (NJ_GET_ERR_CODE(ret) == NJ_ERR_BUFFER_NOT_ENOUGH)) {
return NJ_SET_ERR_VAL(NJ_FUNC_GET_WORD_AND_SEARCH_NEXT_WORD, NJ_ERR_INVALID_RESULT);
} else {
return ret;
}
}
if ((next == -1) || (nj_strcmp(result_stroke, tmp_stroke) > 0)) {
set_operation_id(&(loctset->loct), 0, result);
result->word = tmp_result.word;
next = i;
nj_strcpy(result_stroke, tmp_stroke);
}
}
}
if (next == -1) {
return 0;
}
loctset = &(cursor->loctset[next]);
if ((!first) ||
((loctset->loct.handle != NULL) &&
(cursor->cond.ds->dic[next].srhCache == NULL))) {
dic_type = NJ_GET_DIC_TYPE_EX(loctset->loct.type, loctset->loct.handle);
switch (dic_type) {
case NJ_DIC_TYPE_JIRITSU:
case NJ_DIC_TYPE_FZK:
case NJ_DIC_TYPE_TANKANJI:
case NJ_DIC_TYPE_STDFORE:
case NJ_DIC_TYPE_CUSTOM_COMPRESS:
case NJ_DIC_TYPE_FORECONV:
ret = njd_b_search_word(&cursor->cond, loctset);
break;
case NJ_DIC_TYPE_USER:
case NJ_DIC_TYPE_CUSTOM_INCOMPRESS:
ret = njd_l_search_word(iwnn, &cursor->cond, loctset, comp_flg);
break;
case NJ_DIC_TYPE_YOMINASHI:
ret = njd_f_search_word(&cursor->cond, loctset);
break;
default:
return NJ_SET_ERR_VAL(NJ_FUNC_GET_WORD_AND_SEARCH_NEXT_WORD, NJ_ERR_DIC_TYPE_INVALID);
}
}
if (ret < 0) {
return ret;
}
return 1;
}
NJ_INT16 njd_get_word_data(NJ_CLASS *iwnn, NJ_DIC_SET *dicset, NJ_SEARCH_LOCATION_SET *loctset, NJ_UINT16 dic_idx, NJ_WORD *word) {
NJ_INT16 ret = 0;
NJ_UINT32 dic_type;
if (GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_END) {
return 0;
}
if (loctset->loct.handle == NULL) {
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_GET_WORD_DATA, NJ_ERR_DIC_TYPE_INVALID);
}
dic_type = NJ_GET_DIC_TYPE_EX(loctset->loct.type, loctset->loct.handle);
switch (dic_type) {
case NJ_DIC_TYPE_JIRITSU:
case NJ_DIC_TYPE_FZK:
case NJ_DIC_TYPE_TANKANJI:
case NJ_DIC_TYPE_STDFORE:
case NJ_DIC_TYPE_CUSTOM_COMPRESS:
case NJ_DIC_TYPE_FORECONV:
ret = njd_b_get_word(loctset, word);
break;
case NJ_DIC_TYPE_USER:
case NJ_DIC_TYPE_CUSTOM_INCOMPRESS:
ret = njd_l_get_word(iwnn, loctset, word);
break;
case NJ_DIC_TYPE_YOMINASHI:
ret = njd_f_get_word(loctset, word);
break;
default:
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_GET_WORD_DATA, NJ_ERR_DIC_TYPE_INVALID);
}
return ret;
}
static void set_operation_id(NJ_SEARCH_LOCATION *dicinfo, NJ_UINT8 reverse, NJ_RESULT *result) {
NJ_UINT16 dictype;
NJ_UINT32 type;
if (dicinfo->handle == NULL) {
dictype = NJ_DIC_STATIC;
return;
}
type = NJ_GET_DIC_TYPE_EX(NJ_GET_DIC_INFO(dicinfo), dicinfo->handle);
switch (type) {
case NJ_DIC_TYPE_JIRITSU:
case NJ_DIC_TYPE_FZK:
case NJ_DIC_TYPE_TANKANJI:
case NJ_DIC_TYPE_STDFORE:
case NJ_DIC_TYPE_YOMINASHI:
case NJ_DIC_TYPE_FORECONV:
dictype = NJ_DIC_STATIC;
break;
case NJ_DIC_TYPE_CUSTOM_INCOMPRESS:
case NJ_DIC_TYPE_CUSTOM_COMPRESS:
dictype = NJ_DIC_CUSTOMIZE;
break;
case NJ_DIC_TYPE_USER:
dictype = NJ_DIC_USER;
break;
default:
dictype = NJ_DIC_STATIC;
}
result->operation_id =
(NJ_UINT16)((NJ_UINT16)NJ_OP_SEARCH | (NJ_UINT16)NJ_FUNC_SEARCH | dictype);
}
static NJ_INT16 njd_search_word(NJ_CLASS *iwnn, NJ_CURSOR *cursor, NJ_UINT8 comp_flg,
NJ_UINT8 *exit_flag) {
NJ_INT16 ret;
ret = check_search_cursor(iwnn, cursor);
if (ret != 0) {
return ret;
}
return search_word(iwnn, cursor, comp_flg, exit_flag);
}
static NJ_INT16 njd_get_word(NJ_CLASS *iwnn, NJ_CURSOR *cursor, NJ_RESULT *result,
NJ_UINT8 comp_flg) {
NJ_INT16 ret;
ret = get_word_and_search_next_word(iwnn, cursor, result, comp_flg);
return ret;
}
NJ_INT16 njd_get_stroke(NJ_CLASS *iwnn, NJ_RESULT *result, NJ_CHAR *stroke, NJ_UINT16 size) {
NJ_INT16 ret = 0;
NJ_UINT16 len;
NJ_UINT32 dictype;
if (result->word.stem.loc.handle == NULL) {
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_GET_STROKE, NJ_ERR_INVALID_RESULT);
}
dictype = NJ_GET_DIC_TYPE_EX(result->word.stem.loc.type, result->word.stem.loc.handle);
switch (dictype) {
case NJ_DIC_TYPE_JIRITSU:
case NJ_DIC_TYPE_FZK:
case NJ_DIC_TYPE_TANKANJI:
case NJ_DIC_TYPE_STDFORE:
case NJ_DIC_TYPE_CUSTOM_COMPRESS:
case NJ_DIC_TYPE_FORECONV:
if (GET_LOCATION_OPERATION(result->word.stem.loc.status) != NJ_CUR_OP_COMP) {
ret = njd_b_get_stroke(&result->word, stroke, size);
} else {
len = NJ_GET_YLEN_FROM_STEM(&result->word);
if (size < ((len + NJ_TERM_LEN) * sizeof(NJ_CHAR))) {
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_GET_STROKE,
NJ_ERR_BUFFER_NOT_ENOUGH);
}
if (len == 0) {
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_GET_STROKE,
NJ_ERR_INVALID_RESULT);
}
nj_strncpy(stroke, result->word.yomi, len);
*(stroke + len) = NJ_CHAR_NUL;
return len;
}
break;
case NJ_DIC_TYPE_USER:
case NJ_DIC_TYPE_CUSTOM_INCOMPRESS:
ret = njd_l_get_stroke(iwnn, &result->word, stroke, size);
break;
case NJ_DIC_TYPE_YOMINASHI:
ret = njd_f_get_stroke(&result->word, stroke, size);
break;
default:
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_GET_STROKE, NJ_ERR_DIC_TYPE_INVALID);
}
if (ret == 0) {
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_GET_STROKE, NJ_ERR_INVALID_RESULT);
}
return ret;
}
NJ_INT16 njd_get_candidate(NJ_CLASS *iwnn, NJ_RESULT *result,
NJ_CHAR *candidate, NJ_UINT16 size) {
NJ_INT16 ret = 0;
NJ_UINT32 dictype;
if (result->word.stem.loc.handle == NULL) {
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_GET_CANDIDATE, NJ_ERR_INVALID_RESULT);
}
dictype = NJ_GET_DIC_TYPE_EX(result->word.stem.loc.type, result->word.stem.loc.handle);
switch (dictype) {
case NJ_DIC_TYPE_JIRITSU:
case NJ_DIC_TYPE_FZK:
case NJ_DIC_TYPE_TANKANJI:
case NJ_DIC_TYPE_STDFORE:
case NJ_DIC_TYPE_CUSTOM_COMPRESS:
case NJ_DIC_TYPE_FORECONV:
ret = njd_b_get_candidate(&result->word, candidate, size);
break;
case NJ_DIC_TYPE_USER:
case NJ_DIC_TYPE_CUSTOM_INCOMPRESS:
ret = njd_l_get_candidate(iwnn, &result->word, candidate, size);
break;
case NJ_DIC_TYPE_YOMINASHI:
ret = njd_f_get_candidate(&result->word, candidate, size);
break;
default:
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_GET_CANDIDATE, NJ_ERR_DIC_TYPE_INVALID);
}
if (ret == 0) {
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_GET_CANDIDATE, NJ_ERR_INVALID_RESULT);
}
return ret;
}
static NJ_INT16 njd_check_dic(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle) {
NJ_UINT8 *addr;
NJ_UINT32 datasize, extsize;
NJ_UINT32 version;
NJ_UINT32 type;
addr = handle;
if (NJ_INT32_READ(addr) != NJ_DIC_IDENTIFIER) {
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_CHECK_DIC, NJ_ERR_FORMAT_INVALID);
}
addr += sizeof(NJ_UINT32);
version = NJ_INT32_READ(addr);
if ((version != NJ_DIC_VERSION1) && (version != NJ_DIC_VERSION2) &&
(version != NJ_DIC_VERSION2_1) && (version != NJ_DIC_VERSION3)) {
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_CHECK_DIC, NJ_ERR_FORMAT_INVALID);
}
addr += sizeof(NJ_UINT32);
type = NJ_INT32_READ(addr);
addr += sizeof(NJ_UINT32);
datasize = NJ_INT32_READ(addr);
addr += sizeof(NJ_UINT32);
extsize = NJ_INT32_READ(addr);
addr += sizeof(NJ_UINT32);
if (NJ_INT32_READ(addr) > (NJ_MAX_LEN * sizeof(NJ_CHAR))) {
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_CHECK_DIC, NJ_ERR_FORMAT_INVALID);
}
addr += sizeof(NJ_UINT32);
if (NJ_INT32_READ(addr) > (NJ_MAX_RESULT_LEN * sizeof(NJ_CHAR))) {
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_CHECK_DIC, NJ_ERR_FORMAT_INVALID);
}
addr += (extsize + datasize);
if (NJ_INT32_READ(addr) != NJ_DIC_IDENTIFIER) {
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_CHECK_DIC, NJ_ERR_FORMAT_INVALID);
}
switch (type) {
case NJ_DIC_TYPE_JIRITSU:
case NJ_DIC_TYPE_FZK:
case NJ_DIC_TYPE_TANKANJI:
case NJ_DIC_TYPE_CUSTOM_COMPRESS:
case NJ_DIC_TYPE_STDFORE:
if (version != (NJ_UINT32)NJ_DIC_VERSION2) {
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_CHECK_DIC, NJ_ERR_FORMAT_INVALID);
}
break;
case NJ_DIC_TYPE_RULE:
if (version != (NJ_UINT32)NJ_DIC_VERSION2_1) {
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_CHECK_DIC, NJ_ERR_FORMAT_INVALID);
}
break;
case NJ_DIC_TYPE_YOMINASHI:
if (version != (NJ_UINT32)NJ_DIC_VERSION1) {
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_CHECK_DIC, NJ_ERR_FORMAT_INVALID);
}
break;
case NJ_DIC_TYPE_USER:
if (version != (NJ_UINT32)NJ_DIC_VERSION2) {
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_CHECK_DIC, NJ_ERR_FORMAT_INVALID);
}
return njd_l_check_dic(iwnn, handle);
default:
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_CHECK_DIC, NJ_ERR_DIC_TYPE_INVALID);
}
return 0;
}
NJ_EXTERN NJ_INT16 njx_search_word(NJ_CLASS *iwnn, NJ_CURSOR *cursor) {
NJ_SEARCH_CACHE *pCache;
NJ_CHAR *p_yomi, *p_key;
NJ_UINT16 initst, inited;
NJ_UINT16 clrcnt, diccnt;
NJ_UINT16 kw_len;
NJ_UINT16 cacheOverKeyPtr;
NJ_UINT8 exit_flag;
NJ_UINT8 cnt;
NJ_DIC_HANDLE dhdl;
NJ_PREVIOUS_SELECTION_INFO *prev_info = &(iwnn->previous_selection);
if (iwnn == NULL) {
return NJ_SET_ERR_VAL(NJ_FUNC_NJ_SEARCH_WORD, NJ_ERR_PARAM_ENV_NULL);
}
if (cursor == NULL) {
return NJ_SET_ERR_VAL(NJ_FUNC_NJ_SEARCH_WORD, NJ_ERR_PARAM_CURSOR_NULL);
}
cursor->cond.hinsi.fore = NULL;
cursor->cond.hinsi.foreSize = 0;
cursor->cond.hinsi.foreFlag = 0;
cursor->cond.hinsi.rear = NULL;
cursor->cond.hinsi.rearSize = 0;
cursor->cond.hinsi.rearFlag = 0;
if (cursor->cond.yomi == NULL) {
return NJ_SET_ERR_VAL(NJ_FUNC_CHECK_SEARCH_CURSOR, NJ_ERR_PARAM_YOMI_NULL);
}
cursor->cond.ylen = nj_strlen(cursor->cond.yomi);
cursor->cond.yclen = nj_charlen(cursor->cond.yomi);
if (cursor->cond.ds == NULL) {
return NJ_SET_ERR_VAL(NJ_FUNC_CHECK_SEARCH_CURSOR, NJ_ERR_PARAM_DIC_NULL);
}
cursor->cond.ds->mode = NJ_CACHE_MODE_VALID;
p_yomi = cursor->cond.yomi;
p_key = cursor->cond.ds->keyword;
for (clrcnt = 0; clrcnt < cursor->cond.yclen; clrcnt++) {
if (nj_charncmp(p_yomi, p_key, 1) != 0) {
break;
}
p_yomi += NJ_CHAR_LEN(p_yomi);
p_key += NJ_CHAR_LEN(p_key);
}
if (clrcnt != 0) {
initst = clrcnt + 1;
} else {
initst = 0;
}
kw_len = nj_charlen(cursor->cond.ds->keyword);
if (kw_len >= cursor->cond.yclen) {
inited = kw_len + 1;
} else {
inited = cursor->cond.yclen + 1;
}
for (diccnt = 0; diccnt < NJ_MAX_DIC; diccnt++) {
pCache = cursor->cond.ds->dic[diccnt].srhCache;
if (pCache != NULL) {
if (NJ_GET_CACHEOVER_FROM_SCACHE(pCache)) {
for (cacheOverKeyPtr = 0; cacheOverKeyPtr < kw_len; cacheOverKeyPtr++) {
if (pCache->keyPtr[cacheOverKeyPtr] == pCache->keyPtr[cacheOverKeyPtr + 1] ) {
break;
}
}
cacheOverKeyPtr++;
if (cacheOverKeyPtr < initst) {
clrcnt = cacheOverKeyPtr;
} else {
clrcnt = initst;
}
for (; clrcnt < inited; clrcnt++) {
pCache->keyPtr[clrcnt] = 0x0000;
}
for (clrcnt = 1; clrcnt < inited; clrcnt++ ) {
if ((pCache->keyPtr[clrcnt - 1] > pCache->keyPtr[clrcnt]) &&
(pCache->keyPtr[clrcnt] != 0)) {
return NJ_SET_ERR_VAL(NJ_FUNC_CHECK_SEARCH_CURSOR, NJ_ERR_CACHE_BROKEN);
}
}
NJ_UNSET_CACHEOVER_TO_SCACHE(pCache);
} else {
for (clrcnt = initst; clrcnt < inited; clrcnt++) {
pCache->keyPtr[clrcnt] = 0x0000;
}
for (clrcnt = 1; clrcnt < inited; clrcnt++ ) {
if ((pCache->keyPtr[clrcnt - 1] > pCache->keyPtr[clrcnt]) &&
(pCache->keyPtr[clrcnt] != 0)) {
return NJ_SET_ERR_VAL(NJ_FUNC_CHECK_SEARCH_CURSOR, NJ_ERR_CACHE_BROKEN);
}
}
}
}
}
nj_strcpy(cursor->cond.ds->keyword, cursor->cond.yomi);
for (cnt = 0; cnt < NJ_MAX_DIC; cnt++) {
dhdl = cursor->cond.ds->dic[cnt].handle;
if (dhdl != NULL) {
if ((cursor->cond.ds->dic[cnt].dic_freq[NJ_MODE_TYPE_HENKAN].base
> cursor->cond.ds->dic[cnt].dic_freq[NJ_MODE_TYPE_HENKAN].high)) {
return NJ_SET_ERR_VAL(NJ_FUNC_CHECK_SEARCH_CURSOR, NJ_ERR_DIC_FREQ_INVALID);
}
}
}
if( prev_info->count == 0 ) {
cursor->cond.hinsi.yominasi_fore = NULL;
} else {
int prev_hinsi = prev_info->selection_data.b_hinsi;
njd_r_get_connect(cursor->cond.ds->rHandle[NJ_MODE_TYPE_HENKAN], prev_hinsi,
0, &(cursor->cond.hinsi.yominasi_fore));
njd_r_get_count(cursor->cond.ds->rHandle[NJ_MODE_TYPE_HENKAN],
&(cursor->cond.hinsi.foreSize), &(cursor->cond.hinsi.rearSize));
}
return njd_search_word(iwnn, cursor, 0, &exit_flag);
}
NJ_EXTERN NJ_INT16 njx_get_word(NJ_CLASS *iwnn, NJ_CURSOR *cursor, NJ_RESULT *result) {
NJ_INT16 ret;
if (iwnn == NULL) {
return NJ_SET_ERR_VAL(NJ_FUNC_NJ_GET_WORD, NJ_ERR_PARAM_ENV_NULL);
}
if (cursor == NULL) {
return NJ_SET_ERR_VAL(NJ_FUNC_NJ_GET_WORD, NJ_ERR_PARAM_CURSOR_NULL);
}
if (result == NULL) {
return NJ_SET_ERR_VAL(NJ_FUNC_NJ_GET_WORD, NJ_ERR_PARAM_RESULT_NULL);
}
ret = njd_get_word(iwnn, cursor, result, 0);
return ret;
}
NJ_EXTERN NJ_INT16 njx_check_dic(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT8 restore, NJ_UINT32 size) {
if (iwnn == NULL) {
return NJ_SET_ERR_VAL(NJ_FUNC_NJ_CHECK_DIC, NJ_ERR_PARAM_ENV_NULL);
}
if (handle == NULL) {
return NJ_SET_ERR_VAL(NJ_FUNC_NJ_CHECK_DIC, NJ_ERR_DIC_HANDLE_NULL);
}
if (size <= NJ_DIC_COMMON_HEADER_SIZE) {
return NJ_SET_ERR_VAL(NJ_FUNC_NJ_CHECK_DIC, NJ_ERR_AREASIZE_INVALID);
}
if (size != (NJ_DIC_COMMON_HEADER_SIZE
+ NJ_INT32_READ(handle + NJ_DIC_POS_DATA_SIZE)
+ NJ_INT32_READ(handle + NJ_DIC_POS_EXT_SIZE))) {
return NJ_SET_ERR_VAL(NJ_FUNC_NJ_CHECK_DIC, NJ_ERR_AREASIZE_INVALID);
}
return njd_check_dic(iwnn, handle);
}
NJ_INT16 njd_init_search_location_set(NJ_SEARCH_LOCATION_SET* loctset)
{
loctset->cache_freq = 0;
loctset->dic_freq.base = 0;
loctset->dic_freq.high = 0;
loctset->loct.type = NJ_DIC_H_TYPE_NORMAL;
loctset->loct.handle = NULL;
loctset->loct.current_info = 0x10;
loctset->loct.current = 0;
loctset->loct.top = 0;
loctset->loct.bottom = 0;
loctset->loct.current_cache = 0;
loctset->loct.status = NJ_ST_SEARCH_NO_INIT;
return 1;
}
NJ_INT16 njd_init_word(NJ_WORD* word)
{
word->yomi = NULL;
word->stem.info1 = 0;
word->stem.info2 = 0;
word->stem.hindo = 0;
word->fzk.info1 = 0;
word->fzk.info2 = 0;
word->fzk.hindo = 0;
word->stem.loc.handle = NULL;
word->stem.loc.type = NJ_DIC_H_TYPE_NORMAL;
word->stem.loc.current = 0;
word->stem.loc.top = 0;
word->stem.loc.bottom = 0;
word->stem.loc.current_cache= 0;
word->stem.loc.current_info = 0x10;
word->stem.loc.status = NJ_ST_SEARCH_NO_INIT;
return 1;
}