2428 lines
72 KiB
C
2428 lines
72 KiB
C
/*
|
|
* 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"
|
|
#ifdef NJ_LEARN_MUHENKAN_DEBUG
|
|
#include <stdio.h>
|
|
#include <def_mojicode.h>
|
|
#endif
|
|
#ifdef NJ_AWNN22_DEBUG
|
|
#include <stdio.h>
|
|
#include <def_mojicode.h>
|
|
#endif
|
|
|
|
#define QUE_TYPE_EMPTY 0
|
|
#define QUE_TYPE_NEXT 0
|
|
#define QUE_TYPE_JIRI 1
|
|
#define QUE_TYPE_FZK 2
|
|
#define POS_DATA_OFFSET 0x20
|
|
#define POS_LEARN_WORD 0x24
|
|
#define POS_MAX_WORD 0x28
|
|
#define POS_QUE_SIZE 0x2C
|
|
#define POS_NEXT_QUE 0x30
|
|
#define POS_WRITE_FLG 0x34
|
|
#define POS_INDEX_OFFSET 0x3C
|
|
#define POS_INDEX_OFFSET2 0x40
|
|
|
|
#define LEARN_INDEX_TOP_ADDR(x) ((x) + (NJ_INT32_READ((x) + POS_INDEX_OFFSET)))
|
|
#define LEARN_INDEX_TOP_ADDR2(x) ((x) + (NJ_INT32_READ((x) + POS_INDEX_OFFSET2)))
|
|
#define LEARN_DATA_TOP_ADDR(x) ((x) + (NJ_INT32_READ((x) + POS_DATA_OFFSET)))
|
|
|
|
#define LEARN_INDEX_BOTTOM_ADDR(x) (LEARN_DATA_TOP_ADDR(x) - 1)
|
|
|
|
#define LEARN_QUE_STRING_OFFSET 5
|
|
|
|
#define ADDRESS_TO_POS(x,adr) (((adr) - LEARN_DATA_TOP_ADDR(x)) / QUE_SIZE(x))
|
|
#define POS_TO_ADDRESS(x,pos) (LEARN_DATA_TOP_ADDR(x) + QUE_SIZE(x) * (pos))
|
|
|
|
#define GET_UINT16(ptr) ((((NJ_UINT16)(*(ptr))) << 8) | (*((ptr) + 1) & 0x00ff))
|
|
|
|
#define GET_FPOS_FROM_DATA(x) ((NJ_UINT16)NJ_INT16_READ((x)+1) >> 7)
|
|
#define GET_YSIZE_FROM_DATA(x) ((NJ_UINT8)((NJ_UINT16)NJ_INT16_READ((x)+1) & 0x7F))
|
|
#define GET_BPOS_FROM_DATA(x) ((NJ_UINT16)NJ_INT16_READ((x)+3) >> 7)
|
|
#define GET_KSIZE_FROM_DATA(x) ((NJ_UINT8)((NJ_UINT16)NJ_INT16_READ((x)+3) & 0x7F))
|
|
#define GET_BPOS_FROM_EXT_DATA(x) ((NJ_UINT16)NJ_INT16_READ(x) >> 7)
|
|
#define GET_YSIZE_FROM_EXT_DATA(x) ((NJ_UINT8)((NJ_UINT16)NJ_INT16_READ(x) & 0x7F))
|
|
|
|
#define SET_BPOS_AND_YSIZE(x,bpos,ysize) \
|
|
NJ_INT16_WRITE((x), ((NJ_UINT16)((bpos) << 7) | ((ysize) & 0x7F)))
|
|
#define SET_FPOS_AND_YSIZE(x,fpos,ysize) \
|
|
NJ_INT16_WRITE(((x)+1), ((NJ_UINT16)((fpos) << 7) | ((ysize) & 0x7F)))
|
|
#define SET_BPOS_AND_KSIZE(x,bpos,ksize) \
|
|
NJ_INT16_WRITE(((x)+3), ((NJ_UINT16)((bpos) << 7) | ((ksize) & 0x7F)))
|
|
|
|
#define GET_TYPE_FROM_DATA(x) (*(x) & 0x03)
|
|
#define GET_UFLG_FROM_DATA(x) (*(x) >> 7)
|
|
#define GET_FFLG_FROM_DATA(x) ((*(x) >> 6) & 0x01)
|
|
#define GET_MFLG_FROM_DATA(x) (*(x) & 0x10)
|
|
|
|
#define SET_TYPE_UFLG_FFLG(x,type,u,f) \
|
|
(*(x) = (NJ_UINT8)(((type) & 0x03) | \
|
|
(((u) & 0x01) << 7) | (((f) & 0x01) << 6)))
|
|
#define SET_TYPE_ALLFLG(x,type,u,f,m) \
|
|
(*(x) = (NJ_UINT8)(((type) & 0x03) | \
|
|
(((u) & 0x01) << 7) | (((f) & 0x01) << 6) | (((m) & 0x01) << 4)))
|
|
|
|
#define RESET_FFLG(x) (*(x) &= 0xbf)
|
|
|
|
#define STATE_COPY(to, from) \
|
|
{ ((NJ_UINT8*)(to))[0] = ((NJ_UINT8*)(from))[0]; \
|
|
((NJ_UINT8*)(to))[1] = ((NJ_UINT8*)(from))[1]; \
|
|
((NJ_UINT8*)(to))[2] = ((NJ_UINT8*)(from))[2]; \
|
|
((NJ_UINT8*)(to))[3] = ((NJ_UINT8*)(from))[3]; }
|
|
|
|
#define USE_QUE_NUM(que_size, str_size) \
|
|
( (((str_size) % ((que_size) - 1)) == 0) \
|
|
? ((str_size) / ((que_size) - 1)) \
|
|
: ((str_size) / ((que_size) - 1) + 1) )
|
|
|
|
#define NEXT_QUE(que, max) ( ((que) < ((max) - 1)) ? ((que) + 1) : 0 )
|
|
|
|
#define PREV_QUE(que, max) ( ((que) == 0) ? ((max) - 1) : ((que) - 1) )
|
|
|
|
#define COPY_QUE(handle, src, dst) \
|
|
nj_memcpy(POS_TO_ADDRESS((handle), (dst)), POS_TO_ADDRESS((handle), (src)), QUE_SIZE(handle))
|
|
|
|
|
|
#define INIT_HINDO (-10000)
|
|
|
|
#define LOC_CURRENT_NO_ENTRY 0xffffffffU
|
|
|
|
|
|
|
|
static NJ_WQUE *get_que(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT16 que_id);
|
|
static NJ_INT16 is_continued(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT16 que_id);
|
|
static NJ_UINT16 search_next_que(NJ_DIC_HANDLE handle, NJ_UINT16 que_id);
|
|
static NJ_INT16 que_strcmp_complete_with_hyouki(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT16 que_id, NJ_CHAR *yomi, NJ_UINT16 yomi_len, NJ_CHAR *hyouki, NJ_UINT8 multi_flg);
|
|
static NJ_CHAR *get_string(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT16 que_id, NJ_UINT8 *slen);
|
|
static NJ_CHAR *get_hyouki(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT16 que_id, NJ_UINT8 *slen);
|
|
static NJ_INT16 get_cand_by_sequential(NJ_CLASS *iwnn, NJ_SEARCH_CONDITION *cond, NJ_SEARCH_LOCATION_SET *loctset, NJ_UINT8 search_pattern, NJ_UINT8 comp_flg);
|
|
static NJ_INT16 get_cand_by_evaluate(NJ_CLASS *iwnn, NJ_SEARCH_CONDITION *cond, NJ_SEARCH_LOCATION_SET *loctset, NJ_UINT8 search_pattern);
|
|
static NJ_INT16 get_cand_by_evaluate2(NJ_CLASS *iwnn, NJ_SEARCH_CONDITION *cond, NJ_SEARCH_LOCATION_SET *loctset, NJ_UINT8 search_pattern, NJ_UINT16 hIdx);
|
|
static NJ_INT16 search_range_by_yomi(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT8 op, NJ_CHAR *yomi, NJ_UINT16 ylen, NJ_UINT16 *from, NJ_UINT16 *to, NJ_UINT8 *forward_flag);
|
|
static NJ_INT16 search_range_by_yomi2(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT8 op, NJ_CHAR *yomi, NJ_UINT16 ylen, NJ_UINT16 sfrom, NJ_UINT16 sto, NJ_UINT16 *from, NJ_UINT16 *to,
|
|
NJ_UINT8 *forward_flag);
|
|
static NJ_INT16 search_range_by_yomi_multi(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_CHAR *yomi, NJ_UINT16 ylen, NJ_UINT16 *from, NJ_UINT16 *to);
|
|
static NJ_INT16 str_que_cmp(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_CHAR *yomi, NJ_UINT16 yomiLen, NJ_UINT16 que_id, NJ_UINT8 mode);
|
|
static NJ_WQUE *get_que_type_and_next(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT16 que_id);
|
|
static NJ_WQUE *get_que_allHinsi(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT16 que_id);
|
|
static NJ_WQUE *get_que_yomiLen_and_hyoukiLen(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT16 que_id);
|
|
static NJ_INT16 continue_cnt(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT16 que_id);
|
|
|
|
static NJ_UINT8 *get_search_index_address(NJ_DIC_HANDLE handle, NJ_UINT8 search_pattern);
|
|
|
|
static NJ_HINDO get_hindo(NJ_CLASS *iwnn, NJ_SEARCH_LOCATION_SET *loctset, NJ_UINT8 search_pattern);
|
|
|
|
static NJ_HINDO calculate_hindo(NJ_DIC_HANDLE handle, NJ_INT32 freq, NJ_DIC_FREQ *dic_freq, NJ_INT16 freq_max, NJ_INT16 freq_min);
|
|
static NJ_INT16 que_strcmp_include(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT16 que_id, NJ_CHAR *yomi);
|
|
|
|
#define GET_LEARN_MAX_WORD_COUNT(h) ((NJ_UINT16)NJ_INT32_READ((h) + POS_MAX_WORD))
|
|
|
|
#define GET_LEARN_WORD_COUNT(h) \
|
|
((NJ_UINT16)NJ_INT32_READ((h) + POS_LEARN_WORD))
|
|
#define SET_LEARN_WORD_COUNT(h, n) \
|
|
NJ_INT32_WRITE((h)+POS_LEARN_WORD, (NJ_UINT32)(n))
|
|
#define GET_LEARN_NEXT_WORD_POS(h) \
|
|
((NJ_UINT16)NJ_INT32_READ((h) + POS_NEXT_QUE))
|
|
#define SET_LEARN_NEXT_WORD_POS(h, id) \
|
|
NJ_INT32_WRITE((h)+POS_NEXT_QUE, (NJ_UINT32)(id))
|
|
#define QUE_SIZE(h) ((NJ_UINT16)NJ_INT32_READ((h) + POS_QUE_SIZE))
|
|
|
|
#define COPY_UINT16(dst,src) (*(NJ_UINT16 *)(dst) = *(NJ_UINT16 *)(src))
|
|
|
|
static NJ_UINT8 *get_search_index_address(NJ_DIC_HANDLE handle, NJ_UINT8 search_pattern) {
|
|
|
|
|
|
|
|
return LEARN_INDEX_TOP_ADDR(handle);
|
|
}
|
|
|
|
NJ_INT16 njd_l_search_word(NJ_CLASS *iwnn, NJ_SEARCH_CONDITION *con,
|
|
NJ_SEARCH_LOCATION_SET *loctset,
|
|
NJ_UINT8 comp_flg) {
|
|
|
|
NJ_UINT16 word_count;
|
|
NJ_UINT32 type;
|
|
NJ_DIC_INFO *pdicinfo;
|
|
NJ_UINT16 hIdx;
|
|
NJ_INT16 ret;
|
|
|
|
|
|
word_count = GET_LEARN_WORD_COUNT(loctset->loct.handle);
|
|
if (word_count == 0) {
|
|
|
|
loctset->loct.status = NJ_ST_SEARCH_END_EXT;
|
|
return 0;
|
|
}
|
|
|
|
type = NJ_GET_DIC_TYPE_EX(loctset->loct.type, loctset->loct.handle);
|
|
|
|
if (type == NJ_DIC_TYPE_CUSTOM_INCOMPRESS) {
|
|
if ((con->operation == NJ_CUR_OP_COMP) ||
|
|
(con->operation == NJ_CUR_OP_FORE)){
|
|
|
|
if (con->ylen > NJ_GET_MAX_YLEN(loctset->loct.handle)) {
|
|
loctset->loct.status = NJ_ST_SEARCH_END_EXT;
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
switch (con->operation) {
|
|
case NJ_CUR_OP_COMP:
|
|
if (con->mode != NJ_CUR_MODE_FREQ) {
|
|
|
|
loctset->loct.status = NJ_ST_SEARCH_END_EXT;
|
|
break;
|
|
}
|
|
|
|
|
|
return get_cand_by_sequential(iwnn, con, loctset, con->operation, comp_flg);
|
|
|
|
case NJ_CUR_OP_FORE:
|
|
|
|
if (con->mode == NJ_CUR_MODE_YOMI) {
|
|
|
|
return get_cand_by_sequential(iwnn, con, loctset, con->operation, 0);
|
|
} else {
|
|
|
|
|
|
pdicinfo = con->ds->dic;
|
|
for (hIdx = 0; (hIdx < NJ_MAX_DIC) && (pdicinfo->handle != loctset->loct.handle); hIdx++) {
|
|
pdicinfo++;
|
|
}
|
|
|
|
if (hIdx == NJ_MAX_DIC) {
|
|
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
if ((con->ds->dic[hIdx].srhCache == NULL) || (con->ylen == 0) ||
|
|
!(con->ds->mode & 0x0001)) {
|
|
return get_cand_by_evaluate(iwnn, con, loctset, con->operation);
|
|
} else {
|
|
ret = get_cand_by_evaluate2(iwnn, con, loctset, con->operation, hIdx);
|
|
if (ret == NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_CACHE_NOT_ENOUGH)) {
|
|
|
|
NJ_SET_CACHEOVER_TO_SCACHE(con->ds->dic[hIdx].srhCache);
|
|
ret = get_cand_by_evaluate2(iwnn, con, loctset, con->operation, hIdx);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
case NJ_CUR_OP_LINK:
|
|
|
|
if (NJ_GET_DIC_TYPE_EX(loctset->loct.type, loctset->loct.handle) == NJ_DIC_TYPE_USER) {
|
|
|
|
loctset->loct.status = NJ_ST_SEARCH_END_EXT;
|
|
break;
|
|
}
|
|
if (con->mode != NJ_CUR_MODE_FREQ) {
|
|
|
|
loctset->loct.status = NJ_ST_SEARCH_END_EXT;
|
|
break;
|
|
}
|
|
|
|
if (comp_flg == 0) {
|
|
|
|
return get_cand_by_sequential(iwnn, con, loctset, con->operation, 0);
|
|
} else {
|
|
|
|
return get_cand_by_evaluate(iwnn, con, loctset, con->operation);
|
|
}
|
|
|
|
default:
|
|
loctset->loct.status = NJ_ST_SEARCH_END_EXT;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static NJ_WQUE *get_que_type_and_next(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle,
|
|
NJ_UINT16 que_id) {
|
|
NJ_UINT8 *ptr;
|
|
NJ_WQUE *que = &(iwnn->que_tmp);
|
|
|
|
|
|
if (que_id >= GET_LEARN_MAX_WORD_COUNT(handle)) {
|
|
return NULL;
|
|
}
|
|
|
|
ptr = POS_TO_ADDRESS(handle, que_id);
|
|
|
|
que->type = GET_TYPE_FROM_DATA(ptr);
|
|
que->next_flag = GET_FFLG_FROM_DATA(ptr);
|
|
|
|
switch (que->type) {
|
|
case QUE_TYPE_EMPTY:
|
|
case QUE_TYPE_JIRI:
|
|
case QUE_TYPE_FZK:
|
|
return que;
|
|
default:
|
|
break;
|
|
}
|
|
#ifdef LEARN_DEBUG
|
|
printf("FATAL : Illegal que was gotten (que_id=%d)\n", que_id);
|
|
#endif
|
|
return NULL;
|
|
}
|
|
|
|
static NJ_WQUE *get_que_yomiLen_and_hyoukiLen(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle,
|
|
NJ_UINT16 que_id) {
|
|
NJ_UINT8 *ptr;
|
|
NJ_WQUE *que = &(iwnn->que_tmp);
|
|
|
|
|
|
if (que_id >= GET_LEARN_MAX_WORD_COUNT(handle)) {
|
|
return NULL;
|
|
}
|
|
|
|
ptr = POS_TO_ADDRESS(handle, que_id);
|
|
|
|
que->type = GET_TYPE_FROM_DATA(ptr);
|
|
que->yomi_byte = GET_YSIZE_FROM_DATA(ptr);
|
|
que->yomi_len = que->yomi_byte / sizeof(NJ_CHAR);
|
|
que->hyouki_byte = GET_KSIZE_FROM_DATA(ptr);
|
|
que->hyouki_len = que->hyouki_byte / sizeof(NJ_CHAR);
|
|
|
|
switch (que->type) {
|
|
case QUE_TYPE_JIRI:
|
|
case QUE_TYPE_FZK:
|
|
return que;
|
|
default:
|
|
break;
|
|
}
|
|
#ifdef LEARN_DEBUG
|
|
printf("FATAL : Illegal que was gotten (que_id=%d)\n", que_id);
|
|
#endif
|
|
return NULL;
|
|
}
|
|
|
|
static NJ_WQUE *get_que_allHinsi(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle,
|
|
NJ_UINT16 que_id) {
|
|
NJ_UINT8 *ptr;
|
|
NJ_WQUE *que = &(iwnn->que_tmp);
|
|
|
|
|
|
if (que_id >= GET_LEARN_MAX_WORD_COUNT(handle)) {
|
|
return NULL;
|
|
}
|
|
|
|
ptr = POS_TO_ADDRESS(handle, que_id);
|
|
|
|
que->type = GET_TYPE_FROM_DATA(ptr);
|
|
que->mae_hinsi = GET_FPOS_FROM_DATA(ptr);
|
|
que->ato_hinsi = GET_BPOS_FROM_DATA(ptr);
|
|
|
|
switch (que->type) {
|
|
case QUE_TYPE_JIRI:
|
|
case QUE_TYPE_FZK:
|
|
return que;
|
|
default:
|
|
break;
|
|
}
|
|
#ifdef LEARN_DEBUG
|
|
printf("FATAL : Illegal que was gotten (que_id=%d)\n", que_id);
|
|
#endif
|
|
return NULL;
|
|
}
|
|
|
|
static NJ_WQUE *get_que(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT16 que_id) {
|
|
NJ_UINT8 *ptr;
|
|
NJ_WQUE *que = &(iwnn->que_tmp);
|
|
|
|
|
|
if (que_id >= GET_LEARN_MAX_WORD_COUNT(handle)) {
|
|
return NULL;
|
|
}
|
|
|
|
ptr = POS_TO_ADDRESS(handle, que_id);
|
|
|
|
que->entry = que_id;
|
|
que->type = GET_TYPE_FROM_DATA(ptr);
|
|
que->mae_hinsi = GET_FPOS_FROM_DATA(ptr);
|
|
que->ato_hinsi = GET_BPOS_FROM_DATA(ptr);
|
|
que->yomi_byte = GET_YSIZE_FROM_DATA(ptr);
|
|
que->yomi_len = que->yomi_byte / sizeof(NJ_CHAR);
|
|
que->hyouki_byte= GET_KSIZE_FROM_DATA(ptr);
|
|
que->hyouki_len = que->hyouki_byte / sizeof(NJ_CHAR);
|
|
que->next_flag = GET_FFLG_FROM_DATA(ptr);
|
|
|
|
switch (que->type) {
|
|
case QUE_TYPE_JIRI:
|
|
case QUE_TYPE_FZK:
|
|
return que;
|
|
default:
|
|
break;
|
|
}
|
|
#ifdef LEARN_DEBUG
|
|
printf("FATAL : Illegal que was gotten (que_id=%d)\n", que_id);
|
|
#endif
|
|
return NULL;
|
|
}
|
|
|
|
static NJ_INT16 is_continued(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT16 que_id) {
|
|
NJ_WQUE *que;
|
|
NJ_UINT16 i;
|
|
NJ_UINT16 max, end;
|
|
|
|
|
|
max = GET_LEARN_MAX_WORD_COUNT(handle);
|
|
end = GET_LEARN_NEXT_WORD_POS(handle);
|
|
|
|
for (i = 0; i < max; i++) {
|
|
que_id++;
|
|
if (que_id >= GET_LEARN_MAX_WORD_COUNT(handle)) {
|
|
|
|
que_id = 0;
|
|
}
|
|
|
|
|
|
if (que_id == end) {
|
|
|
|
return 0;
|
|
}
|
|
|
|
que = get_que_type_and_next(iwnn, handle, que_id);
|
|
#ifdef IWNN_ERR_CHECK
|
|
if (iwnn->err_check_flg == 1) {
|
|
que = NULL;
|
|
}
|
|
#endif
|
|
if (que == NULL) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_IS_CONTINUED, NJ_ERR_DIC_BROKEN);
|
|
}
|
|
if (que->type != QUE_TYPE_EMPTY) {
|
|
|
|
if (que->next_flag != 0) {
|
|
|
|
return 1;
|
|
} else {
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
static NJ_INT16 continue_cnt(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT16 que_id) {
|
|
NJ_WQUE *que;
|
|
NJ_UINT16 i;
|
|
NJ_UINT16 max, end;
|
|
NJ_INT16 cnt = 0;
|
|
|
|
|
|
max = GET_LEARN_MAX_WORD_COUNT(handle);
|
|
end = GET_LEARN_NEXT_WORD_POS(handle);
|
|
|
|
for (i = 0; i < max; i++) {
|
|
que_id++;
|
|
if (que_id >= max) {
|
|
|
|
que_id = 0;
|
|
}
|
|
|
|
|
|
if (que_id == end) {
|
|
|
|
return cnt;
|
|
}
|
|
|
|
que = get_que_type_and_next(iwnn, handle, que_id);
|
|
if (que == NULL) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_CONTINUE_CNT, NJ_ERR_DIC_BROKEN);
|
|
}
|
|
if (que->type != QUE_TYPE_EMPTY) {
|
|
|
|
if (que->next_flag != 0) {
|
|
|
|
cnt++;
|
|
|
|
|
|
if (cnt >= (NJD_MAX_CONNECT_CNT - 1)) {
|
|
return cnt;
|
|
}
|
|
} else {
|
|
|
|
return cnt;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
static NJ_UINT16 search_next_que(NJ_DIC_HANDLE handle, NJ_UINT16 que_id) {
|
|
NJ_UINT16 max;
|
|
NJ_UINT16 i;
|
|
|
|
|
|
max = GET_LEARN_MAX_WORD_COUNT(handle);
|
|
|
|
for (i = 0; i < max; i++) {
|
|
que_id++;
|
|
if (que_id >= max) {
|
|
|
|
que_id = 0;
|
|
}
|
|
|
|
if (GET_TYPE_FROM_DATA(POS_TO_ADDRESS(handle, que_id)) != QUE_TYPE_EMPTY) {
|
|
|
|
return que_id;
|
|
}
|
|
}
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
static NJ_INT16 que_strcmp_complete_with_hyouki(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle,
|
|
NJ_UINT16 que_id, NJ_CHAR *yomi, NJ_UINT16 yomi_len, NJ_CHAR *hyouki,
|
|
NJ_UINT8 multi_flg) {
|
|
NJ_CHAR *str;
|
|
NJ_INT16 ret;
|
|
NJ_UINT8 slen;
|
|
NJ_UINT16 hyouki_len;
|
|
NJ_UINT16 que_yomilen, que_hyoukilen;
|
|
NJ_INT16 que_count = 1;
|
|
NJ_INT16 cnt = 0;
|
|
|
|
|
|
|
|
hyouki_len = nj_strlen(hyouki);
|
|
|
|
if (multi_flg == 0) {
|
|
|
|
cnt = 1;
|
|
} else {
|
|
|
|
|
|
cnt = GET_LEARN_WORD_COUNT(handle);
|
|
}
|
|
|
|
while (cnt--) {
|
|
str = get_string(iwnn, handle, que_id, &slen);
|
|
if (str == NULL) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_QUE_STRCMP_COMPLETE_WITH_HYOUKI,
|
|
NJ_ERR_DIC_BROKEN);
|
|
}
|
|
que_yomilen = slen;
|
|
|
|
ret = nj_strncmp(yomi, str, que_yomilen);
|
|
if (ret != 0) {
|
|
|
|
return 0;
|
|
}
|
|
|
|
str = get_hyouki(iwnn, handle, que_id, &slen);
|
|
if (str == NULL) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_QUE_STRCMP_COMPLETE_WITH_HYOUKI,
|
|
NJ_ERR_DIC_BROKEN);
|
|
}
|
|
que_hyoukilen = slen;
|
|
|
|
ret = nj_strncmp(hyouki, str, que_hyoukilen);
|
|
if (ret != 0) {
|
|
|
|
return 0;
|
|
}
|
|
|
|
if ((yomi_len == que_yomilen) &&
|
|
(hyouki_len == que_hyoukilen)) {
|
|
|
|
return que_count;
|
|
}
|
|
|
|
if ((que_yomilen > yomi_len) ||
|
|
(que_hyoukilen > hyouki_len)) {
|
|
|
|
return 0;
|
|
}
|
|
|
|
ret = is_continued(iwnn, handle, que_id);
|
|
if (ret <= 0) {
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
if (que_count >= (NJD_MAX_CONNECT_CNT - 1)) {
|
|
|
|
return 0;
|
|
}
|
|
|
|
yomi_len -= que_yomilen;
|
|
yomi += que_yomilen;
|
|
|
|
hyouki_len -= que_hyoukilen;
|
|
hyouki += que_hyoukilen;
|
|
|
|
|
|
que_id = search_next_que(handle, que_id);
|
|
que_count++;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static NJ_INT16 que_strcmp_include(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle,
|
|
NJ_UINT16 que_id, NJ_CHAR *yomi) {
|
|
NJ_CHAR *str;
|
|
NJ_UINT16 que_len;
|
|
NJ_UINT16 yomi_len;
|
|
NJ_INT16 ret;
|
|
NJ_INT16 que_count = 1;
|
|
NJ_UINT16 i = 0;
|
|
NJ_UINT8 slen;
|
|
|
|
|
|
#ifdef LEARN_DEBUG
|
|
printf("que_strcmp_include(que_id=%d, yomi=[%s])\n", que_id, yomi);
|
|
#endif
|
|
yomi_len = nj_strlen(yomi);
|
|
if (yomi_len == 0) {
|
|
return que_count;
|
|
}
|
|
|
|
i = GET_LEARN_WORD_COUNT(handle);
|
|
|
|
while (--i) {
|
|
|
|
|
|
ret = is_continued(iwnn, handle, que_id);
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
} else if (ret == 0) {
|
|
|
|
return que_count;
|
|
}
|
|
|
|
|
|
que_id = search_next_que(handle, que_id);
|
|
|
|
str = get_string(iwnn, handle, que_id, &slen);
|
|
#ifdef IWNN_ERR_CHECK
|
|
if (iwnn->err_check_flg == 2) {
|
|
str = NULL;
|
|
}
|
|
#endif
|
|
if (str == NULL) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_QUE_STRCMP_INCLUDE, NJ_ERR_DIC_BROKEN);
|
|
}
|
|
que_len = slen;
|
|
|
|
|
|
if (que_len > yomi_len) {
|
|
#ifdef LEARN_DEBUG
|
|
printf(" >> mismatch [%s] (que_len > yomi_len)\n", str);
|
|
#endif
|
|
return que_count;
|
|
}
|
|
|
|
|
|
ret = nj_strncmp(yomi, str, que_len);
|
|
if (ret != 0) {
|
|
#ifdef LEARN_DEBUG
|
|
printf(" >> mismatch [%s]\n", str);
|
|
#endif
|
|
|
|
return que_count;
|
|
}
|
|
|
|
|
|
if (que_len == yomi_len) {
|
|
#ifdef LEARN_DEBUG
|
|
printf(" >> match! [%s](%d)\n", str, que_count);
|
|
#endif
|
|
return (que_count + 1);
|
|
}
|
|
|
|
que_count++;
|
|
if (que_count >= NJD_MAX_CONNECT_CNT) {
|
|
|
|
return que_count;
|
|
}
|
|
|
|
|
|
yomi_len -= que_len;
|
|
yomi += que_len;
|
|
}
|
|
|
|
return que_count;
|
|
}
|
|
|
|
static NJ_CHAR *get_string(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle,
|
|
NJ_UINT16 que_id, NJ_UINT8 *slen) {
|
|
NJ_UINT8 *src, *dst;
|
|
NJ_UINT8 copy_size, size;
|
|
NJ_UINT8 i;
|
|
NJ_UINT8 *top_addr;
|
|
NJ_UINT8 *bottom_addr;
|
|
NJ_UINT16 que_size;
|
|
|
|
|
|
src = POS_TO_ADDRESS(handle, que_id);
|
|
switch (GET_TYPE_FROM_DATA(src)) {
|
|
case QUE_TYPE_JIRI:
|
|
case QUE_TYPE_FZK:
|
|
size = GET_YSIZE_FROM_DATA(src);
|
|
*slen = (NJ_UINT8)(size / sizeof(NJ_CHAR));
|
|
break;
|
|
|
|
default:
|
|
#ifdef LEARN_DEBUG
|
|
printf("get_string(handle=%p, que_id=%d) : broken que\n", handle, que_id);
|
|
#endif
|
|
return NULL;
|
|
}
|
|
|
|
if (NJ_GET_DIC_TYPE(handle) == NJ_DIC_TYPE_USER) {
|
|
if (*slen > NJ_MAX_USER_LEN) {
|
|
return NULL;
|
|
}
|
|
} else {
|
|
if (*slen > NJ_MAX_LEN) {
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
|
|
src += LEARN_QUE_STRING_OFFSET;
|
|
|
|
que_size = QUE_SIZE(handle);
|
|
|
|
|
|
copy_size = (NJ_UINT8)que_size - LEARN_QUE_STRING_OFFSET;
|
|
dst = (NJ_UINT8*)&(iwnn->learn_string_tmp[0]);
|
|
if (copy_size > size) {
|
|
|
|
copy_size = size;
|
|
}
|
|
for (i = 0; i < copy_size; i++) {
|
|
*dst++ = *src++;
|
|
}
|
|
|
|
|
|
top_addr = LEARN_DATA_TOP_ADDR(handle);
|
|
bottom_addr = top_addr;
|
|
bottom_addr += que_size * GET_LEARN_MAX_WORD_COUNT(handle) - 1;
|
|
|
|
while (size -= copy_size) {
|
|
|
|
if (src >= bottom_addr) {
|
|
src = top_addr;
|
|
}
|
|
|
|
|
|
if (*src != QUE_TYPE_NEXT) {
|
|
#ifdef LEARN_DEBUG
|
|
printf("FATAL: src que was broken(not QUE_TYPE_NEXT) [src=%x]\n", src);
|
|
#endif
|
|
return NULL;
|
|
}
|
|
|
|
src++;
|
|
if (size < que_size) {
|
|
|
|
copy_size = size;
|
|
} else {
|
|
copy_size = (NJ_UINT8)(que_size - 1);
|
|
}
|
|
for (i = 0; i < copy_size; i++) {
|
|
*dst++ = *src++;
|
|
}
|
|
}
|
|
iwnn->learn_string_tmp[*slen] = NJ_CHAR_NUL;
|
|
|
|
return &(iwnn->learn_string_tmp[0]);
|
|
}
|
|
|
|
static NJ_CHAR *get_hyouki(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle,
|
|
NJ_UINT16 que_id, NJ_UINT8 *slen) {
|
|
NJ_UINT8 *src, *dst;
|
|
NJ_WQUE *que;
|
|
NJ_UINT8 copy_size, size;
|
|
NJ_UINT8 i;
|
|
NJ_UINT8 *top_addr;
|
|
NJ_UINT8 *bottom_addr;
|
|
NJ_CHAR *hira;
|
|
NJ_UINT16 que_size;
|
|
NJ_UINT32 dictype;
|
|
|
|
|
|
que = get_que_yomiLen_and_hyoukiLen(iwnn, handle, que_id);
|
|
if (que == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
dictype = NJ_GET_DIC_TYPE(handle);
|
|
if (dictype == NJ_DIC_TYPE_USER) {
|
|
if (que->yomi_len > NJ_MAX_USER_LEN) {
|
|
return NULL;
|
|
}
|
|
if (que->hyouki_len > NJ_MAX_USER_KOUHO_LEN) {
|
|
return NULL;
|
|
}
|
|
} else {
|
|
if (que->yomi_len > NJ_MAX_LEN) {
|
|
return NULL;
|
|
}
|
|
if (que->hyouki_len > NJ_MAX_RESULT_LEN) {
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
src = POS_TO_ADDRESS(handle, que_id);
|
|
|
|
if (que->hyouki_len == 0) {
|
|
hira = get_string(iwnn, handle, que_id, slen);
|
|
if (hira == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
if (GET_MFLG_FROM_DATA(src) != 0) {
|
|
*slen = (NJ_UINT8)nje_convert_hira_to_kata(hira, &(iwnn->muhenkan_tmp[0]), *slen);
|
|
return &(iwnn->muhenkan_tmp[0]);
|
|
} else {
|
|
return hira;
|
|
}
|
|
}
|
|
|
|
src += LEARN_QUE_STRING_OFFSET;
|
|
|
|
que_size = QUE_SIZE(handle);
|
|
|
|
|
|
size = que->yomi_byte;
|
|
copy_size = (NJ_UINT8)que_size - LEARN_QUE_STRING_OFFSET;
|
|
dst = (NJ_UINT8*)&(iwnn->learn_string_tmp[0]);
|
|
if (copy_size > size) {
|
|
|
|
copy_size = size;
|
|
}
|
|
|
|
|
|
top_addr = LEARN_DATA_TOP_ADDR(handle);
|
|
bottom_addr = top_addr;
|
|
bottom_addr += que_size * GET_LEARN_MAX_WORD_COUNT(handle) - 1;
|
|
|
|
src += copy_size;
|
|
while (size -= copy_size) {
|
|
|
|
|
|
if (src >= bottom_addr) {
|
|
src = top_addr;
|
|
}
|
|
|
|
|
|
if (*src != QUE_TYPE_NEXT) {
|
|
#ifdef LEARN_DEBUG
|
|
printf("FATAL: src que was broken(not QUE_TYPE_NEXT) [src=%x]\n", src);
|
|
#endif
|
|
return NULL;
|
|
}
|
|
|
|
src++;
|
|
if (size < que_size) {
|
|
|
|
copy_size = size;
|
|
} else {
|
|
copy_size = (NJ_UINT8)(que_size - 1);
|
|
}
|
|
src += copy_size;
|
|
}
|
|
|
|
|
|
|
|
if (((src - top_addr) % que_size) == 0) {
|
|
|
|
if (src >= bottom_addr) {
|
|
src = top_addr;
|
|
}
|
|
|
|
if (*src++ != QUE_TYPE_NEXT) {
|
|
#ifdef LEARN_DEBUG
|
|
printf("FATAL: src que was broken(QUE_TYPE_NEXT) [src=%x]\n", src - 1);
|
|
#endif
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
size = que->hyouki_byte;
|
|
|
|
|
|
copy_size = (NJ_UINT8)(que_size);
|
|
copy_size -= (NJ_UINT8)((src - top_addr) % que_size);
|
|
if (copy_size > size) {
|
|
|
|
copy_size = size;
|
|
}
|
|
for (i = 0; i < copy_size; i++) {
|
|
*dst++ = *src++;
|
|
}
|
|
|
|
while (size -= copy_size) {
|
|
|
|
|
|
if (src >= bottom_addr) {
|
|
src = top_addr;
|
|
}
|
|
|
|
|
|
if (*src != QUE_TYPE_NEXT) {
|
|
#ifdef LEARN_DEBUG
|
|
printf("FATAL: src que was broken(not QUE_TYPE_NEXT) [src=%x]\n", src);
|
|
#endif
|
|
return NULL;
|
|
}
|
|
|
|
src++;
|
|
if (size < que_size) {
|
|
|
|
copy_size = size;
|
|
} else {
|
|
copy_size = (NJ_UINT8)(que_size - 1);
|
|
}
|
|
|
|
for (i = 0; i < copy_size; i++) {
|
|
*dst++ = *src++;
|
|
}
|
|
}
|
|
|
|
*slen = que->hyouki_len;
|
|
iwnn->learn_string_tmp[*slen] = NJ_CHAR_NUL;
|
|
|
|
return &(iwnn->learn_string_tmp[0]);
|
|
}
|
|
|
|
static NJ_INT16 get_cand_by_sequential(NJ_CLASS *iwnn, NJ_SEARCH_CONDITION *cond,
|
|
NJ_SEARCH_LOCATION_SET *loctset, NJ_UINT8 search_pattern,
|
|
NJ_UINT8 comp_flg) {
|
|
NJ_UINT16 current, from, to;
|
|
NJ_UINT16 que_id;
|
|
NJ_UINT8 *ptr, *p;
|
|
NJ_INT16 ret, num_count;
|
|
NJ_CHAR *yomi;
|
|
NJ_WQUE *que;
|
|
NJ_UINT8 forward_flag = 0;
|
|
|
|
|
|
|
|
if (GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_NO_INIT) {
|
|
|
|
ret = search_range_by_yomi(iwnn, loctset->loct.handle, search_pattern,
|
|
cond->yomi, cond->ylen, &from, &to, &forward_flag);
|
|
if (ret < 0) {
|
|
return ret;
|
|
}
|
|
if (ret == 0) {
|
|
if (forward_flag) {
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
} else {
|
|
loctset->loct.status = NJ_ST_SEARCH_END_EXT;
|
|
}
|
|
return 0;
|
|
}
|
|
loctset->loct.top = from;
|
|
loctset->loct.bottom = to;
|
|
current = from;
|
|
} else if (GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_READY) {
|
|
|
|
current = (NJ_UINT16)(loctset->loct.current + 1);
|
|
} else {
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return 0;
|
|
}
|
|
|
|
|
|
ptr = get_search_index_address(loctset->loct.handle, cond->operation);
|
|
p = ptr + (current * NJ_INDEX_SIZE);
|
|
|
|
while (current <= loctset->loct.bottom) {
|
|
que_id = GET_UINT16(p);
|
|
if (search_pattern == NJ_CUR_OP_COMP) {
|
|
|
|
ret = str_que_cmp(iwnn, loctset->loct.handle, cond->yomi, cond->ylen, que_id, 1);
|
|
|
|
|
|
if (ret == 2) {
|
|
ret = 0;
|
|
}
|
|
} else if (search_pattern == NJ_CUR_OP_FORE) {
|
|
|
|
ret = str_que_cmp(iwnn, loctset->loct.handle, cond->yomi, cond->ylen, que_id, 2);
|
|
|
|
|
|
if (ret == 2) {
|
|
ret = 0;
|
|
}
|
|
} else {
|
|
|
|
|
|
|
|
ret = que_strcmp_complete_with_hyouki(iwnn, loctset->loct.handle, que_id,
|
|
cond->yomi, cond->ylen, cond->kanji, 0);
|
|
}
|
|
|
|
if (ret < 0) {
|
|
return ret;
|
|
}
|
|
if (ret > 0) {
|
|
if (search_pattern == NJ_CUR_OP_LINK) {
|
|
|
|
|
|
num_count = continue_cnt(iwnn, loctset->loct.handle, que_id);
|
|
if (num_count < 0) {
|
|
|
|
return num_count;
|
|
}
|
|
|
|
|
|
if (num_count >= ret) {
|
|
|
|
loctset->loct.current_info = (NJ_UINT8)(((num_count + 1) << 4) | ret);
|
|
loctset->loct.current = current;
|
|
loctset->loct.status = NJ_ST_SEARCH_READY;
|
|
loctset->cache_freq = get_hindo(iwnn, loctset, search_pattern);
|
|
return 1;
|
|
}
|
|
} else {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
que = get_que_allHinsi(iwnn, loctset->loct.handle, que_id);
|
|
if (njd_connect_test(cond, que->mae_hinsi, que->ato_hinsi)) {
|
|
|
|
|
|
switch (NJ_GET_DIC_TYPE_EX(loctset->loct.type, loctset->loct.handle)) {
|
|
case NJ_DIC_TYPE_CUSTOM_INCOMPRESS:
|
|
if ((search_pattern == NJ_CUR_OP_COMP) && (comp_flg == 1)) {
|
|
yomi = cond->yomi + cond->ylen;
|
|
ret = que_strcmp_include(iwnn, loctset->loct.handle, que_id, yomi);
|
|
if (ret < 0) {
|
|
return ret;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
loctset->loct.current = current;
|
|
loctset->loct.status = NJ_ST_SEARCH_READY;
|
|
|
|
loctset->loct.current_info = (ret & 0x0f) << 4;
|
|
loctset->cache_freq = get_hindo(iwnn, loctset, search_pattern);
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
p += NJ_INDEX_SIZE;
|
|
current++;
|
|
}
|
|
|
|
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return 0;
|
|
}
|
|
|
|
static NJ_INT16 get_cand_by_evaluate(NJ_CLASS *iwnn, NJ_SEARCH_CONDITION *cond,
|
|
NJ_SEARCH_LOCATION_SET *loctset, NJ_UINT8 search_pattern) {
|
|
NJ_UINT16 from, to, i;
|
|
NJ_UINT16 que_id, oldest;
|
|
NJ_UINT32 max_value, eval, current;
|
|
NJ_UINT8 *ptr, *p;
|
|
NJ_WQUE *que;
|
|
NJ_INT16 ret, num_count;
|
|
NJ_INT32 found = 0;
|
|
NJ_UINT8 forward_flag = 0;
|
|
NJ_INT32 is_first_search, is_better_freq;
|
|
|
|
|
|
|
|
ptr = get_search_index_address(loctset->loct.handle, cond->operation);
|
|
|
|
|
|
oldest = GET_LEARN_NEXT_WORD_POS(loctset->loct.handle);
|
|
|
|
|
|
current = 0;
|
|
if (GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_NO_INIT) {
|
|
if (search_pattern == NJ_CUR_OP_LINK) {
|
|
|
|
|
|
|
|
ret = search_range_by_yomi_multi(iwnn, loctset->loct.handle,
|
|
cond->yomi, cond->ylen, &from, &to);
|
|
} else {
|
|
|
|
|
|
ret = search_range_by_yomi(iwnn, loctset->loct.handle, search_pattern,
|
|
cond->yomi, cond->ylen, &from, &to, &forward_flag);
|
|
}
|
|
if (ret <= 0) {
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return ret;
|
|
}
|
|
loctset->loct.top = from;
|
|
loctset->loct.bottom = to;
|
|
is_first_search = 1;
|
|
} else if (GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_READY) {
|
|
current = GET_UINT16(ptr + (loctset->loct.current * NJ_INDEX_SIZE));
|
|
if (current < oldest) {
|
|
current += GET_LEARN_MAX_WORD_COUNT(loctset->loct.handle);
|
|
}
|
|
is_first_search = 0;
|
|
} else {
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return 0;
|
|
}
|
|
|
|
|
|
max_value = oldest;
|
|
|
|
p = ptr + (loctset->loct.top * NJ_INDEX_SIZE);
|
|
eval = current;
|
|
for (i = (NJ_UINT16)loctset->loct.top; i <= (NJ_UINT16)loctset->loct.bottom; i++) {
|
|
que_id = GET_UINT16(p);
|
|
if (que_id < oldest) {
|
|
eval = que_id + GET_LEARN_MAX_WORD_COUNT(loctset->loct.handle);
|
|
} else {
|
|
eval = que_id;
|
|
}
|
|
#ifdef LEARN_DEBUG
|
|
printf("que(%d) : eval = %d\n", que_id, eval);
|
|
#endif
|
|
is_better_freq = ((eval >= max_value) && ((is_first_search) || (eval < current))) ? 1 : 0;
|
|
|
|
if (is_better_freq) {
|
|
|
|
if (search_pattern == NJ_CUR_OP_LINK) {
|
|
|
|
ret = que_strcmp_complete_with_hyouki(iwnn, loctset->loct.handle, que_id,
|
|
cond->yomi, cond->ylen, cond->kanji, 1);
|
|
} else {
|
|
|
|
ret = str_que_cmp(iwnn, loctset->loct.handle, cond->yomi, cond->ylen, que_id, 2);
|
|
|
|
if (ret == 2) {
|
|
ret = 0;
|
|
}
|
|
}
|
|
if (ret < 0) {
|
|
return ret;
|
|
}
|
|
if (ret >= 1) {
|
|
if (search_pattern == NJ_CUR_OP_LINK) {
|
|
|
|
|
|
num_count = continue_cnt(iwnn, loctset->loct.handle, que_id);
|
|
if (num_count < 0) {
|
|
|
|
return num_count;
|
|
}
|
|
|
|
|
|
if (num_count >= ret) {
|
|
|
|
loctset->loct.current_info = (NJ_UINT8)(((num_count + 1) << 4) | ret);
|
|
loctset->loct.current = i;
|
|
max_value = eval;
|
|
found = 1;
|
|
}
|
|
} else {
|
|
|
|
|
|
|
|
|
|
|
|
que = get_que_allHinsi(iwnn, loctset->loct.handle, que_id);
|
|
if (njd_connect_test(cond, que->mae_hinsi, que->ato_hinsi)) {
|
|
|
|
loctset->loct.current_info = (NJ_UINT8)0x10;
|
|
loctset->loct.current = i;
|
|
max_value = eval;
|
|
found = 1;
|
|
#ifdef LEARN_DEBUG
|
|
printf("---keep.");
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
p += NJ_INDEX_SIZE;
|
|
}
|
|
|
|
|
|
if (found == 0) {
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return 0;
|
|
} else {
|
|
loctset->loct.status = NJ_ST_SEARCH_READY;
|
|
loctset->cache_freq = get_hindo(iwnn, loctset, search_pattern);
|
|
return 1;
|
|
}
|
|
|
|
}
|
|
|
|
static NJ_INT16 search_range_by_yomi(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT8 op,
|
|
NJ_CHAR *yomi, NJ_UINT16 len, NJ_UINT16 *from, NJ_UINT16 *to,
|
|
NJ_UINT8 *forward_flag) {
|
|
NJ_UINT16 right, mid = 0, left, max;
|
|
NJ_UINT16 que_id;
|
|
NJ_UINT8 *ptr, *p;
|
|
NJ_CHAR *str;
|
|
NJ_INT16 ret = 0;
|
|
NJ_INT32 found = 0;
|
|
NJ_UINT8 slen;
|
|
NJ_INT32 cmp;
|
|
|
|
|
|
|
|
ptr = get_search_index_address(handle, op);
|
|
|
|
max = GET_LEARN_WORD_COUNT(handle);
|
|
|
|
right = max - 1;
|
|
left = 0;
|
|
|
|
#ifdef LEARN_DEBUG
|
|
printf("src:[%s]\n", yomi);
|
|
#endif
|
|
|
|
*forward_flag = 0;
|
|
|
|
|
|
switch (op) {
|
|
case NJ_CUR_OP_COMP:
|
|
case NJ_CUR_OP_LINK:
|
|
case NJ_CUR_OP_FORE:
|
|
|
|
|
|
|
|
break;
|
|
default:
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_PARAM_OPERATION);
|
|
}
|
|
|
|
while (left <= right) {
|
|
mid = left + ((right - left) / 2);
|
|
p = ptr + (mid * NJ_INDEX_SIZE);
|
|
que_id = GET_UINT16(p);
|
|
str = get_string(iwnn, handle, que_id, &slen);
|
|
|
|
#ifdef IWNN_ERR_CHECK
|
|
if (iwnn->err_check_flg == 3) {
|
|
str = NULL;
|
|
}
|
|
#endif
|
|
if (str == NULL) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_DIC_BROKEN);
|
|
}
|
|
|
|
ret = nj_strncmp(yomi, str, len);
|
|
if (op != NJ_CUR_OP_FORE) {
|
|
|
|
|
|
if (ret == 0) {
|
|
if ((*forward_flag == 0) && (len <= (NJ_UINT16)slen)) {
|
|
|
|
*forward_flag = 1;
|
|
}
|
|
if (len > (NJ_UINT16)slen) {
|
|
ret = 1;
|
|
} else if (len < (NJ_UINT16)slen) {
|
|
ret = -1;
|
|
}
|
|
}
|
|
}
|
|
#ifdef LEARN_DEBUG
|
|
printf(" [%d][%d][%d]COMPARE:[%s] = %d\n", left, mid, right, str, ret);
|
|
#endif
|
|
if (ret == 0) {
|
|
|
|
found = 1;
|
|
break;
|
|
} else if (ret < 0) {
|
|
|
|
right = mid - 1;
|
|
if (mid == 0) {
|
|
break;
|
|
}
|
|
} else {
|
|
|
|
left = mid + 1;
|
|
}
|
|
}
|
|
|
|
if (!found) {
|
|
return 0;
|
|
}
|
|
|
|
if (mid == 0) {
|
|
*from = mid;
|
|
} else {
|
|
|
|
p = ((mid - 1) * NJ_INDEX_SIZE) + ptr;
|
|
|
|
for (cmp = mid - 1; cmp >= 0; cmp--) {
|
|
que_id = GET_UINT16(p);
|
|
str = get_string(iwnn, handle, que_id, &slen);
|
|
|
|
#ifdef IWNN_ERR_CHECK
|
|
if (iwnn->err_check_flg == 4) {
|
|
str = NULL;
|
|
}
|
|
#endif
|
|
if (str == NULL) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_DIC_BROKEN);
|
|
}
|
|
|
|
if (op != NJ_CUR_OP_FORE) {
|
|
ret = nj_strncmp(yomi, str, len);
|
|
if (ret == 0) {
|
|
if (len > (NJ_UINT16)slen) {
|
|
ret = 1;
|
|
} else if (len < (NJ_UINT16)slen) {
|
|
ret = -1;
|
|
}
|
|
}
|
|
if (ret > 0) {
|
|
|
|
break;
|
|
}
|
|
} else {
|
|
|
|
if (nj_strncmp(yomi, str, len) != 0) {
|
|
break;
|
|
}
|
|
}
|
|
p -= NJ_INDEX_SIZE;
|
|
}
|
|
if (cmp < 0) {
|
|
*from = 0;
|
|
} else {
|
|
*from = (NJ_UINT16)cmp + 1;
|
|
}
|
|
}
|
|
|
|
#ifdef LEARN_DEBUG
|
|
printf(" >> from:(%d)\n", *from);
|
|
#endif
|
|
|
|
#ifdef IWNN_ERR_CHECK
|
|
if (iwnn->err_check_flg == 5) {
|
|
mid = max - 2;
|
|
}
|
|
#endif
|
|
if ((mid + 1) >= max) {
|
|
*to = mid;
|
|
} else {
|
|
|
|
p = ((mid + 1) * NJ_INDEX_SIZE) + ptr;
|
|
|
|
for (right = mid + 1; right < max; right++) {
|
|
que_id = GET_UINT16(p);
|
|
str = get_string(iwnn, handle, que_id, &slen);
|
|
|
|
#ifdef IWNN_ERR_CHECK
|
|
if (iwnn->err_check_flg == 5) {
|
|
str = NULL;
|
|
}
|
|
#endif
|
|
if (str == NULL) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_DIC_BROKEN);
|
|
}
|
|
|
|
if (op != NJ_CUR_OP_FORE) {
|
|
ret = nj_strncmp(yomi, str, len);
|
|
if (ret == 0) {
|
|
if (len > (NJ_UINT16)slen) {
|
|
ret = 1;
|
|
} else if (len < (NJ_UINT16)slen) {
|
|
ret = -1;
|
|
}
|
|
}
|
|
if (ret < 0) {
|
|
|
|
break;
|
|
}
|
|
} else {
|
|
|
|
if (nj_strncmp(yomi, str, len) != 0) {
|
|
break;
|
|
}
|
|
}
|
|
p += NJ_INDEX_SIZE;
|
|
}
|
|
*to = right - 1;
|
|
}
|
|
|
|
#ifdef LEARN_DEBUG
|
|
printf(" >> to:(%d)\n", *to);
|
|
#endif
|
|
return 1;
|
|
}
|
|
|
|
static NJ_INT16 search_range_by_yomi_multi(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle,
|
|
NJ_CHAR *yomi, NJ_UINT16 len, NJ_UINT16 *from, NJ_UINT16 *to) {
|
|
NJ_UINT16 right, mid = 0, left, max = 0;
|
|
NJ_UINT16 que_id;
|
|
NJ_UINT8 *ptr, *p;
|
|
NJ_INT16 ret = 0;
|
|
NJ_UINT16 comp_len;
|
|
NJ_UINT16 i, char_len;
|
|
NJ_INT32 found = 0;
|
|
NJ_INT32 cmp;
|
|
NJ_CHAR comp_yomi[NJ_MAX_LEN + NJ_TERM_LEN];
|
|
NJ_CHAR *pYomi;
|
|
|
|
|
|
|
|
|
|
ptr = LEARN_INDEX_TOP_ADDR(handle);
|
|
|
|
|
|
max = GET_LEARN_WORD_COUNT(handle);
|
|
|
|
#ifdef LEARN_DEBUG
|
|
printf("src:[%s]\n", yomi);
|
|
#endif
|
|
|
|
comp_len = 0;
|
|
pYomi = &yomi[0];
|
|
while (comp_len < len) {
|
|
|
|
|
|
char_len = NJ_CHAR_LEN(pYomi);
|
|
for (i = 0; i < char_len; i++) {
|
|
*(comp_yomi + comp_len) = *pYomi;
|
|
comp_len++;
|
|
pYomi++;
|
|
}
|
|
*(comp_yomi + comp_len) = NJ_CHAR_NUL;
|
|
|
|
right = max - 1;
|
|
left = 0;
|
|
while (left <= right) {
|
|
mid = left + ((right - left) / 2);
|
|
p = ptr + (mid * NJ_INDEX_SIZE);
|
|
que_id = GET_UINT16(p);
|
|
|
|
|
|
ret = str_que_cmp(iwnn, handle, comp_yomi, comp_len, que_id, 1);
|
|
if (ret < 0) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI_MULTI, NJ_ERR_DIC_BROKEN);
|
|
}
|
|
|
|
#ifdef LEARN_DEBUG
|
|
printf(" [%d][%d][%d]COMPARE:[%s] = %d\n", left, mid, right, str, ret);
|
|
#endif
|
|
if (ret == 1) {
|
|
|
|
found = 1;
|
|
break;
|
|
} else if (ret == 0) {
|
|
|
|
right = mid - 1;
|
|
if (mid == 0) {
|
|
break;
|
|
}
|
|
} else {
|
|
|
|
left = mid + 1;
|
|
}
|
|
}
|
|
|
|
if (found) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found) {
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
if (mid == 0) {
|
|
*from = mid;
|
|
} else {
|
|
|
|
p = ((mid - 1) * NJ_INDEX_SIZE) + ptr;
|
|
|
|
for (cmp = mid - 1; cmp >= 0; cmp--) {
|
|
que_id = GET_UINT16(p);
|
|
ret = str_que_cmp(iwnn, handle, comp_yomi, comp_len, que_id, 1);
|
|
if (ret < 0) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI_MULTI, NJ_ERR_DIC_BROKEN);
|
|
}
|
|
if (ret == 2) {
|
|
break;
|
|
}
|
|
p -= NJ_INDEX_SIZE;
|
|
}
|
|
if (cmp < 0) {
|
|
*from = 0;
|
|
} else {
|
|
*from = (NJ_UINT16)cmp + 1;
|
|
}
|
|
}
|
|
|
|
#ifdef LEARN_DEBUG
|
|
printf(" >> from:(%d)\n", *from);
|
|
#endif
|
|
|
|
|
|
if ((mid + 1) >= max) {
|
|
*to = mid;
|
|
} else {
|
|
|
|
p = ((mid + 1) * NJ_INDEX_SIZE) + ptr;
|
|
|
|
for (right = mid + 1; right < max; right++) {
|
|
que_id = GET_UINT16(p);
|
|
ret = str_que_cmp(iwnn, handle, yomi, len, que_id, 1);
|
|
if (ret < 0) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI_MULTI, NJ_ERR_DIC_BROKEN);
|
|
}
|
|
if (ret == 0) {
|
|
break;
|
|
}
|
|
p += NJ_INDEX_SIZE;
|
|
}
|
|
*to = right - 1;
|
|
}
|
|
|
|
#ifdef LEARN_DEBUG
|
|
printf(" >> to:(%d)\n", *to);
|
|
#endif
|
|
return 1;
|
|
}
|
|
|
|
static NJ_INT16 str_que_cmp(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_CHAR *yomi,
|
|
NJ_UINT16 yomiLen, NJ_UINT16 que_id, NJ_UINT8 mode) {
|
|
NJ_UINT8 *queYomi;
|
|
NJ_UINT8 *yomiPtr;
|
|
NJ_UINT16 yomiByte;
|
|
NJ_UINT16 yomiPos;
|
|
NJ_UINT8 queYomiByte, queKouhoByte;
|
|
NJ_UINT8 queYomiPos, queYomiSearchArea;
|
|
NJ_INT16 complete;
|
|
NJ_UINT8 *top_addr;
|
|
NJ_UINT8 *bottom_addr;
|
|
NJ_UINT16 que_size;
|
|
|
|
|
|
#ifdef IWNN_ERR_CHECK
|
|
if (iwnn->err_check_flg == 6) {
|
|
que_id = GET_LEARN_MAX_WORD_COUNT(handle);
|
|
}
|
|
#endif
|
|
if (que_id >= GET_LEARN_MAX_WORD_COUNT(handle)) {
|
|
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_STR_QUE_CMP, NJ_ERR_DIC_BROKEN);
|
|
}
|
|
|
|
queYomi = POS_TO_ADDRESS(handle, que_id);
|
|
#ifdef IWNN_ERR_CHECK
|
|
if (iwnn->err_check_flg == 7) {
|
|
*queYomi = 0x03;
|
|
}
|
|
#endif
|
|
switch (GET_TYPE_FROM_DATA(queYomi)) {
|
|
case QUE_TYPE_EMPTY:
|
|
case QUE_TYPE_JIRI:
|
|
case QUE_TYPE_FZK:
|
|
break;
|
|
default:
|
|
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_STR_QUE_CMP, NJ_ERR_DIC_BROKEN);
|
|
}
|
|
|
|
|
|
if ((mode == 2) && (yomiLen == 0)) {
|
|
return 1;
|
|
}
|
|
|
|
|
|
queYomiByte = GET_YSIZE_FROM_DATA(queYomi);
|
|
queKouhoByte= GET_KSIZE_FROM_DATA(queYomi);
|
|
|
|
top_addr = LEARN_DATA_TOP_ADDR(handle);
|
|
que_size = QUE_SIZE(handle);
|
|
|
|
|
|
queYomi += LEARN_QUE_STRING_OFFSET;
|
|
queYomiSearchArea = (NJ_UINT8)(QUE_SIZE(handle) - LEARN_QUE_STRING_OFFSET);
|
|
|
|
complete = 0;
|
|
yomiPos = 0; queYomiPos = 0;
|
|
yomiPtr = (NJ_UINT8*)yomi;
|
|
yomiByte = yomiLen * sizeof(NJ_CHAR);
|
|
|
|
|
|
while ((complete = (*yomiPtr - *queYomi)) == 0) {
|
|
yomiPos++; queYomiPos++;
|
|
|
|
if (queYomiPos >= queYomiByte) {
|
|
if (queYomiByte == yomiByte) {
|
|
|
|
return 1;
|
|
} else if (mode == 2) {
|
|
|
|
return 2;
|
|
} else {
|
|
|
|
return (mode + 1);
|
|
}
|
|
}
|
|
if (yomiPos >= yomiByte) {
|
|
|
|
break;
|
|
} else {
|
|
yomiPtr++; queYomi++;
|
|
#ifdef IWNN_ERR_CHECK
|
|
if (iwnn->err_check_flg == 8) {
|
|
queYomiPos = queYomiSearchArea;
|
|
}
|
|
#endif
|
|
if (queYomiPos >= queYomiSearchArea) {
|
|
|
|
bottom_addr = top_addr;
|
|
bottom_addr += que_size * GET_LEARN_MAX_WORD_COUNT(handle) - 1;
|
|
if (queYomi >= bottom_addr) {
|
|
queYomi = top_addr;
|
|
}
|
|
|
|
|
|
if (*queYomi++ != QUE_TYPE_NEXT) {
|
|
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_STR_QUE_CMP, NJ_ERR_DIC_BROKEN);
|
|
}
|
|
queYomiSearchArea += (NJ_UINT8)(que_size - 1);
|
|
}
|
|
}
|
|
}
|
|
if (complete == 0) {
|
|
if (yomiByte < queYomiByte) {
|
|
|
|
if (mode == 2) {
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
} else {
|
|
|
|
return 2;
|
|
}
|
|
} else if (complete < 0) {
|
|
|
|
return 0;
|
|
} else {
|
|
|
|
return 2;
|
|
}
|
|
}
|
|
|
|
static NJ_HINDO calculate_hindo(NJ_DIC_HANDLE handle, NJ_INT32 freq, NJ_DIC_FREQ *dic_freq, NJ_INT16 freq_max, NJ_INT16 freq_min) {
|
|
NJ_UINT16 max;
|
|
NJ_HINDO hindo;
|
|
|
|
|
|
max = GET_LEARN_MAX_WORD_COUNT(handle);
|
|
|
|
|
|
|
|
|
|
if (NJ_GET_DIC_TYPE(handle) == NJ_DIC_TYPE_USER) {
|
|
|
|
hindo = (NJ_INT16)dic_freq->base;
|
|
} else {
|
|
|
|
if (max > 1) {
|
|
|
|
hindo = CALCULATE_HINDO(freq, dic_freq->base, dic_freq->high, (max-1));
|
|
} else {
|
|
|
|
hindo = (NJ_INT16)dic_freq->high;
|
|
}
|
|
}
|
|
return NORMALIZE_HINDO(hindo, freq_max, freq_min);
|
|
}
|
|
|
|
static NJ_HINDO get_hindo(NJ_CLASS *iwnn, NJ_SEARCH_LOCATION_SET *loctset,
|
|
NJ_UINT8 search_pattern) {
|
|
NJ_WQUE *que;
|
|
NJ_UINT16 que_id, oldest;
|
|
NJ_UINT8 offset;
|
|
NJ_INT32 dic_freq;
|
|
NJ_UINT16 max;
|
|
NJ_UINT8 *learn_index_top_addr;
|
|
|
|
|
|
|
|
learn_index_top_addr = get_search_index_address(loctset->loct.handle, search_pattern);
|
|
|
|
que_id = (NJ_UINT16)GET_UINT16(learn_index_top_addr +
|
|
((loctset->loct.current & 0xffffU) * NJ_INDEX_SIZE));
|
|
oldest = GET_LEARN_NEXT_WORD_POS(loctset->loct.handle);
|
|
|
|
offset = (loctset->loct.current_info & 0x0f);
|
|
while (offset--) {
|
|
que_id = search_next_que(loctset->loct.handle, que_id);
|
|
}
|
|
|
|
que = get_que(iwnn, loctset->loct.handle, que_id);
|
|
if (que == NULL) {
|
|
return INIT_HINDO;
|
|
}
|
|
|
|
max = GET_LEARN_MAX_WORD_COUNT(loctset->loct.handle);
|
|
if (que_id >= oldest) {
|
|
dic_freq = que_id - oldest;
|
|
} else {
|
|
dic_freq = que_id - oldest + max;
|
|
}
|
|
|
|
|
|
return calculate_hindo(loctset->loct.handle, dic_freq, &(loctset->dic_freq), 1000, 0);
|
|
}
|
|
|
|
NJ_INT16 njd_l_get_word(NJ_CLASS *iwnn, NJ_SEARCH_LOCATION_SET *loctset, NJ_WORD *word) {
|
|
NJ_WQUE *que;
|
|
NJ_UINT16 que_id;
|
|
NJ_UINT8 offset;
|
|
NJ_UINT8 *learn_index_top_addr;
|
|
|
|
|
|
|
|
learn_index_top_addr = get_search_index_address(loctset->loct.handle, GET_LOCATION_OPERATION(loctset->loct.status));
|
|
|
|
que_id = (NJ_UINT16)GET_UINT16(learn_index_top_addr +
|
|
((loctset->loct.current & 0xffff) * NJ_INDEX_SIZE));
|
|
|
|
offset = (loctset->loct.current_info & 0x0f);
|
|
while (offset--) {
|
|
que_id = search_next_que(loctset->loct.handle, que_id);
|
|
}
|
|
|
|
que = get_que(iwnn, loctset->loct.handle, que_id);
|
|
if (que == NULL) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_GET_WORD, NJ_ERR_CANNOT_GET_QUE);
|
|
}
|
|
|
|
word->stem.loc = loctset->loct;
|
|
|
|
word->stem.loc.current &= 0x0000ffff;
|
|
word->stem.loc.current |= ((NJ_UINT32)que_id << 16);
|
|
|
|
|
|
word->stem.hindo = loctset->cache_freq;
|
|
|
|
NJ_SET_FPOS_TO_STEM(word, que->mae_hinsi);
|
|
NJ_SET_YLEN_TO_STEM(word, que->yomi_len);
|
|
if (que->hyouki_len > 0) {
|
|
NJ_SET_KLEN_TO_STEM(word, que->hyouki_len);
|
|
} else {
|
|
|
|
NJ_SET_KLEN_TO_STEM(word, que->yomi_len);
|
|
}
|
|
NJ_SET_BPOS_TO_STEM(word, que->ato_hinsi);
|
|
|
|
|
|
word->stem.type = 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
NJ_INT16 njd_l_get_stroke(NJ_CLASS *iwnn, NJ_WORD *word, NJ_CHAR *stroke, NJ_UINT16 size) {
|
|
NJ_UINT16 que_id;
|
|
NJ_CHAR *str;
|
|
NJ_UINT8 slen;
|
|
NJ_UINT8 ylen;
|
|
|
|
|
|
que_id = (NJ_UINT16)(word->stem.loc.current >> 16);
|
|
|
|
|
|
ylen = (NJ_UINT8)NJ_GET_YLEN_FROM_STEM(word);
|
|
|
|
if ((NJ_UINT16)((ylen+ NJ_TERM_LEN)*sizeof(NJ_CHAR)) > size) {
|
|
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_GET_STROKE, NJ_ERR_BUFFER_NOT_ENOUGH);
|
|
}
|
|
if (ylen == 0) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_GET_STROKE, NJ_ERR_INVALID_RESULT);
|
|
}
|
|
str = get_string(iwnn, word->stem.loc.handle, que_id, &slen);
|
|
|
|
#ifdef IWNN_ERR_CHECK
|
|
if (iwnn->err_check_flg == 9) {
|
|
str = NULL;
|
|
}
|
|
#endif
|
|
|
|
if (str == NULL) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_GET_STROKE, NJ_ERR_DIC_BROKEN);
|
|
}
|
|
|
|
|
|
nj_strcpy(stroke, str);
|
|
|
|
return slen;
|
|
}
|
|
|
|
NJ_INT16 njd_l_get_candidate(NJ_CLASS *iwnn, NJ_WORD *word,
|
|
NJ_CHAR *candidate, NJ_UINT16 size) {
|
|
NJ_UINT16 que_id;
|
|
NJ_CHAR *str;
|
|
NJ_UINT16 klen;
|
|
NJ_UINT8 slen;
|
|
|
|
|
|
que_id = (NJ_UINT16)(word->stem.loc.current >> 16);
|
|
|
|
|
|
klen = NJ_GET_KLEN_FROM_STEM(word);
|
|
|
|
if (size < ((klen+NJ_TERM_LEN)*sizeof(NJ_CHAR))) {
|
|
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_GET_CANDIDATE, NJ_ERR_BUFFER_NOT_ENOUGH);
|
|
}
|
|
str = get_hyouki(iwnn, word->stem.loc.handle, que_id, &slen);
|
|
#ifdef IWNN_ERR_CHECK
|
|
if (iwnn->err_check_flg == 10) {
|
|
str = NULL;
|
|
}
|
|
#endif
|
|
if (str == NULL) {
|
|
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_GET_CANDIDATE, NJ_ERR_DIC_BROKEN);
|
|
}
|
|
|
|
|
|
nj_strcpy(candidate, str);
|
|
|
|
return klen;
|
|
}
|
|
|
|
NJ_INT16 njd_l_check_dic(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle) {
|
|
NJ_UINT16 flg;
|
|
NJ_UINT16 word_cnt, max;
|
|
NJ_UINT8 *ptr;
|
|
NJ_UINT16 target_id;
|
|
NJ_UINT16 i;
|
|
NJ_UINT16 id1 = 0;
|
|
NJ_UINT8 slen;
|
|
|
|
|
|
|
|
if ((NJ_GET_DIC_TYPE(handle) != NJ_DIC_TYPE_USER)) {
|
|
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_CHECK_DIC, NJ_ERR_DIC_TYPE_INVALID);
|
|
}
|
|
|
|
|
|
word_cnt = GET_LEARN_WORD_COUNT(handle);
|
|
max = GET_LEARN_MAX_WORD_COUNT(handle);
|
|
if (word_cnt > max) {
|
|
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_CHECK_DIC,
|
|
NJ_ERR_DIC_BROKEN);
|
|
}
|
|
|
|
ptr = LEARN_INDEX_TOP_ADDR(handle);
|
|
for (i = 0; i < word_cnt; i++) {
|
|
id1 = GET_UINT16(ptr);
|
|
|
|
if (id1 >= max) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_CHECK_DIC,
|
|
NJ_ERR_DIC_BROKEN);
|
|
}
|
|
ptr += NJ_INDEX_SIZE;
|
|
}
|
|
|
|
|
|
ptr = LEARN_INDEX_TOP_ADDR2(handle);
|
|
for (i = 0; i < word_cnt; i++) {
|
|
id1 = GET_UINT16(ptr);
|
|
|
|
if (id1 >= max) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_CHECK_DIC,
|
|
NJ_ERR_DIC_BROKEN);
|
|
}
|
|
ptr += NJ_INDEX_SIZE;
|
|
}
|
|
|
|
|
|
flg = GET_UINT16(handle + POS_WRITE_FLG);
|
|
|
|
target_id = GET_UINT16(handle + POS_WRITE_FLG + 2);
|
|
|
|
|
|
|
|
if (((flg != word_cnt) && (flg != (word_cnt + 1)) && (flg != (word_cnt - 1))) ||
|
|
(target_id >= max)) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_CHECK_DIC,
|
|
NJ_ERR_DIC_BROKEN);
|
|
}
|
|
|
|
|
|
if (flg == (word_cnt + 1)) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_CHECK_DIC, NJ_ERR_DIC_BROKEN);
|
|
} else if (flg == (word_cnt - 1)) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_CHECK_DIC, NJ_ERR_DIC_BROKEN);
|
|
}
|
|
|
|
word_cnt = GET_LEARN_WORD_COUNT(handle);
|
|
|
|
ptr = LEARN_INDEX_TOP_ADDR(handle);
|
|
for (i = 0; i < word_cnt; i++) {
|
|
id1 = GET_UINT16(ptr);
|
|
if (get_hyouki(iwnn, handle, id1, &slen) == NULL) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_CHECK_DIC,
|
|
NJ_ERR_DIC_BROKEN);
|
|
}
|
|
ptr += NJ_INDEX_SIZE;
|
|
}
|
|
|
|
ptr = LEARN_INDEX_TOP_ADDR2(handle);
|
|
for (i = 0; i < word_cnt; i++) {
|
|
id1 = GET_UINT16(ptr);
|
|
|
|
if (id1 >= max) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_CHECK_DIC,
|
|
NJ_ERR_DIC_BROKEN);
|
|
}
|
|
ptr += NJ_INDEX_SIZE;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static NJ_INT16 get_cand_by_evaluate2(NJ_CLASS *iwnn, NJ_SEARCH_CONDITION *cond,
|
|
NJ_SEARCH_LOCATION_SET *loctset,
|
|
NJ_UINT8 search_pattern,
|
|
NJ_UINT16 idx) {
|
|
NJ_UINT16 from, to, i;
|
|
NJ_UINT16 que_id, oldest;
|
|
NJ_UINT32 max_value, eval, current;
|
|
NJ_UINT8 *ptr, *p;
|
|
NJ_WQUE *que;
|
|
NJ_INT16 ret = 0;
|
|
NJ_INT32 found = 0;
|
|
NJ_UINT8 forward_flag = 0;
|
|
|
|
|
|
NJ_UINT16 abIdx;
|
|
NJ_UINT16 abIdx_old;
|
|
NJ_UINT16 tmp_len;
|
|
NJ_UINT16 yomi_clen;
|
|
NJ_UINT16 j,l,m;
|
|
NJ_UINT8 cmpflg;
|
|
NJ_UINT8 endflg = 0;
|
|
NJ_CHAR *str;
|
|
NJ_CHAR *key;
|
|
NJ_CHAR char_tmp[NJ_MAX_LEN + NJ_TERM_LEN];
|
|
NJ_CHAR *pchar_tmp;
|
|
NJ_SEARCH_CACHE *psrhCache = cond->ds->dic[idx].srhCache;
|
|
NJ_UINT16 endIdx;
|
|
NJ_UINT8 slen;
|
|
NJ_UINT16 addcnt = 0;
|
|
NJ_CHAR *yomi;
|
|
NJ_UINT8 aimai_flg = 0x01;
|
|
NJ_CHARSET *pCharset = cond->charset;
|
|
|
|
|
|
if (NJ_GET_CACHEOVER_FROM_SCACHE(psrhCache)) {
|
|
aimai_flg = 0x00;
|
|
}
|
|
|
|
|
|
ptr = get_search_index_address(loctset->loct.handle, cond->operation);
|
|
|
|
|
|
oldest = GET_LEARN_NEXT_WORD_POS(loctset->loct.handle);
|
|
max_value = oldest;
|
|
|
|
|
|
current = 0;
|
|
if (GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_NO_INIT) {
|
|
|
|
|
|
key = cond->ds->keyword;
|
|
yomi = cond->yomi;
|
|
yomi_clen = cond->yclen;
|
|
|
|
|
|
endflg = 0x00;
|
|
|
|
if (psrhCache->keyPtr[0] == 0xFFFF) {
|
|
cmpflg = 0x01;
|
|
psrhCache->keyPtr[0] = 0x0000;
|
|
} else {
|
|
cmpflg = 0x00;
|
|
}
|
|
|
|
for (i = 0; i < yomi_clen; i++) {
|
|
j = i;
|
|
|
|
|
|
if (!cmpflg) {
|
|
|
|
if (((j != 0) && (psrhCache->keyPtr[j] == 0)) || (psrhCache->keyPtr[j+1] == 0)) {
|
|
|
|
cmpflg = 0x01;
|
|
} else {
|
|
|
|
}
|
|
}
|
|
|
|
if (cmpflg) {
|
|
|
|
if (!j) {
|
|
|
|
abIdx = 0;
|
|
addcnt = 0;
|
|
nj_charncpy(char_tmp, yomi, 1);
|
|
tmp_len = nj_strlen(char_tmp);
|
|
ret = search_range_by_yomi(iwnn, loctset->loct.handle, search_pattern,
|
|
char_tmp, tmp_len, &from,
|
|
&to, &forward_flag);
|
|
if (ret < 0) {
|
|
|
|
|
|
psrhCache->keyPtr[j+1] = abIdx;
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return ret;
|
|
} else if (ret > 0) {
|
|
|
|
psrhCache->storebuff[abIdx].top = from;
|
|
psrhCache->storebuff[abIdx].bottom = to;
|
|
psrhCache->storebuff[abIdx].idx_no = (NJ_INT8)tmp_len;
|
|
addcnt++;
|
|
abIdx++;
|
|
psrhCache->keyPtr[j+1] = abIdx;
|
|
} else {
|
|
psrhCache->keyPtr[j+1] = abIdx;
|
|
}
|
|
|
|
if ((!endflg) && (pCharset != NULL) && aimai_flg) {
|
|
|
|
for (l = 0; l < pCharset->charset_count; l++) {
|
|
|
|
if (nj_charncmp(yomi, pCharset->from[l], 1) == 0) {
|
|
|
|
nj_strcpy(char_tmp, pCharset->to[l]);
|
|
tmp_len = nj_strlen(char_tmp);
|
|
ret = search_range_by_yomi(iwnn, loctset->loct.handle, search_pattern,
|
|
char_tmp, tmp_len, &from, &to, &forward_flag);
|
|
if (ret < 0) {
|
|
|
|
|
|
psrhCache->keyPtr[j+1] = abIdx;
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return ret;
|
|
} else if (ret > 0) {
|
|
|
|
|
|
if (abIdx >= NJ_SEARCH_CACHE_SIZE) {
|
|
psrhCache->keyPtr[j+1] = 0;
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_CACHE_NOT_ENOUGH);
|
|
}
|
|
psrhCache->storebuff[abIdx].top = from;
|
|
psrhCache->storebuff[abIdx].bottom = to;
|
|
psrhCache->storebuff[abIdx].idx_no = (NJ_INT8)tmp_len;
|
|
if (addcnt == 0) {
|
|
psrhCache->keyPtr[j] = abIdx;
|
|
}
|
|
abIdx++;
|
|
addcnt++;
|
|
psrhCache->keyPtr[j+1] = abIdx;
|
|
} else {
|
|
psrhCache->keyPtr[j+1] = abIdx;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
|
|
if (psrhCache->keyPtr[j] == psrhCache->keyPtr[j-1]) {
|
|
|
|
psrhCache->keyPtr[j+1] = psrhCache->keyPtr[j-1];
|
|
endflg = 0x01;
|
|
} else {
|
|
|
|
endIdx = psrhCache->keyPtr[j];
|
|
abIdx_old = psrhCache->keyPtr[j-1];
|
|
|
|
if (NJ_GET_CACHEOVER_FROM_SCACHE(psrhCache)) {
|
|
abIdx = psrhCache->keyPtr[j - 1];
|
|
psrhCache->keyPtr[j] = abIdx;
|
|
} else {
|
|
abIdx = psrhCache->keyPtr[j];
|
|
}
|
|
addcnt = 0;
|
|
|
|
if ((abIdx > NJ_SEARCH_CACHE_SIZE) || (abIdx_old >= NJ_SEARCH_CACHE_SIZE) ||
|
|
(endIdx > NJ_SEARCH_CACHE_SIZE)) {
|
|
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_CACHE_BROKEN);
|
|
}
|
|
for (m = abIdx_old; m < endIdx; m++) {
|
|
|
|
p = ptr + (psrhCache->storebuff[m].top * NJ_INDEX_SIZE);
|
|
que_id = GET_UINT16(p);
|
|
|
|
|
|
str = get_string(iwnn, loctset->loct.handle, que_id, &slen);
|
|
|
|
if (str == NULL) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_DIC_BROKEN);
|
|
}
|
|
|
|
|
|
nj_strncpy(char_tmp, str, psrhCache->storebuff[m].idx_no);
|
|
char_tmp[psrhCache->storebuff[m].idx_no] = NJ_CHAR_NUL;
|
|
|
|
pchar_tmp = &char_tmp[psrhCache->storebuff[m].idx_no];
|
|
nj_charncpy(pchar_tmp, yomi, 1);
|
|
tmp_len = nj_strlen(char_tmp);
|
|
|
|
|
|
ret = search_range_by_yomi2(iwnn, loctset->loct.handle, search_pattern,
|
|
char_tmp, tmp_len,
|
|
(NJ_UINT16)(psrhCache->storebuff[m].top),
|
|
(NJ_UINT16)(psrhCache->storebuff[m].bottom),
|
|
&from, &to, &forward_flag);
|
|
if (ret < 0) {
|
|
|
|
|
|
psrhCache->keyPtr[j+1] = abIdx;
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return ret;
|
|
} else if (ret > 0) {
|
|
|
|
|
|
if (abIdx >= NJ_SEARCH_CACHE_SIZE) {
|
|
psrhCache->keyPtr[j+1] = 0;
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_CACHE_NOT_ENOUGH);
|
|
}
|
|
psrhCache->storebuff[abIdx].top = from;
|
|
psrhCache->storebuff[abIdx].bottom = to;
|
|
psrhCache->storebuff[abIdx].idx_no = (NJ_INT8)tmp_len;
|
|
if (addcnt == 0) {
|
|
psrhCache->keyPtr[j] = abIdx;
|
|
}
|
|
abIdx++;
|
|
addcnt++;
|
|
psrhCache->keyPtr[j+1] = abIdx;
|
|
} else {
|
|
psrhCache->keyPtr[j+1] = abIdx;
|
|
}
|
|
|
|
if ((!endflg) && (pCharset != NULL) && aimai_flg) {
|
|
|
|
for (l = 0; l < pCharset->charset_count; l++) {
|
|
|
|
if (nj_charncmp(yomi, pCharset->from[l], 1) == 0) {
|
|
|
|
tmp_len = nj_strlen(pCharset->to[l]);
|
|
|
|
nj_strncpy(pchar_tmp, pCharset->to[l], tmp_len);
|
|
*(pchar_tmp + tmp_len) = NJ_CHAR_NUL;
|
|
tmp_len = nj_strlen(char_tmp);
|
|
ret = search_range_by_yomi2(iwnn, loctset->loct.handle, search_pattern,
|
|
char_tmp, tmp_len,
|
|
(NJ_UINT16)(psrhCache->storebuff[m].top),
|
|
(NJ_UINT16)(psrhCache->storebuff[m].bottom),
|
|
&from, &to, &forward_flag);
|
|
if (ret < 0) {
|
|
|
|
|
|
psrhCache->keyPtr[j+1] = abIdx;
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return ret;
|
|
} else if (ret > 0) {
|
|
|
|
|
|
if (abIdx >= NJ_SEARCH_CACHE_SIZE) {
|
|
psrhCache->keyPtr[j+1] = 0;
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_CACHE_NOT_ENOUGH);
|
|
}
|
|
psrhCache->storebuff[abIdx].top = from;
|
|
psrhCache->storebuff[abIdx].bottom = to;
|
|
psrhCache->storebuff[abIdx].idx_no = (NJ_INT8)tmp_len;
|
|
abIdx++;
|
|
addcnt++;
|
|
psrhCache->keyPtr[j+1] = abIdx;
|
|
} else {
|
|
psrhCache->keyPtr[j+1] = abIdx;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
yomi += UTL_CHAR(yomi);
|
|
key += UTL_CHAR(key);
|
|
}
|
|
|
|
|
|
if ((addcnt == 0) && (psrhCache->keyPtr[yomi_clen - 1] == psrhCache->keyPtr[yomi_clen])) {
|
|
endflg = 0x01;
|
|
}
|
|
|
|
if (endflg) {
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return 0;
|
|
}
|
|
} else if (GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_READY) {
|
|
current = GET_UINT16(ptr + (loctset->loct.current * NJ_INDEX_SIZE));
|
|
if (current < oldest) {
|
|
current += GET_LEARN_MAX_WORD_COUNT(loctset->loct.handle);
|
|
}
|
|
} else {
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return 0;
|
|
}
|
|
|
|
|
|
j = cond->yclen - 1;
|
|
|
|
abIdx = psrhCache->keyPtr[j];
|
|
abIdx_old = psrhCache->keyPtr[j+1];
|
|
|
|
endIdx = abIdx_old;
|
|
if ((abIdx >= NJ_SEARCH_CACHE_SIZE) || (abIdx_old > NJ_SEARCH_CACHE_SIZE)) {
|
|
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_CACHE_BROKEN);
|
|
}
|
|
p = ptr + (psrhCache->storebuff[abIdx].top * NJ_INDEX_SIZE);
|
|
que_id = GET_UINT16(p);
|
|
eval = current;
|
|
|
|
|
|
|
|
if (psrhCache->keyPtr[j] < psrhCache->keyPtr[j + 1]) {
|
|
if (GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_NO_INIT) {
|
|
endIdx = abIdx + 1;
|
|
NJ_SET_AIMAI_TO_SCACHE(psrhCache);
|
|
}
|
|
|
|
for (m = abIdx; m < endIdx; m++) {
|
|
p = ptr + (psrhCache->storebuff[m].top * NJ_INDEX_SIZE);
|
|
que_id = GET_UINT16(p);
|
|
eval = current;
|
|
|
|
for (i = (NJ_UINT16)psrhCache->storebuff[m].top; i <= (NJ_UINT16)psrhCache->storebuff[m].bottom; i++) {
|
|
que_id = GET_UINT16(p);
|
|
if (que_id < oldest) {
|
|
eval = que_id + GET_LEARN_MAX_WORD_COUNT(loctset->loct.handle);
|
|
} else {
|
|
eval = que_id;
|
|
}
|
|
#ifdef LEARN_DEBUG
|
|
printf("que(%d) : eval = %d : %d\n", que_id, eval, i);
|
|
#endif
|
|
if (eval >= max_value) {
|
|
if ((GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_NO_INIT)
|
|
|| ((GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_READY)
|
|
&& (NJ_GET_AIMAI_FROM_SCACHE(psrhCache)))
|
|
|| (eval < current)) {
|
|
|
|
|
|
|
|
str = get_string(iwnn, loctset->loct.handle, que_id, &slen);
|
|
if (str == NULL) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_DIC_BROKEN);
|
|
}
|
|
|
|
|
|
|
|
que = get_que_allHinsi(iwnn, loctset->loct.handle, que_id);
|
|
if (njd_connect_test(cond, que->mae_hinsi, que->ato_hinsi)) {
|
|
|
|
loctset->loct.current_info = (NJ_UINT8)0x10;
|
|
loctset->loct.current = i;
|
|
max_value = eval;
|
|
found = 1;
|
|
#ifdef LEARN_DEBUG
|
|
printf("---keep.");
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
p += NJ_INDEX_SIZE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (GET_LOCATION_STATUS(loctset->loct.status) != NJ_ST_SEARCH_NO_INIT) {
|
|
NJ_UNSET_AIMAI_TO_SCACHE(psrhCache);
|
|
}
|
|
|
|
|
|
if (found == 0) {
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return 0;
|
|
} else {
|
|
loctset->loct.status = NJ_ST_SEARCH_READY;
|
|
loctset->cache_freq = get_hindo(iwnn, loctset, search_pattern);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
static NJ_INT16 search_range_by_yomi2(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT8 op,
|
|
NJ_CHAR *yomi, NJ_UINT16 len,
|
|
NJ_UINT16 sfrom, NJ_UINT16 sto,
|
|
NJ_UINT16 *from, NJ_UINT16 *to,
|
|
NJ_UINT8 *forward_flag) {
|
|
NJ_UINT16 right, mid = 0, left, max;
|
|
NJ_UINT16 que_id;
|
|
NJ_UINT8 *ptr, *p;
|
|
NJ_CHAR *str;
|
|
NJ_INT16 ret = 0;
|
|
NJ_INT32 found = 0;
|
|
NJ_UINT8 slen;
|
|
NJ_INT32 cmp;
|
|
|
|
|
|
|
|
ptr = get_search_index_address(handle, op);
|
|
|
|
max = GET_LEARN_WORD_COUNT(handle);
|
|
|
|
right = sto;
|
|
left = sfrom;
|
|
|
|
#ifdef LEARN_DEBUG
|
|
printf("src:[%s]\n", yomi);
|
|
#endif
|
|
|
|
*forward_flag = 0;
|
|
|
|
while (left <= right) {
|
|
mid = left + ((right - left) / 2);
|
|
p = ptr + (mid * NJ_INDEX_SIZE);
|
|
que_id = GET_UINT16(p);
|
|
str = get_string(iwnn, handle, que_id, &slen);
|
|
if (str == NULL) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_DIC_BROKEN);
|
|
}
|
|
|
|
|
|
ret = nj_strncmp(yomi, str, len);
|
|
|
|
#ifdef LEARN_DEBUG
|
|
printf(" [%d][%d][%d]COMPARE:[%s] = %d\n", left, mid, right, str, ret);
|
|
#endif
|
|
if (ret == 0) {
|
|
|
|
found = 1;
|
|
break;
|
|
} else if (ret < 0) {
|
|
|
|
right = mid - 1;
|
|
if (mid == 0) {
|
|
break;
|
|
}
|
|
} else {
|
|
|
|
left = mid + 1;
|
|
}
|
|
}
|
|
|
|
if (!found) {
|
|
return 0;
|
|
}
|
|
|
|
if (mid == 0) {
|
|
*from = mid;
|
|
} else {
|
|
|
|
p = ((mid - 1) * NJ_INDEX_SIZE) + ptr;
|
|
|
|
for (cmp = mid - 1; cmp >= 0; cmp--) {
|
|
que_id = GET_UINT16(p);
|
|
str = get_string(iwnn, handle, que_id, &slen);
|
|
if (str == NULL) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_DIC_BROKEN);
|
|
}
|
|
|
|
|
|
if (nj_strncmp(yomi, str, len) != 0) {
|
|
break;
|
|
}
|
|
p -= NJ_INDEX_SIZE;
|
|
}
|
|
if (cmp < 0) {
|
|
*from = 0;
|
|
} else {
|
|
*from = (NJ_UINT16)cmp + 1;
|
|
}
|
|
}
|
|
|
|
#ifdef LEARN_DEBUG
|
|
printf(" >> from:(%d)\n", *from);
|
|
#endif
|
|
|
|
if ((mid + 1) >= max) {
|
|
*to = mid;
|
|
} else {
|
|
|
|
p = ((mid + 1) * NJ_INDEX_SIZE) + ptr;
|
|
|
|
for (right = mid + 1; right < max; right++) {
|
|
que_id = GET_UINT16(p);
|
|
str = get_string(iwnn, handle, que_id, &slen);
|
|
if (str == NULL) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_DIC_BROKEN);
|
|
}
|
|
|
|
|
|
if (nj_strncmp(yomi, str, len) != 0) {
|
|
break;
|
|
}
|
|
p += NJ_INDEX_SIZE;
|
|
}
|
|
*to = right - 1;
|
|
}
|
|
|
|
#ifdef LEARN_DEBUG
|
|
printf(" >> to:(%d)\n", *to);
|
|
#endif
|
|
return 1;
|
|
}
|
|
|