| /* |
| * Copyright (C) 2008,2009 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), loctset->dic_freq_max, loctset->dic_freq_min); |
| } |
| |
| 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; |
| } |
| |
