2831 lines
87 KiB
C
2831 lines
87 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"
|
|
|
|
|
|
#define NODE_TERM(x) ((NJ_UINT8)(0x80 & (*(x))))
|
|
#define NODE_LEFT_EXIST(x) ((NJ_UINT8)(0x40 & (*(x))))
|
|
#define NODE_DATA_EXIST(x) ((NJ_UINT8)(0x20 & (*(x))))
|
|
#define NODE_IDX_EXIST(x) ((NJ_UINT8)(0x10 & (*(x))))
|
|
#define NODE_IDX_CNT(x) ((NJ_UINT8)((0x0f & (*(x))) + 2))
|
|
|
|
#define STEM_TERMINETER(x) ((NJ_UINT8)(0x80 & (*(x))))
|
|
|
|
#define STEM_NO_CONV_FLG(x) ((NJ_UINT8)(0x40 & (*(x))))
|
|
|
|
#define TERM_BIT (1)
|
|
#define INDEX_BIT (8)
|
|
|
|
#define APPEND_YOMI_FLG(h) ((NJ_UINT8)(0x80 & (*((h) + 0x1C))))
|
|
#define HINSI_NO_TOP_ADDR(h) ((NJ_UINT8*)((h) + NJ_INT32_READ((h) + 0x1D)))
|
|
#define FHINSI_NO_CNT(h) ((NJ_INT16)(NJ_INT16_READ((h) + 0x21)))
|
|
#define BHINSI_NO_CNT(h) ((NJ_INT16)(NJ_INT16_READ((h) + 0x23)))
|
|
#define HINSI_NO_BYTE(h) ((NJ_UINT8)(*((h) + 0x25)))
|
|
#define HINDO_NO_TOP_ADDR(h) ((NJ_UINT8*)((h) + NJ_INT32_READ((h) + 0x26)))
|
|
#define HINDO_NO_CNT(h) ((NJ_UINT8)(*((h) + 0x2A)))
|
|
#define STEM_AREA_TOP_ADDR(h) ((NJ_UINT8*)((h) + NJ_INT32_READ((h) + 0x2B)))
|
|
#define BIT_CANDIDATE_LEN(h) ((NJ_UINT8)(*((h) + 0x2F)))
|
|
#define BIT_FHINSI(h) ((NJ_UINT8)(*((h) + 0x30)))
|
|
#define BIT_BHINSI(h) ((NJ_UINT8)(*((h) + 0x31)))
|
|
#define BIT_HINDO_LEN(h) ((NJ_UINT8)(*((h) + 0x32)))
|
|
#define BIT_MUHENKAN_LEN(h) ((NJ_UINT8)(*((h) + 0x33)))
|
|
#define BIT_YOMI_LEN(h) ((NJ_UINT8)(*((h) + 0x35)))
|
|
#define YOMI_INDX_TOP_ADDR(h) ((NJ_UINT8*)((h) + NJ_INT32_READ((h) + 0x42)))
|
|
#define YOMI_INDX_CNT(h) ((NJ_INT16)(*((h) + 0x46)))
|
|
#define YOMI_INDX_SIZE(h) ((NJ_INT8)(*((h) + 0x47)))
|
|
#define NODE_AREA_TOP_ADDR(h) ((NJ_UINT8*)((h) + NJ_INT32_READ((h) + 0x48)))
|
|
#define BIT_NODE_AREA_DATA_LEN(h) ((NJ_UINT8)(*((h) + 0x4C)))
|
|
#define BIT_NODE_AREA_LEFT_LEN(h) ((NJ_UINT8)(*((h) + 0x4D)))
|
|
#define NODE_AREA_MID_ADDR(h) ((NJ_UINT32)(NJ_INT32_READ((h) + 0x4E)))
|
|
#define CAND_IDX_AREA_TOP_ADDR(h) ((NJ_UINT8*)((h) + NJ_INT32_READ((h) + 0x52)))
|
|
#define CAND_IDX_AREA_CNT(h) ((NJ_UINT32)(((NJ_INT32_READ((h) + 0x56)) >> 8) & 0x00FFFFFF))
|
|
#define CAND_IDX_AREA_SIZE(h) ((NJ_UINT8)(*((h) + 0x59)))
|
|
|
|
#define WORD_LEN(x) ((NJ_UINT16)(0x007F & (x)))
|
|
|
|
#define CURRENT_INFO_SET ((NJ_UINT8)(0x10))
|
|
|
|
#define COMP_DIC_FREQ_DIV 63
|
|
|
|
#define LOC_CURRENT_NO_ENTRY 0xffffffffU
|
|
|
|
typedef struct {
|
|
NJ_UINT16 stem_size;
|
|
NJ_UINT16 term;
|
|
NJ_UINT16 no_conv_flg;
|
|
NJ_HINDO hindo;
|
|
NJ_UINT16 hindo_jitu;
|
|
NJ_UINT16 candidate_size;
|
|
NJ_UINT16 yomi_size;
|
|
NJ_UINT16 fhinsi;
|
|
NJ_UINT16 bhinsi;
|
|
NJ_UINT16 fhinsi_jitu;
|
|
NJ_UINT16 bhinsi_jitu;
|
|
} STEM_DATA_SET;
|
|
|
|
static NJ_INT16 get_stem_next(NJ_DIC_HANDLE hdl, NJ_UINT8 *stem_data);
|
|
static void get_stem_word(NJ_DIC_HANDLE hdl, NJ_UINT8 *stem_data, STEM_DATA_SET *stem_set, NJ_UINT8 check);
|
|
static void get_stem_cand_data(NJ_DIC_HANDLE hdl, NJ_UINT8 *stem_data, STEM_DATA_SET *stem_set);
|
|
static NJ_UINT16 get_stem_yomi_data(NJ_DIC_HANDLE hdl, NJ_UINT8 *stem_data,STEM_DATA_SET *stem_set);
|
|
static NJ_UINT16 get_stem_yomi_size(NJ_DIC_HANDLE hdl, NJ_UINT8 *stem_data, NJ_UINT16 yomi_size);
|
|
static NJ_UINT16 get_stem_yomi_string(NJ_DIC_HANDLE hdl, NJ_UINT8 *stem_data, NJ_CHAR *yomi, NJ_UINT16 yomi_pos, NJ_UINT16 yomi_size, NJ_UINT16 size);
|
|
static NJ_INT16 search_node(NJ_SEARCH_CONDITION *condition, NJ_SEARCH_LOCATION_SET *loctset);
|
|
static NJ_INT16 bdic_search_data(NJ_SEARCH_CONDITION *condition, NJ_SEARCH_LOCATION_SET *loctset);
|
|
static NJ_INT16 bdic_search_fore_data(NJ_SEARCH_CONDITION *condition, NJ_SEARCH_LOCATION_SET *loctset);
|
|
|
|
static NJ_HINDO get_stem_hindo(NJ_DIC_HANDLE hdl, NJ_UINT8 *stem_data);
|
|
|
|
static NJ_INT16 search_node2(NJ_SEARCH_CONDITION *condition, NJ_SEARCH_LOCATION_SET *loctset,
|
|
NJ_UINT16 hidx);
|
|
static NJ_INT16 bdic_search_fore_data2(NJ_SEARCH_CONDITION *condition,
|
|
NJ_SEARCH_LOCATION_SET *loctset, NJ_UINT16 hidx);
|
|
static NJ_INT16 search_yomi_node(NJ_UINT8 operation, NJ_UINT8 *node,
|
|
NJ_UINT8 *now, NJ_UINT16 idx_no,
|
|
NJ_CHAR *yomi, NJ_UINT16 yomilen,
|
|
NJ_UINT8 *root, NJ_UINT8 *node_mid,
|
|
NJ_UINT16 bit_left, NJ_UINT16 bit_data,
|
|
NJ_UINT8 *data_top,
|
|
NJ_INT16 ytbl_cnt, NJ_UINT16 y,
|
|
NJ_UINT8 *ytbl_top, NJ_CACHE_INFO *storebuf,
|
|
NJ_UINT8 **con_node, NJ_UINT32 *data_offset);
|
|
static NJ_INT16 get_node_bottom(NJ_CHAR *yomi, NJ_UINT8 *now, NJ_UINT8 *node_mid,
|
|
NJ_UINT8 *data_top, NJ_UINT16 bit_left,
|
|
NJ_UINT16 bit_data, NJ_UINT32 top,
|
|
NJ_DIC_HANDLE handle, NJ_UINT32 *ret_bottom);
|
|
static NJ_INT16 bdic_get_next_data(NJ_UINT8 *data_top, NJ_UINT8 *data_end,
|
|
NJ_SEARCH_LOCATION_SET *loctset,
|
|
NJ_SEARCH_CACHE *psrhCache, NJ_UINT16 abIdx);
|
|
static NJ_INT16 bdic_get_word_freq(NJ_UINT8 *data_top, NJ_SEARCH_LOCATION_SET *loctset,
|
|
NJ_SEARCH_CACHE *psrhCache, NJ_UINT16 abIdx);
|
|
|
|
static NJ_HINDO get_stem_hindo(NJ_DIC_HANDLE hdl, NJ_UINT8 *stem_data)
|
|
{
|
|
NJ_UINT8 flg_bit;
|
|
NJ_UINT16 data;
|
|
NJ_UINT16 pos, j, bit_all;
|
|
|
|
|
|
|
|
flg_bit = BIT_MUHENKAN_LEN(hdl);
|
|
if (NJ_GET_DIC_FMT(hdl) != NJ_DIC_FMT_KANAKAN) {
|
|
flg_bit++;
|
|
}
|
|
|
|
if (BIT_HINDO_LEN(hdl)) {
|
|
|
|
bit_all = (NJ_UINT16)(TERM_BIT + flg_bit);
|
|
pos = (NJ_UINT16)(bit_all >> 3);
|
|
data = (NJ_UINT16)(NJ_INT16_READ(stem_data + pos));
|
|
|
|
|
|
j = (NJ_UINT16)(bit_all & 0x0007);
|
|
|
|
return GET_BITFIELD_16(data, j, BIT_HINDO_LEN(hdl));
|
|
} else {
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static NJ_INT16 get_stem_next(NJ_DIC_HANDLE hdl, NJ_UINT8 *stem_data)
|
|
{
|
|
NJ_UINT8 flg_bit;
|
|
NJ_UINT16 data;
|
|
NJ_UINT16 pos, j, bit_all;
|
|
NJ_UINT16 stem_size, cand_bit, yomi_bit;
|
|
NJ_UINT16 candidate_size, yomi_size;
|
|
|
|
|
|
|
|
flg_bit = BIT_MUHENKAN_LEN(hdl);
|
|
if (NJ_GET_DIC_FMT(hdl) != NJ_DIC_FMT_KANAKAN) {
|
|
flg_bit++;
|
|
}
|
|
|
|
|
|
|
|
bit_all = (NJ_UINT16)(TERM_BIT + flg_bit +
|
|
BIT_HINDO_LEN(hdl) +
|
|
BIT_FHINSI(hdl) +
|
|
BIT_BHINSI(hdl));
|
|
pos = (NJ_UINT16)(bit_all >> 3);
|
|
data = (NJ_UINT16)(NJ_INT16_READ(stem_data + pos));
|
|
|
|
|
|
j = (NJ_UINT16)(bit_all & 0x0007);
|
|
cand_bit = BIT_CANDIDATE_LEN(hdl);
|
|
|
|
candidate_size = GET_BITFIELD_16(data, j, cand_bit);
|
|
bit_all += cand_bit;
|
|
|
|
|
|
if (APPEND_YOMI_FLG(hdl) && STEM_TERMINETER(stem_data)) {
|
|
|
|
|
|
pos = (NJ_UINT16)(bit_all >> 3);
|
|
data = (NJ_UINT16)(NJ_INT16_READ(stem_data + pos));
|
|
|
|
|
|
j = (NJ_UINT16)(bit_all & 0x0007);
|
|
yomi_bit = BIT_YOMI_LEN(hdl);
|
|
|
|
yomi_size = GET_BITFIELD_16(data, j, yomi_bit);
|
|
bit_all += yomi_bit;
|
|
} else {
|
|
yomi_size = 0;
|
|
}
|
|
|
|
|
|
stem_size = GET_BIT_TO_BYTE(bit_all);
|
|
|
|
|
|
stem_size += candidate_size;
|
|
|
|
|
|
stem_size += yomi_size;
|
|
|
|
|
|
return stem_size;
|
|
}
|
|
|
|
static void get_stem_word(NJ_DIC_HANDLE hdl, NJ_UINT8 *stem_data, STEM_DATA_SET *stem_set, NJ_UINT8 check)
|
|
{
|
|
NJ_UINT8 flg_bit;
|
|
NJ_UINT16 data;
|
|
NJ_UINT16 pos, j, bit_all = 0;
|
|
NJ_UINT16 bit;
|
|
NJ_UINT16 dpos = 0;
|
|
NJ_INT16 next;
|
|
NJ_UINT8 b;
|
|
NJ_UINT8 *wkc;
|
|
|
|
|
|
|
|
flg_bit = BIT_MUHENKAN_LEN(hdl);
|
|
if (NJ_GET_DIC_FMT(hdl) != NJ_DIC_FMT_KANAKAN) {
|
|
flg_bit++;
|
|
}
|
|
|
|
if (BIT_HINDO_LEN(hdl)) {
|
|
|
|
bit_all = (NJ_UINT16)(TERM_BIT + flg_bit);
|
|
pos = (NJ_UINT16)(bit_all >> 3);
|
|
data = (NJ_UINT16)(NJ_INT16_READ(stem_data + pos));
|
|
|
|
|
|
j = (NJ_UINT16)(bit_all & 0x0007);
|
|
|
|
stem_set->hindo = GET_BITFIELD_16(data, j, BIT_HINDO_LEN(hdl));
|
|
} else {
|
|
|
|
stem_set->hindo = 0;
|
|
}
|
|
|
|
stem_set->hindo_jitu = (NJ_UINT16)(*(HINDO_NO_TOP_ADDR(hdl) + stem_set->hindo));
|
|
|
|
if (BIT_FHINSI(hdl)) {
|
|
|
|
|
|
bit_all = (NJ_UINT16)(TERM_BIT + flg_bit + BIT_HINDO_LEN(hdl));
|
|
pos = (NJ_UINT16)(bit_all >> 3);
|
|
data = (NJ_UINT16)(NJ_INT16_READ(stem_data + pos));
|
|
|
|
|
|
j = (NJ_UINT16)(bit_all & 0x0007);
|
|
|
|
stem_set->fhinsi = GET_BITFIELD_16(data, j, BIT_FHINSI(hdl));
|
|
} else {
|
|
stem_set->fhinsi = 0;
|
|
}
|
|
|
|
|
|
b = HINSI_NO_BYTE(hdl);
|
|
wkc = (NJ_UINT8*)(HINSI_NO_TOP_ADDR(hdl) + (b * (NJ_UINT16)(stem_set->fhinsi)));
|
|
|
|
|
|
if (b == 2) {
|
|
stem_set->fhinsi_jitu = (NJ_UINT16)(NJ_INT16_READ(wkc));
|
|
} else {
|
|
stem_set->fhinsi_jitu = (NJ_UINT16)*wkc;
|
|
}
|
|
|
|
if (BIT_BHINSI(hdl)) {
|
|
|
|
|
|
bit_all = (NJ_UINT16)(TERM_BIT + flg_bit + BIT_HINDO_LEN(hdl) + BIT_FHINSI(hdl));
|
|
pos = (NJ_UINT16)(bit_all >> 3);
|
|
data = (NJ_UINT16)(NJ_INT16_READ(stem_data + pos));
|
|
|
|
|
|
j = (NJ_UINT16)(bit_all & 0x0007);
|
|
|
|
stem_set->bhinsi = GET_BITFIELD_16(data, j, BIT_BHINSI(hdl));
|
|
} else {
|
|
stem_set->bhinsi = 0;
|
|
}
|
|
|
|
wkc = (NJ_UINT8*)(HINSI_NO_TOP_ADDR(hdl)
|
|
+ (b * (FHINSI_NO_CNT(hdl) + (NJ_UINT16)(stem_set->bhinsi))));
|
|
|
|
if (b == 2) {
|
|
stem_set->bhinsi_jitu = (NJ_UINT16)(NJ_INT16_READ(wkc));
|
|
} else {
|
|
stem_set->bhinsi_jitu = (NJ_UINT16)*wkc;
|
|
}
|
|
|
|
|
|
if (check != 1) {
|
|
|
|
|
|
bit_all = (NJ_UINT16)(TERM_BIT + flg_bit +
|
|
BIT_HINDO_LEN(hdl) +
|
|
BIT_FHINSI(hdl) +
|
|
BIT_BHINSI(hdl));
|
|
pos = (NJ_UINT16)(bit_all >> 3);
|
|
data = (NJ_UINT16)(NJ_INT16_READ(stem_data + pos));
|
|
|
|
|
|
j = (NJ_UINT16)(bit_all & 0x0007);
|
|
bit = BIT_CANDIDATE_LEN(hdl);
|
|
|
|
stem_set->candidate_size = GET_BITFIELD_16(data, j, bit);
|
|
bit_all += bit;
|
|
}
|
|
|
|
if (check == 0) {
|
|
stem_set->yomi_size = 0;
|
|
|
|
|
|
if (APPEND_YOMI_FLG(hdl) && STEM_TERMINETER(stem_data)) {
|
|
pos = (NJ_UINT16)(bit_all >> 3);
|
|
data = (NJ_UINT16)(NJ_INT16_READ(stem_data + pos));
|
|
|
|
|
|
j = (NJ_UINT16)(bit_all & 0x0007);
|
|
bit = BIT_YOMI_LEN(hdl);
|
|
|
|
stem_set->yomi_size = GET_BITFIELD_16(data, j, bit);
|
|
bit_all += bit;
|
|
|
|
|
|
|
|
dpos = GET_BIT_TO_BYTE(bit_all);
|
|
dpos += stem_set->candidate_size;
|
|
|
|
} else if (APPEND_YOMI_FLG(hdl)) {
|
|
while (!(STEM_TERMINETER(stem_data))) {
|
|
next = get_stem_next(hdl, stem_data);
|
|
stem_data += next;
|
|
}
|
|
|
|
dpos = get_stem_yomi_data(hdl, stem_data, stem_set);
|
|
}
|
|
|
|
if (stem_set->yomi_size) {
|
|
|
|
stem_set->yomi_size = get_stem_yomi_size(hdl, stem_data + dpos, stem_set->yomi_size);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void get_stem_cand_data(NJ_DIC_HANDLE hdl, NJ_UINT8 *stem_data, STEM_DATA_SET *stem_set)
|
|
{
|
|
NJ_UINT8 flg_bit;
|
|
NJ_UINT16 data;
|
|
NJ_UINT16 pos, j, bit_all;
|
|
NJ_UINT16 cand_bit, yomi_bit;
|
|
|
|
|
|
|
|
flg_bit = BIT_MUHENKAN_LEN(hdl);
|
|
if (NJ_GET_DIC_FMT(hdl) != NJ_DIC_FMT_KANAKAN) {
|
|
flg_bit++;
|
|
}
|
|
|
|
|
|
|
|
bit_all = (NJ_UINT16)(TERM_BIT + flg_bit +
|
|
BIT_HINDO_LEN(hdl) +
|
|
BIT_FHINSI(hdl) +
|
|
BIT_BHINSI(hdl));
|
|
pos = (NJ_UINT16)(bit_all >> 3);
|
|
data = (NJ_UINT16)(NJ_INT16_READ(stem_data + pos));
|
|
|
|
|
|
cand_bit = BIT_CANDIDATE_LEN(hdl);
|
|
j = (NJ_UINT16)(bit_all & 0x0007);
|
|
|
|
stem_set->candidate_size = GET_BITFIELD_16(data, j, cand_bit);
|
|
bit_all += cand_bit;
|
|
|
|
|
|
if (APPEND_YOMI_FLG(hdl) && STEM_TERMINETER(stem_data)) {
|
|
|
|
yomi_bit = BIT_YOMI_LEN(hdl);
|
|
bit_all += yomi_bit;
|
|
}
|
|
|
|
|
|
stem_set->stem_size = GET_BIT_TO_BYTE(bit_all);
|
|
}
|
|
|
|
static NJ_UINT16 get_stem_yomi_data(NJ_DIC_HANDLE hdl, NJ_UINT8 *stem_data,STEM_DATA_SET *stem_set)
|
|
{
|
|
NJ_UINT16 flg_bit;
|
|
NJ_UINT16 data;
|
|
NJ_UINT16 cand_bit, yomi_bit;
|
|
NJ_UINT16 pos, j, bit_all;
|
|
NJ_UINT16 yomi_pos;
|
|
NJ_UINT16 candidate_size;
|
|
|
|
|
|
|
|
flg_bit = BIT_MUHENKAN_LEN(hdl);
|
|
if (NJ_GET_DIC_FMT(hdl) != NJ_DIC_FMT_KANAKAN) {
|
|
flg_bit++;
|
|
}
|
|
|
|
|
|
|
|
bit_all = (NJ_UINT16)(TERM_BIT + flg_bit + BIT_HINDO_LEN(hdl) +
|
|
BIT_FHINSI(hdl) + BIT_BHINSI(hdl));
|
|
pos = (NJ_UINT16)(bit_all >> 3);
|
|
data = (NJ_UINT16)(NJ_INT16_READ(stem_data + pos));
|
|
|
|
|
|
j = (NJ_UINT16)(bit_all & 0x0007);
|
|
|
|
cand_bit = BIT_CANDIDATE_LEN(hdl);
|
|
candidate_size = GET_BITFIELD_16(data, j, cand_bit);
|
|
|
|
|
|
bit_all += cand_bit;
|
|
|
|
|
|
if (APPEND_YOMI_FLG(hdl) && STEM_TERMINETER(stem_data)) {
|
|
|
|
|
|
pos = (NJ_UINT16)(bit_all >> 3);
|
|
data = (NJ_UINT16)(NJ_INT16_READ(stem_data + pos));
|
|
|
|
|
|
j = (NJ_UINT16)(bit_all & 0x0007);
|
|
yomi_bit = BIT_YOMI_LEN(hdl);
|
|
|
|
stem_set->yomi_size = GET_BITFIELD_16(data, j, yomi_bit);
|
|
bit_all += yomi_bit;
|
|
} else {
|
|
stem_set->yomi_size = 0;
|
|
}
|
|
|
|
|
|
|
|
yomi_pos = GET_BIT_TO_BYTE(bit_all);
|
|
yomi_pos += candidate_size;
|
|
|
|
return yomi_pos;
|
|
}
|
|
|
|
static NJ_UINT16 get_stem_yomi_size(NJ_DIC_HANDLE hdl, NJ_UINT8 *ydata, NJ_UINT16 yomi_size)
|
|
{
|
|
NJ_INT16 ytbl_cnt;
|
|
NJ_INT8 ysize;
|
|
NJ_UINT8 *ytbl_top;
|
|
NJ_UINT8 *ytbl;
|
|
NJ_UINT8 yidx;
|
|
NJ_UINT16 i;
|
|
NJ_UINT16 len;
|
|
|
|
|
|
|
|
ytbl_cnt = YOMI_INDX_CNT(hdl);
|
|
|
|
if (ytbl_cnt) {
|
|
ysize = YOMI_INDX_SIZE(hdl);
|
|
ytbl_top = YOMI_INDX_TOP_ADDR(hdl);
|
|
|
|
len = 0;
|
|
for (i = 0; i < yomi_size; i++) {
|
|
if (ysize == 2) {
|
|
|
|
yidx = *(ydata+i);
|
|
ytbl = ytbl_top + ((yidx-1) * ysize);
|
|
len += UTL_CHAR(ytbl);
|
|
|
|
} else {
|
|
|
|
len++;
|
|
}
|
|
}
|
|
|
|
return len * sizeof(NJ_CHAR);
|
|
} else {
|
|
|
|
return yomi_size;
|
|
}
|
|
}
|
|
|
|
static NJ_UINT16 get_stem_yomi_string(NJ_DIC_HANDLE hdl, NJ_UINT8 *stem_data, NJ_CHAR *yomi, NJ_UINT16 yomi_pos, NJ_UINT16 yomi_size, NJ_UINT16 size)
|
|
{
|
|
NJ_INT16 ytbl_cnt;
|
|
NJ_INT8 ysize;
|
|
NJ_UINT8 *ytbl_top, *ytbl;
|
|
NJ_UINT8 *ydata;
|
|
NJ_UINT8 yidx;
|
|
NJ_UINT16 i;
|
|
NJ_UINT16 copy_len;
|
|
NJ_UINT16 char_len;
|
|
|
|
|
|
|
|
ytbl_cnt = YOMI_INDX_CNT(hdl);
|
|
ysize = YOMI_INDX_SIZE(hdl);
|
|
ytbl_top = YOMI_INDX_TOP_ADDR(hdl);
|
|
|
|
|
|
ydata = stem_data + yomi_pos;
|
|
|
|
if (ytbl_cnt) {
|
|
copy_len = 0;
|
|
for (i = 0; i < yomi_size; i++) {
|
|
|
|
yidx = *(ydata + i);
|
|
ytbl = ytbl_top + ((yidx - 1) * ysize);
|
|
if (ysize == 2) {
|
|
|
|
char_len = UTL_CHAR(ytbl);
|
|
if (((copy_len + char_len + NJ_TERM_LEN) * sizeof(NJ_CHAR)) > size) {
|
|
return size;
|
|
}
|
|
while (char_len > 0) {
|
|
NJ_CHAR_COPY(yomi + copy_len, ytbl);
|
|
copy_len++;
|
|
char_len--;
|
|
ytbl += sizeof(NJ_CHAR);
|
|
}
|
|
} else {
|
|
|
|
if (((copy_len + 1 + NJ_TERM_LEN) * sizeof(NJ_CHAR)) > size) {
|
|
return size;
|
|
}
|
|
|
|
*(yomi + copy_len) = (NJ_CHAR)(*ytbl);
|
|
copy_len++;
|
|
}
|
|
}
|
|
} else {
|
|
if ((yomi_size + (NJ_TERM_LEN * sizeof(NJ_CHAR))) > size) {
|
|
return size;
|
|
}
|
|
|
|
nj_memcpy((NJ_UINT8*)yomi, ydata, yomi_size);
|
|
copy_len = yomi_size / sizeof(NJ_CHAR);
|
|
}
|
|
|
|
|
|
*(yomi + copy_len) = NJ_CHAR_NUL;
|
|
|
|
|
|
return copy_len;
|
|
}
|
|
|
|
static NJ_INT16 search_node(NJ_SEARCH_CONDITION *condition, NJ_SEARCH_LOCATION_SET *loctset)
|
|
{
|
|
NJ_UINT8 *root, *now, *node, *node_mid;
|
|
NJ_UINT8 index;
|
|
NJ_UINT8 *byomi;
|
|
NJ_UINT8 *wkc;
|
|
NJ_UINT8 idx_no;
|
|
NJ_INT16 idx;
|
|
NJ_INT16 char_size;
|
|
NJ_INT16 left, right, mid;
|
|
NJ_INT16 ytbl_cnt;
|
|
NJ_UINT16 c, d;
|
|
NJ_UINT8 c1 = 0, c2 = 0;
|
|
NJ_UINT16 y;
|
|
NJ_UINT16 ysize = (condition->ylen * sizeof(NJ_CHAR));
|
|
NJ_UINT8 *ytbl_top;
|
|
NJ_UINT16 idx_cnt;
|
|
NJ_UINT16 nd_index;
|
|
NJ_UINT16 bit_left, bit_data;
|
|
NJ_UINT32 data_offset;
|
|
NJ_UINT16 data;
|
|
NJ_UINT16 pos, j, bit_all, bit_tmp, bit_idx;
|
|
NJ_UINT32 data_l;
|
|
NJ_UINT8 restart_flg = 0;
|
|
NJ_UINT8 bottom_flg = 0;
|
|
NJ_UINT8 *data_top, *stem_data;
|
|
NJ_UINT16 hindo, hindo_max;
|
|
NJ_UINT32 current,hindo_max_data, bottom, next;
|
|
|
|
|
|
node = NULL;
|
|
|
|
byomi = (NJ_UINT8*)(condition->yomi);
|
|
|
|
|
|
root = NODE_AREA_TOP_ADDR(loctset->loct.handle);
|
|
|
|
|
|
node_mid = root + NODE_AREA_MID_ADDR(loctset->loct.handle);
|
|
now = node_mid;
|
|
|
|
|
|
idx_no = 0;
|
|
idx_cnt = 1;
|
|
|
|
bit_left = BIT_NODE_AREA_LEFT_LEN(loctset->loct.handle);
|
|
bit_data = BIT_NODE_AREA_DATA_LEN(loctset->loct.handle);
|
|
|
|
ytbl_cnt = YOMI_INDX_CNT(loctset->loct.handle);
|
|
y = YOMI_INDX_SIZE(loctset->loct.handle);
|
|
ytbl_top = YOMI_INDX_TOP_ADDR(loctset->loct.handle);
|
|
|
|
data_top = STEM_AREA_TOP_ADDR(loctset->loct.handle);
|
|
|
|
|
|
if ((condition->operation == NJ_CUR_OP_FORE) &&
|
|
NJ_CHAR_STRLEN_IS_0(condition->yomi)) {
|
|
|
|
ysize = 0;
|
|
|
|
|
|
node = root;
|
|
}
|
|
|
|
|
|
while (ysize > 0) {
|
|
if (ytbl_cnt != 0) {
|
|
char_size = UTL_CHAR(byomi) * sizeof(NJ_CHAR);
|
|
if (char_size > 2) {
|
|
loctset->loct.status = NJ_ST_SEARCH_END_EXT;
|
|
return 0;
|
|
}
|
|
|
|
if (char_size == 2) {
|
|
if (y == 1) {
|
|
return 0;
|
|
}
|
|
c1 = *byomi;
|
|
c2 = *(byomi + 1);
|
|
c = (NJ_UINT16)((c1 << 8) | c2);
|
|
} else {
|
|
|
|
c1 = *byomi;
|
|
c2 = 0x00;
|
|
c = (NJ_UINT16)(*byomi);
|
|
}
|
|
|
|
idx = -1;
|
|
left = 0;
|
|
right = ytbl_cnt;
|
|
|
|
if (y == 2) {
|
|
while (left <= right) {
|
|
mid = (left + right) >> 1;
|
|
wkc = ytbl_top + (mid << 1);
|
|
|
|
if (c1 == *wkc) {
|
|
if (c2 == *(wkc + 1)) {
|
|
idx = (NJ_UINT16)(mid + 1);
|
|
break;
|
|
}
|
|
if (c2 < *(wkc + 1)) {
|
|
right = mid - 1;
|
|
} else {
|
|
left = mid + 1;
|
|
}
|
|
} else if (c1 < *wkc) {
|
|
right = mid - 1;
|
|
} else {
|
|
left = mid + 1;
|
|
}
|
|
}
|
|
} else {
|
|
while (left <= right) {
|
|
mid = (left + right) >> 1;
|
|
wkc = ytbl_top + (mid * y);
|
|
d = (NJ_UINT16)(*wkc);
|
|
if (c == d) {
|
|
idx = (NJ_UINT16)(mid + 1);
|
|
break;
|
|
}
|
|
if (c < d) {
|
|
right = mid - 1;
|
|
} else {
|
|
left = mid + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (idx < 0) {
|
|
loctset->loct.status = NJ_ST_SEARCH_END_EXT;
|
|
return 0;
|
|
}
|
|
index = (NJ_UINT8)idx;
|
|
} else {
|
|
index = *byomi;
|
|
char_size = 1;
|
|
}
|
|
|
|
byomi += char_size;
|
|
ysize -= char_size;
|
|
|
|
while (now < data_top) {
|
|
if (NODE_IDX_EXIST(now)) {
|
|
bit_idx = 8;
|
|
idx_cnt = NODE_IDX_CNT(now);
|
|
} else {
|
|
bit_idx = 4;
|
|
idx_cnt = 1;
|
|
}
|
|
bit_all = bit_idx;
|
|
|
|
|
|
if (NODE_LEFT_EXIST(now)) {
|
|
bit_all += bit_left;
|
|
}
|
|
|
|
|
|
if (NODE_DATA_EXIST(now)) {
|
|
bit_all += bit_data;
|
|
}
|
|
|
|
bit_tmp = bit_all;
|
|
|
|
|
|
bit_all += (NJ_UINT16)(idx_no << 3);
|
|
|
|
|
|
pos = (NJ_UINT16)(bit_all >> 3);
|
|
|
|
data = (NJ_UINT16)(NJ_INT16_READ(now + pos));
|
|
|
|
|
|
j = (NJ_UINT16)(bit_all & 0x0007);
|
|
|
|
nd_index = GET_BITFIELD_16(data, j, INDEX_BIT);
|
|
if (index == (NJ_UINT8)nd_index) {
|
|
|
|
break;
|
|
} else {
|
|
if ((!NODE_TERM(now)) && (index > (NJ_UINT8)nd_index) && (idx_no == 0)) {
|
|
|
|
now += GET_BIT_TO_BYTE(bit_tmp + (idx_cnt * 8));
|
|
if (now == node_mid) {
|
|
loctset->loct.status = NJ_ST_SEARCH_END_EXT;
|
|
return 0;
|
|
}
|
|
continue;
|
|
} else {
|
|
if ((now == node_mid) && (restart_flg == 0) &&
|
|
(index < (NJ_UINT8)nd_index) && (idx_no == 0) &&
|
|
(root != node_mid)) {
|
|
now = root;
|
|
idx_no = 0;
|
|
restart_flg = 1;
|
|
continue;
|
|
}
|
|
loctset->loct.status = NJ_ST_SEARCH_END_EXT;
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( (idx_cnt > (NJ_UINT16)(idx_no + 1))) {
|
|
if (ysize == 0) {
|
|
if (condition->operation == NJ_CUR_OP_FORE) {
|
|
|
|
node = now;
|
|
break;
|
|
}
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return 0;
|
|
}
|
|
idx_no++;
|
|
continue;
|
|
}
|
|
node = now;
|
|
idx_no = 0;
|
|
|
|
if (ysize == 0) {
|
|
break;
|
|
} else {
|
|
if (!(NODE_LEFT_EXIST(now))) {
|
|
loctset->loct.status = NJ_ST_SEARCH_END_EXT;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if (NODE_IDX_EXIST(now)) {
|
|
bit_idx = 8;
|
|
} else {
|
|
bit_idx = 4;
|
|
}
|
|
pos = (NJ_UINT16)(bit_idx >> 3);
|
|
data_l = (NJ_UINT32)(NJ_INT32_READ(now + pos));
|
|
|
|
|
|
j = (NJ_UINT16)(bit_idx & 0x0007);
|
|
|
|
now += GET_BITFIELD_32(data_l, j, bit_left);
|
|
}
|
|
|
|
|
|
now = node;
|
|
|
|
|
|
if ((node == NULL) || !(NODE_DATA_EXIST(node))) {
|
|
|
|
if ((condition->operation == NJ_CUR_OP_FORE) &&
|
|
(node != NULL)) {
|
|
while (!NODE_DATA_EXIST(node)) {
|
|
if (!(NODE_LEFT_EXIST(node))) {
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return 0;
|
|
}
|
|
|
|
if (NODE_IDX_EXIST(node)) {
|
|
bit_idx = 8;
|
|
} else {
|
|
bit_idx = 4;
|
|
}
|
|
pos = (NJ_UINT16)(bit_idx >> 3);
|
|
data_l = (NJ_UINT32)(NJ_INT32_READ(node + pos));
|
|
|
|
|
|
j = (NJ_UINT16)(bit_idx & 0x0007);
|
|
node += GET_BITFIELD_32(data_l, j, bit_left);
|
|
}
|
|
} else {
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if (NODE_IDX_EXIST(node)) {
|
|
bit_idx = 8;
|
|
} else {
|
|
bit_idx = 4;
|
|
}
|
|
|
|
|
|
if (NODE_LEFT_EXIST(node)) {
|
|
bit_all = bit_idx + bit_left;
|
|
} else {
|
|
bit_all = bit_idx;
|
|
}
|
|
|
|
pos = (NJ_UINT16)(bit_all >> 3);
|
|
data_l = (NJ_UINT32)(NJ_INT32_READ(node + pos));
|
|
|
|
|
|
j = (NJ_UINT16)(bit_all & 0x0007);
|
|
data_offset = GET_BITFIELD_32(data_l, j, bit_data);
|
|
|
|
loctset->loct.top = data_offset;
|
|
loctset->loct.current = 0;
|
|
|
|
if (condition->operation == NJ_CUR_OP_FORE) {
|
|
|
|
bottom = loctset->loct.top;
|
|
|
|
if (NJ_CHAR_STRLEN_IS_0(condition->yomi)) {
|
|
node = node_mid;
|
|
|
|
} else {
|
|
|
|
node = now;
|
|
if (NODE_LEFT_EXIST(node)) {
|
|
if (NODE_IDX_EXIST(node)) {
|
|
bit_all = 8;
|
|
} else {
|
|
bit_all = 4;
|
|
}
|
|
|
|
pos = (NJ_UINT16)(bit_all >> 3);
|
|
data_l = (NJ_UINT32)(NJ_INT32_READ(node + pos));
|
|
|
|
|
|
j = (NJ_UINT16)(bit_all & 0x0007);
|
|
node += GET_BITFIELD_32(data_l, j, bit_left);
|
|
|
|
} else {
|
|
bottom_flg = 1;
|
|
}
|
|
}
|
|
|
|
if (!bottom_flg) {
|
|
while (node < data_top) {
|
|
|
|
if (!NODE_TERM(node)) {
|
|
|
|
if (NODE_IDX_EXIST(node)) {
|
|
bit_all = 8;
|
|
idx_cnt = NODE_IDX_CNT(node);
|
|
} else {
|
|
bit_all = 4;
|
|
idx_cnt = 1;
|
|
}
|
|
|
|
|
|
if (NODE_LEFT_EXIST(node)) {
|
|
bit_all += bit_left;
|
|
}
|
|
|
|
|
|
if (NODE_DATA_EXIST(node)) {
|
|
bit_all += bit_data;
|
|
}
|
|
|
|
|
|
node += GET_BIT_TO_BYTE(bit_all + (idx_cnt * 8));
|
|
} else {
|
|
|
|
if (!NODE_LEFT_EXIST(node)) {
|
|
|
|
if (NODE_DATA_EXIST(node)) {
|
|
|
|
if (NODE_IDX_EXIST(node)) {
|
|
bit_all = 8;
|
|
} else {
|
|
bit_all = 4;
|
|
}
|
|
|
|
pos = (NJ_UINT16)(bit_all >> 3);
|
|
data_l = (NJ_UINT32)(NJ_INT32_READ(node + pos));
|
|
|
|
|
|
j = (NJ_UINT16)(bit_all & 0x0007);
|
|
data_offset = GET_BITFIELD_32(data_l, j, bit_data);
|
|
|
|
bottom = data_offset;
|
|
break;
|
|
} else {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_B_SEARCH_WORD, NJ_ERR_DIC_BROKEN);
|
|
}
|
|
|
|
} else {
|
|
|
|
if (NODE_IDX_EXIST(node)) {
|
|
bit_all = 8;
|
|
} else {
|
|
bit_all = 4;
|
|
}
|
|
|
|
pos = (NJ_UINT16)(bit_all >> 3);
|
|
data_l = (NJ_UINT32)(NJ_INT32_READ(node + pos));
|
|
|
|
|
|
j = (NJ_UINT16)(bit_all & 0x0007);
|
|
|
|
|
|
node += GET_BITFIELD_32(data_l, j, bit_left);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
stem_data = data_top + bottom;
|
|
|
|
while (!(STEM_TERMINETER(stem_data))) {
|
|
next = get_stem_next(loctset->loct.handle, stem_data);
|
|
stem_data += next;
|
|
}
|
|
loctset->loct.bottom = (NJ_UINT32)(stem_data - data_top);
|
|
|
|
|
|
stem_data = data_top + loctset->loct.top;
|
|
|
|
hindo = (NJ_UINT16) *((NJ_UINT8*)(HINDO_NO_TOP_ADDR(loctset->loct.handle)
|
|
+ get_stem_hindo(loctset->loct.handle, stem_data)));
|
|
|
|
hindo_max = hindo;
|
|
hindo_max_data = 0;
|
|
|
|
if (condition->mode == NJ_CUR_MODE_FREQ) {
|
|
|
|
|
|
j = get_stem_next(loctset->loct.handle, stem_data);
|
|
current = j;
|
|
stem_data += j;
|
|
|
|
while (stem_data <= (data_top + loctset->loct.bottom)) {
|
|
|
|
|
|
hindo = (NJ_UINT16) *((NJ_UINT8*)(HINDO_NO_TOP_ADDR(loctset->loct.handle)
|
|
+ get_stem_hindo(loctset->loct.handle, stem_data)));
|
|
|
|
|
|
if (hindo > hindo_max) {
|
|
hindo_max = hindo;
|
|
hindo_max_data = current;
|
|
}
|
|
|
|
|
|
j = get_stem_next(loctset->loct.handle, stem_data);
|
|
current += j;
|
|
stem_data += j;
|
|
}
|
|
}
|
|
loctset->cache_freq = CALCULATE_HINDO(hindo_max, loctset->dic_freq.base,
|
|
loctset->dic_freq.high, COMP_DIC_FREQ_DIV);
|
|
loctset->loct.current = hindo_max_data;
|
|
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static NJ_INT16 bdic_search_data(NJ_SEARCH_CONDITION *condition, NJ_SEARCH_LOCATION_SET *loctset)
|
|
{
|
|
NJ_UINT8 *data, *data_end;
|
|
NJ_INT16 i, current = 0;
|
|
NJ_UINT16 hindo;
|
|
|
|
|
|
data = STEM_AREA_TOP_ADDR(loctset->loct.handle);
|
|
data += loctset->loct.top + loctset->loct.current;
|
|
|
|
if (GET_LOCATION_STATUS(loctset->loct.status) != NJ_ST_SEARCH_NO_INIT) {
|
|
|
|
if (STEM_TERMINETER(data)) {
|
|
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return 0;
|
|
}
|
|
|
|
|
|
i = get_stem_next(loctset->loct.handle, data);
|
|
|
|
data += i;
|
|
current += i;
|
|
}
|
|
|
|
if (NJ_GET_DIC_FMT(loctset->loct.handle) == NJ_DIC_FMT_KANAKAN) {
|
|
data_end = loctset->loct.handle
|
|
+ NJ_DIC_COMMON_HEADER_SIZE
|
|
+ NJ_INT32_READ(loctset->loct.handle + NJ_DIC_POS_DATA_SIZE)
|
|
+ NJ_INT32_READ(loctset->loct.handle + NJ_DIC_POS_EXT_SIZE)
|
|
- NJ_DIC_ID_LEN;
|
|
} else {
|
|
data_end = CAND_IDX_AREA_TOP_ADDR(loctset->loct.handle);
|
|
}
|
|
|
|
if (data < data_end) {
|
|
|
|
loctset->loct.status = NJ_ST_SEARCH_READY;
|
|
loctset->loct.current += current;
|
|
hindo = (NJ_UINT16) *((NJ_UINT8*)(HINDO_NO_TOP_ADDR(loctset->loct.handle) +
|
|
get_stem_hindo(loctset->loct.handle, data)));
|
|
loctset->cache_freq = CALCULATE_HINDO(hindo, loctset->dic_freq.base,
|
|
loctset->dic_freq.high, COMP_DIC_FREQ_DIV);
|
|
return 1;
|
|
}
|
|
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return 0;
|
|
}
|
|
|
|
static NJ_INT16 bdic_search_fore_data(NJ_SEARCH_CONDITION *condition, NJ_SEARCH_LOCATION_SET *loctset)
|
|
{
|
|
NJ_UINT8 *data, *data_top, *bottom, *data_end;
|
|
NJ_INT16 i = 0;
|
|
NJ_INT16 hindo = 0;
|
|
NJ_INT16 hindo_max = -1;
|
|
NJ_UINT8 no_hit = 0;
|
|
NJ_UINT32 current = loctset->loct.current;
|
|
NJ_UINT8 *current_org;
|
|
NJ_UINT32 hindo_data = 0;
|
|
|
|
|
|
|
|
if (GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_NO_INIT) {
|
|
loctset->loct.status = NJ_ST_SEARCH_READY;
|
|
loctset->loct.current_info = CURRENT_INFO_SET;
|
|
return 1;
|
|
}
|
|
|
|
|
|
data_top = STEM_AREA_TOP_ADDR(loctset->loct.handle);
|
|
|
|
|
|
data = data_top + loctset->loct.top + loctset->loct.current;
|
|
|
|
|
|
current_org = data;
|
|
|
|
|
|
bottom = data_top + loctset->loct.bottom;
|
|
|
|
if (NJ_GET_DIC_FMT(loctset->loct.handle) == NJ_DIC_FMT_KANAKAN) {
|
|
data_end = loctset->loct.handle
|
|
+ NJ_DIC_COMMON_HEADER_SIZE
|
|
+ NJ_INT32_READ(loctset->loct.handle + NJ_DIC_POS_DATA_SIZE)
|
|
+ NJ_INT32_READ(loctset->loct.handle + NJ_DIC_POS_EXT_SIZE)
|
|
- NJ_DIC_ID_LEN;
|
|
} else {
|
|
data_end = CAND_IDX_AREA_TOP_ADDR(loctset->loct.handle);
|
|
}
|
|
|
|
if (condition->mode == NJ_CUR_MODE_FREQ) {
|
|
|
|
|
|
|
|
while (data < data_end) {
|
|
|
|
i = get_stem_next(loctset->loct.handle, data);
|
|
data += i;
|
|
current += i;
|
|
|
|
|
|
if (data > bottom) {
|
|
if (loctset->cache_freq == 0) {
|
|
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return 0;
|
|
} else if (no_hit == 1) {
|
|
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return 0;
|
|
}
|
|
|
|
loctset->cache_freq -= 1;
|
|
|
|
|
|
data = data_top + loctset->loct.top;
|
|
current = 0;
|
|
|
|
no_hit = 1;
|
|
}
|
|
|
|
|
|
if ((hindo_max != -1) && (data == current_org)) {
|
|
loctset->loct.status = NJ_ST_SEARCH_READY;
|
|
loctset->loct.current_info = CURRENT_INFO_SET;
|
|
loctset->loct.current = hindo_data;
|
|
loctset->cache_freq = hindo_max;
|
|
return 1;
|
|
}
|
|
|
|
|
|
hindo = (NJ_INT16) *((NJ_UINT8*)(HINDO_NO_TOP_ADDR(loctset->loct.handle) + get_stem_hindo(loctset->loct.handle, data)));
|
|
|
|
hindo = CALCULATE_HINDO(hindo, loctset->dic_freq.base,
|
|
loctset->dic_freq.high, COMP_DIC_FREQ_DIV);
|
|
|
|
|
|
if (hindo == loctset->cache_freq) {
|
|
loctset->loct.status = NJ_ST_SEARCH_READY;
|
|
loctset->loct.current_info = CURRENT_INFO_SET;
|
|
loctset->loct.current = current;
|
|
return 1;
|
|
}
|
|
|
|
if (hindo < loctset->cache_freq) {
|
|
if (((hindo == hindo_max) && (current < hindo_data)) ||
|
|
(hindo > hindo_max)) {
|
|
hindo_max = hindo;
|
|
hindo_data = current;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
|
|
|
|
|
|
i = get_stem_next(loctset->loct.handle, data);
|
|
data += i;
|
|
current += i;
|
|
|
|
|
|
if (data > bottom) {
|
|
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return 0;
|
|
}
|
|
|
|
|
|
hindo = (NJ_INT16) *((NJ_UINT8*)(HINDO_NO_TOP_ADDR(loctset->loct.handle)
|
|
+ get_stem_hindo(loctset->loct.handle, data)));
|
|
loctset->cache_freq = CALCULATE_HINDO(hindo, loctset->dic_freq.base,
|
|
loctset->dic_freq.high, COMP_DIC_FREQ_DIV);
|
|
loctset->loct.status = NJ_ST_SEARCH_READY;
|
|
loctset->loct.current_info = CURRENT_INFO_SET;
|
|
loctset->loct.current = current;
|
|
return 1;
|
|
}
|
|
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return 0;
|
|
}
|
|
|
|
NJ_INT16 njd_b_search_word(NJ_SEARCH_CONDITION *con, NJ_SEARCH_LOCATION_SET *loctset)
|
|
{
|
|
NJ_INT16 ret;
|
|
NJ_DIC_INFO *pdicinfo;
|
|
NJ_UINT16 hIdx;
|
|
|
|
|
|
|
|
|
|
switch (con->operation) {
|
|
case NJ_CUR_OP_COMP:
|
|
|
|
if (con->mode != NJ_CUR_MODE_FREQ) {
|
|
|
|
loctset->loct.status = NJ_ST_SEARCH_END_EXT;
|
|
return 0;
|
|
}
|
|
break;
|
|
case NJ_CUR_OP_FORE:
|
|
|
|
if (APPEND_YOMI_FLG(loctset->loct.handle) == 0) {
|
|
loctset->loct.status = NJ_ST_SEARCH_END_EXT;
|
|
return 0;
|
|
}
|
|
|
|
if ((NJ_GET_DIC_TYPE_EX(loctset->loct.type, loctset->loct.handle) != NJ_DIC_TYPE_CUSTOM_COMPRESS)
|
|
&& NJ_CHAR_STRLEN_IS_0(con->yomi)) {
|
|
loctset->loct.status = NJ_ST_SEARCH_END_EXT;
|
|
return 0;
|
|
}
|
|
break;
|
|
default:
|
|
|
|
loctset->loct.status = NJ_ST_SEARCH_END_EXT;
|
|
return 0;
|
|
}
|
|
|
|
if (con->ylen > NJ_GET_MAX_YLEN(loctset->loct.handle)) {
|
|
loctset->loct.status = NJ_ST_SEARCH_END_EXT;
|
|
return 0;
|
|
}
|
|
|
|
if (GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_NO_INIT) {
|
|
|
|
|
|
switch (con->operation) {
|
|
case NJ_CUR_OP_COMP:
|
|
ret = search_node(con, loctset);
|
|
if (ret < 1) {
|
|
return ret;
|
|
}
|
|
ret = bdic_search_data(con, loctset);
|
|
if (ret < 1) {
|
|
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
}
|
|
break;
|
|
case NJ_CUR_OP_FORE:
|
|
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)) {
|
|
ret = search_node(con, loctset);
|
|
if (ret < 1) {
|
|
return ret;
|
|
}
|
|
ret = bdic_search_fore_data(con, loctset);
|
|
} else {
|
|
ret = search_node2(con, loctset, hIdx);
|
|
if (ret == NJ_SET_ERR_VAL(NJ_FUNC_NJD_B_SEARCH_WORD, NJ_ERR_CACHE_NOT_ENOUGH)) {
|
|
|
|
NJ_SET_CACHEOVER_TO_SCACHE(con->ds->dic[hIdx].srhCache);
|
|
ret = search_node2(con, loctset, hIdx);
|
|
}
|
|
if (ret < 1) {
|
|
return ret;
|
|
}
|
|
ret = bdic_search_fore_data2(con, loctset, hIdx);
|
|
}
|
|
if (ret < 1) {
|
|
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
}
|
|
break;
|
|
default:
|
|
loctset->loct.status = NJ_ST_SEARCH_END_EXT;
|
|
return 0;
|
|
}
|
|
} else if (GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_READY) {
|
|
|
|
switch (con->operation) {
|
|
case NJ_CUR_OP_COMP:
|
|
ret = bdic_search_data(con, loctset);
|
|
if (ret < 1) {
|
|
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
}
|
|
break;
|
|
case NJ_CUR_OP_FORE:
|
|
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)) {
|
|
ret = bdic_search_fore_data(con, loctset);
|
|
} else {
|
|
ret = bdic_search_fore_data2(con, loctset, hIdx);
|
|
}
|
|
if (ret < 1) {
|
|
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
}
|
|
break;
|
|
default:
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return 0;
|
|
}
|
|
} else {
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return 0;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
NJ_INT16 njd_b_get_word(NJ_SEARCH_LOCATION_SET *loctset, NJ_WORD *word)
|
|
{
|
|
NJ_UINT8 *data;
|
|
STEM_DATA_SET stem_set;
|
|
NJ_UINT8 check;
|
|
|
|
|
|
|
|
|
|
if (GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_END) {
|
|
return 0;
|
|
}
|
|
|
|
if (GET_LOCATION_OPERATION(loctset->loct.status) == NJ_CUR_OP_FORE) {
|
|
data = STEM_AREA_TOP_ADDR(loctset->loct.handle);
|
|
data += loctset->loct.top + loctset->loct.current;
|
|
|
|
|
|
check = 0;
|
|
} else {
|
|
|
|
|
|
|
|
data = STEM_AREA_TOP_ADDR(loctset->loct.handle);
|
|
data += loctset->loct.top + loctset->loct.current;
|
|
|
|
|
|
check = 2;
|
|
}
|
|
|
|
|
|
get_stem_word(loctset->loct.handle, data, &stem_set, check);
|
|
|
|
if (GET_LOCATION_OPERATION(loctset->loct.status) == NJ_CUR_OP_FORE) {
|
|
word->stem.info1 = (NJ_UINT16)(stem_set.yomi_size / sizeof(NJ_CHAR));
|
|
}
|
|
word->stem.info1 = WORD_LEN(word->stem.info1);
|
|
word->stem.info1 |= (NJ_UINT16)(stem_set.fhinsi_jitu << 7);
|
|
|
|
if (check != 1) {
|
|
if (stem_set.candidate_size == 0) {
|
|
|
|
if (GET_LOCATION_OPERATION(loctset->loct.status) == NJ_CUR_OP_FORE) {
|
|
word->stem.info2 = (NJ_UINT16)(stem_set.yomi_size / sizeof(NJ_CHAR));
|
|
} else {
|
|
|
|
word->stem.info2 = (NJ_UINT16)NJ_GET_YLEN_FROM_STEM(word);
|
|
}
|
|
} else {
|
|
|
|
word->stem.info2 = (NJ_UINT16)(stem_set.candidate_size / sizeof(NJ_CHAR));
|
|
}
|
|
} else {
|
|
|
|
word->stem.info2 = (NJ_UINT16)NJ_GET_YLEN_FROM_STEM(word);
|
|
}
|
|
|
|
word->stem.info2 = WORD_LEN(word->stem.info2);
|
|
word->stem.info2 |= (NJ_UINT16)(stem_set.bhinsi_jitu << 7);
|
|
word->stem.hindo = CALCULATE_HINDO(stem_set.hindo_jitu, loctset->dic_freq.base,
|
|
loctset->dic_freq.high, COMP_DIC_FREQ_DIV);
|
|
word->stem.loc = loctset->loct;
|
|
|
|
return 1;
|
|
}
|
|
|
|
NJ_INT16 njd_b_get_candidate(NJ_WORD *word, NJ_CHAR *candidate, NJ_UINT16 size)
|
|
{
|
|
NJ_SEARCH_LOCATION *loc;
|
|
NJ_CHAR *wkc, *cand;
|
|
NJ_UINT8 *wkd;
|
|
NJ_UINT8 *data;
|
|
NJ_UINT8 *data_org;
|
|
NJ_UINT16 len, j;
|
|
STEM_DATA_SET stem_set;
|
|
NJ_INT16 next;
|
|
NJ_UINT16 yomi_pos;
|
|
NJ_CHAR ybuf[NJ_MAX_LEN + NJ_TERM_LEN];
|
|
|
|
|
|
|
|
|
|
if ((GET_LOCATION_OPERATION(word->stem.loc.status) == NJ_CUR_OP_COMP) ||
|
|
(GET_LOCATION_OPERATION(word->stem.loc.status) == NJ_CUR_OP_FORE)) {
|
|
|
|
|
|
loc = &word->stem.loc;
|
|
data = STEM_AREA_TOP_ADDR(loc->handle);
|
|
data += loc->top + loc->current;
|
|
|
|
|
|
get_stem_cand_data(loc->handle, data, &stem_set);
|
|
len = stem_set.candidate_size / sizeof(NJ_CHAR);
|
|
|
|
} else {
|
|
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_B_GET_CANDIDATE, NJ_ERR_INVALID_RESULT);
|
|
}
|
|
|
|
if (len == 0) {
|
|
data_org = data;
|
|
|
|
if (GET_LOCATION_OPERATION(word->stem.loc.status) == NJ_CUR_OP_COMP) {
|
|
|
|
len = WORD_LEN(word->stem.info1);
|
|
if (size < ((len + NJ_TERM_LEN) * sizeof(NJ_CHAR))) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_B_GET_CANDIDATE, NJ_ERR_BUFFER_NOT_ENOUGH);
|
|
}
|
|
wkc = word->yomi;
|
|
} else {
|
|
|
|
|
|
|
|
while (!(STEM_TERMINETER(data))) {
|
|
next = get_stem_next(loc->handle, data);
|
|
data += next;
|
|
}
|
|
|
|
|
|
yomi_pos = get_stem_yomi_data(loc->handle, data, &stem_set);
|
|
|
|
|
|
wkc = ybuf;
|
|
len = get_stem_yomi_string(loc->handle, data, wkc,
|
|
yomi_pos, stem_set.yomi_size,
|
|
size);
|
|
|
|
|
|
if (size < ((len + NJ_TERM_LEN) * sizeof(NJ_CHAR))) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_B_GET_CANDIDATE, NJ_ERR_BUFFER_NOT_ENOUGH);
|
|
}
|
|
}
|
|
|
|
if (STEM_NO_CONV_FLG(data_org) == 0) {
|
|
cand = candidate;
|
|
for (j = 0; j < len; j++) {
|
|
*cand++ = *wkc++;
|
|
}
|
|
*cand = NJ_CHAR_NUL;
|
|
} else {
|
|
nje_convert_hira_to_kata(wkc, candidate, len);
|
|
}
|
|
|
|
} else {
|
|
|
|
if (size < (stem_set.candidate_size + (NJ_TERM_LEN*sizeof(NJ_CHAR)))) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_B_GET_CANDIDATE, NJ_ERR_BUFFER_NOT_ENOUGH);
|
|
}
|
|
wkc = candidate;
|
|
wkd = data + stem_set.stem_size;
|
|
for (j = 0; j < len; j++) {
|
|
NJ_CHAR_COPY(wkc, wkd);
|
|
wkd += sizeof(NJ_CHAR);
|
|
wkc++;
|
|
}
|
|
*wkc = NJ_CHAR_NUL;
|
|
}
|
|
|
|
return len;
|
|
}
|
|
|
|
NJ_INT16 njd_b_get_stroke(NJ_WORD *word, NJ_CHAR *stroke, NJ_UINT16 size)
|
|
{
|
|
NJ_SEARCH_LOCATION *loc;
|
|
NJ_UINT8 *data;
|
|
NJ_INT16 len;
|
|
NJ_INT16 next;
|
|
NJ_UINT16 yomi_pos;
|
|
STEM_DATA_SET stem_set;
|
|
|
|
|
|
|
|
|
|
if (GET_LOCATION_OPERATION(word->stem.loc.status) == NJ_CUR_OP_FORE) {
|
|
if (NJ_GET_YLEN_FROM_STEM(word) == 0) {
|
|
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_B_GET_STROKE, NJ_ERR_INVALID_RESULT);
|
|
}
|
|
|
|
|
|
loc = &word->stem.loc;
|
|
|
|
data = STEM_AREA_TOP_ADDR(loc->handle);
|
|
data += loc->top + loc->current;
|
|
|
|
} else {
|
|
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_B_GET_STROKE, NJ_ERR_INVALID_RESULT);
|
|
}
|
|
|
|
|
|
while (!(STEM_TERMINETER(data))) {
|
|
next = get_stem_next(loc->handle, data);
|
|
data += next;
|
|
}
|
|
|
|
|
|
yomi_pos = get_stem_yomi_data(loc->handle, data, &stem_set);
|
|
if (stem_set.yomi_size == 0) {
|
|
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_B_GET_STROKE, NJ_ERR_INVALID_RESULT);
|
|
}
|
|
|
|
|
|
len = get_stem_yomi_string(loc->handle, data, stroke,
|
|
yomi_pos, stem_set.yomi_size,
|
|
size);
|
|
|
|
|
|
if (size < (NJ_UINT16)((len+NJ_TERM_LEN)*sizeof(NJ_CHAR))) {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_B_GET_STROKE, NJ_ERR_BUFFER_NOT_ENOUGH);
|
|
}
|
|
|
|
*(stroke + len) = NJ_CHAR_NUL;
|
|
return len;
|
|
}
|
|
|
|
static NJ_INT16 search_node2(NJ_SEARCH_CONDITION *condition, NJ_SEARCH_LOCATION_SET *loctset, NJ_UINT16 hidx)
|
|
{
|
|
NJ_UINT8 *root, *now, *node, *node_mid;
|
|
NJ_CHAR *yomi;
|
|
|
|
NJ_INT16 ytbl_cnt;
|
|
NJ_UINT16 y;
|
|
NJ_UINT8 *ytbl_top;
|
|
|
|
NJ_UINT16 bit_left, bit_data;
|
|
NJ_UINT32 data_offset;
|
|
NJ_UINT16 j;
|
|
NJ_UINT8 *data_top, *stem_data;
|
|
NJ_UINT16 hindo, hindo_max, hindo_tmp;
|
|
NJ_UINT32 current, hindo_max_data, hindo_tmp_data;
|
|
|
|
|
|
NJ_SEARCH_CACHE *psrhCache = condition->ds->dic[hidx].srhCache;
|
|
NJ_CHAR *key;
|
|
NJ_UINT8 cmpflg;
|
|
NJ_UINT8 endflg;
|
|
NJ_UINT16 abPtrIdx;
|
|
NJ_UINT16 key_len;
|
|
NJ_UINT16 i, l, m;
|
|
NJ_UINT16 abIdx;
|
|
NJ_UINT16 abIdx_current;
|
|
NJ_UINT16 abIdx_old;
|
|
NJ_UINT16 addcnt = 0;
|
|
NJ_CHAR char_tmp[NJ_MAX_LEN + NJ_TERM_LEN];
|
|
NJ_UINT16 tmp_len;
|
|
NJ_UINT16 endIdx;
|
|
NJ_INT16 ret;
|
|
NJ_UINT8 *con_node;
|
|
NJ_UINT16 yomi_clen;
|
|
NJ_UINT8 aimai_flg = 0x01;
|
|
NJ_CHAR key_tmp[NJ_MAX_CHAR_LEN + NJ_TERM_LEN];
|
|
NJ_CACHE_INFO tmpbuff;
|
|
|
|
|
|
if (NJ_GET_CACHEOVER_FROM_SCACHE(psrhCache)) {
|
|
aimai_flg = 0x00;
|
|
}
|
|
|
|
node = NULL;
|
|
|
|
yomi = condition->yomi;
|
|
|
|
|
|
root = NODE_AREA_TOP_ADDR(loctset->loct.handle);
|
|
|
|
|
|
node_mid = root + NODE_AREA_MID_ADDR(loctset->loct.handle);
|
|
now = node_mid;
|
|
|
|
bit_left = BIT_NODE_AREA_LEFT_LEN(loctset->loct.handle);
|
|
bit_data = BIT_NODE_AREA_DATA_LEN(loctset->loct.handle);
|
|
|
|
ytbl_cnt = YOMI_INDX_CNT(loctset->loct.handle);
|
|
y = YOMI_INDX_SIZE(loctset->loct.handle);
|
|
ytbl_top = YOMI_INDX_TOP_ADDR(loctset->loct.handle);
|
|
|
|
data_top = STEM_AREA_TOP_ADDR(loctset->loct.handle);
|
|
|
|
|
|
endflg = 0x00;
|
|
cmpflg = 0x00;
|
|
abPtrIdx = 0;
|
|
key = condition->ds->keyword;
|
|
|
|
|
|
yomi_clen = condition->yclen;
|
|
for (i = 0; i < yomi_clen; i++) {
|
|
|
|
abPtrIdx = i;
|
|
|
|
|
|
if (!cmpflg) {
|
|
|
|
if (((abPtrIdx != 0) && (psrhCache->keyPtr[abPtrIdx] == 0))
|
|
|| (psrhCache->keyPtr[abPtrIdx + 1] == 0)) {
|
|
|
|
cmpflg = 0x01;
|
|
} else {
|
|
|
|
}
|
|
}
|
|
|
|
addcnt = 0;
|
|
if (cmpflg) {
|
|
|
|
if (abPtrIdx == 0) {
|
|
|
|
abIdx = 0;
|
|
|
|
nj_charncpy(key_tmp, yomi, 1);
|
|
key_len = nj_strlen(key_tmp);
|
|
|
|
node = NULL;
|
|
now = node_mid;
|
|
psrhCache->keyPtr[0] = 0;
|
|
|
|
|
|
ret = search_yomi_node(condition->operation,
|
|
node, now, 0, key_tmp, key_len,
|
|
root, node_mid, bit_left, bit_data,
|
|
data_top, ytbl_cnt, y, ytbl_top,
|
|
&tmpbuff,
|
|
&con_node, &data_offset);
|
|
|
|
if (ret < 0) {
|
|
|
|
} else {
|
|
|
|
|
|
|
|
psrhCache->storebuff[abIdx] = tmpbuff;
|
|
|
|
|
|
now = con_node;
|
|
|
|
psrhCache->storebuff[abIdx].top = data_offset;
|
|
|
|
if (condition->operation == NJ_CUR_OP_FORE) {
|
|
ret = get_node_bottom(key_tmp, now, node_mid, data_top,
|
|
bit_left, bit_data,
|
|
psrhCache->storebuff[abIdx].top,
|
|
loctset->loct.handle,
|
|
&(psrhCache->storebuff[abIdx].bottom));
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
}
|
|
}
|
|
addcnt++;
|
|
abIdx++;
|
|
}
|
|
|
|
if ((condition->charset != NULL) && aimai_flg) {
|
|
|
|
for (l = 0; l < condition->charset->charset_count; l++) {
|
|
|
|
if (nj_charncmp(key, condition->charset->from[l], 1) == 0) {
|
|
|
|
nj_strcpy(char_tmp, condition->charset->to[l]);
|
|
tmp_len = nj_strlen(char_tmp);
|
|
|
|
node = NULL;
|
|
now = node_mid;
|
|
|
|
|
|
ret = search_yomi_node(condition->operation,
|
|
node, now, 0, char_tmp, tmp_len,
|
|
root, node_mid, bit_left, bit_data,
|
|
data_top, ytbl_cnt, y, ytbl_top,
|
|
&tmpbuff,
|
|
&con_node, &data_offset);
|
|
|
|
if (ret < 0) {
|
|
|
|
} else {
|
|
|
|
|
|
|
|
if (abIdx >= NJ_SEARCH_CACHE_SIZE) {
|
|
psrhCache->keyPtr[abPtrIdx+1] = 0;
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_B_SEARCH_WORD, NJ_ERR_CACHE_NOT_ENOUGH);
|
|
}
|
|
|
|
|
|
psrhCache->storebuff[abIdx] = tmpbuff;
|
|
|
|
|
|
now = con_node;
|
|
|
|
psrhCache->storebuff[abIdx].top = data_offset;
|
|
|
|
if (condition->operation == NJ_CUR_OP_FORE) {
|
|
ret = get_node_bottom(key_tmp, now,
|
|
node_mid, data_top,
|
|
bit_left, bit_data,
|
|
psrhCache->storebuff[abIdx].top,
|
|
loctset->loct.handle,
|
|
&(psrhCache->storebuff[abIdx].bottom));
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
}
|
|
}
|
|
addcnt++;
|
|
abIdx++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
psrhCache->keyPtr[abPtrIdx + 1] = abIdx;
|
|
} else {
|
|
nj_charncpy(key_tmp, yomi, 1);
|
|
key_len = nj_strlen(key_tmp);
|
|
|
|
if (psrhCache->keyPtr[abPtrIdx] == psrhCache->keyPtr[abPtrIdx - 1]) {
|
|
|
|
psrhCache->keyPtr[abPtrIdx+1] = psrhCache->keyPtr[abPtrIdx-1];
|
|
endflg = 0x01;
|
|
} else {
|
|
endIdx = psrhCache->keyPtr[abPtrIdx];
|
|
abIdx_old = psrhCache->keyPtr[abPtrIdx - 1];
|
|
|
|
if (NJ_GET_CACHEOVER_FROM_SCACHE(psrhCache)) {
|
|
abIdx = psrhCache->keyPtr[abPtrIdx - 1];
|
|
psrhCache->keyPtr[abPtrIdx] = abIdx;
|
|
} else {
|
|
abIdx = psrhCache->keyPtr[abPtrIdx];
|
|
}
|
|
|
|
if ((abIdx > NJ_SEARCH_CACHE_SIZE) || (abIdx_old >= NJ_SEARCH_CACHE_SIZE)
|
|
|| (endIdx > NJ_SEARCH_CACHE_SIZE)) {
|
|
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_B_SEARCH_WORD, NJ_ERR_CACHE_BROKEN);
|
|
}
|
|
|
|
for (m = abIdx_old; m < endIdx; m++) {
|
|
node = psrhCache->storebuff[m].node;
|
|
now = psrhCache->storebuff[m].now;
|
|
|
|
if ((node == now) && (psrhCache->storebuff[m].idx_no == 0)) {
|
|
continue;
|
|
}
|
|
|
|
|
|
ret = search_yomi_node(condition->operation,
|
|
node, now, psrhCache->storebuff[m].idx_no,
|
|
key_tmp, key_len, root,
|
|
node_mid, bit_left, bit_data,
|
|
data_top, ytbl_cnt, y, ytbl_top,
|
|
&tmpbuff,
|
|
&con_node, &data_offset);
|
|
|
|
if (ret < 0) {
|
|
|
|
} else {
|
|
|
|
|
|
|
|
if (abIdx >= NJ_SEARCH_CACHE_SIZE) {
|
|
psrhCache->keyPtr[abPtrIdx+1] = 0;
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_B_SEARCH_WORD, NJ_ERR_CACHE_NOT_ENOUGH);
|
|
}
|
|
|
|
|
|
psrhCache->storebuff[abIdx] = tmpbuff;
|
|
|
|
|
|
now = con_node;
|
|
|
|
psrhCache->storebuff[abIdx].top = data_offset;
|
|
|
|
if (condition->operation == NJ_CUR_OP_FORE) {
|
|
ret = get_node_bottom(key_tmp, now, node_mid, data_top,
|
|
bit_left, bit_data,
|
|
psrhCache->storebuff[abIdx].top,
|
|
loctset->loct.handle,
|
|
&(psrhCache->storebuff[abIdx].bottom));
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
}
|
|
}
|
|
addcnt++;
|
|
abIdx++;
|
|
}
|
|
|
|
if ((condition->charset != NULL) && aimai_flg) {
|
|
|
|
for (l = 0; l < condition->charset->charset_count; l++) {
|
|
|
|
if (nj_charncmp(key, condition->charset->from[l], 1) == 0) {
|
|
|
|
nj_strcpy(char_tmp, condition->charset->to[l]);
|
|
|
|
tmp_len = nj_strlen(char_tmp);
|
|
|
|
node = psrhCache->storebuff[m].node;
|
|
now = psrhCache->storebuff[m].now;
|
|
|
|
|
|
ret = search_yomi_node(condition->operation,
|
|
node, now,
|
|
psrhCache->storebuff[m].idx_no,
|
|
char_tmp, tmp_len,
|
|
root, node_mid,
|
|
bit_left, bit_data, data_top,
|
|
ytbl_cnt, y, ytbl_top,
|
|
&tmpbuff,
|
|
&con_node, &data_offset);
|
|
|
|
if (ret < 0) {
|
|
|
|
} else {
|
|
|
|
|
|
|
|
if (abIdx >= NJ_SEARCH_CACHE_SIZE) {
|
|
psrhCache->keyPtr[abPtrIdx+1] = 0;
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_B_SEARCH_WORD, NJ_ERR_CACHE_NOT_ENOUGH);
|
|
}
|
|
|
|
|
|
psrhCache->storebuff[abIdx] = tmpbuff;
|
|
|
|
|
|
now = con_node;
|
|
|
|
psrhCache->storebuff[abIdx].top = data_offset;
|
|
|
|
if (condition->operation == NJ_CUR_OP_FORE) {
|
|
ret = get_node_bottom(key_tmp, now, node_mid,
|
|
data_top, bit_left, bit_data,
|
|
psrhCache->storebuff[abIdx].top,
|
|
loctset->loct.handle,
|
|
&(psrhCache->storebuff[abIdx].bottom));
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
}
|
|
}
|
|
addcnt++;
|
|
abIdx++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
psrhCache->keyPtr[abPtrIdx + 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;
|
|
}
|
|
|
|
loctset->loct.current = 0;
|
|
|
|
|
|
|
|
abPtrIdx = condition->yclen;
|
|
|
|
|
|
abIdx = psrhCache->keyPtr[abPtrIdx];
|
|
abIdx_old = psrhCache->keyPtr[abPtrIdx - 1];
|
|
if ((abIdx > NJ_SEARCH_CACHE_SIZE) || (abIdx_old >= NJ_SEARCH_CACHE_SIZE)) {
|
|
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_B_SEARCH_WORD, NJ_ERR_CACHE_BROKEN);
|
|
}
|
|
|
|
if (condition->mode == NJ_CUR_MODE_FREQ) {
|
|
hindo_max = 0;
|
|
hindo_max_data = 0;
|
|
abIdx_current = abIdx_old;
|
|
|
|
|
|
stem_data = data_top + psrhCache->storebuff[abIdx_current].top;
|
|
|
|
hindo = (NJ_UINT16) *((NJ_UINT8 *)(HINDO_NO_TOP_ADDR(loctset->loct.handle) +
|
|
get_stem_hindo(loctset->loct.handle, stem_data)));
|
|
|
|
hindo_tmp = 0;
|
|
hindo_tmp_data = 0;
|
|
current = 0;
|
|
|
|
|
|
while (stem_data <= (data_top + psrhCache->storebuff[abIdx_current].bottom)) {
|
|
|
|
if (hindo > hindo_tmp) {
|
|
hindo_tmp = hindo;
|
|
hindo_tmp_data = current;
|
|
}
|
|
|
|
|
|
j = get_stem_next(loctset->loct.handle, stem_data);
|
|
current += j;
|
|
stem_data += j;
|
|
|
|
|
|
hindo = (NJ_UINT16) *((NJ_UINT8 *) (HINDO_NO_TOP_ADDR(loctset->loct.handle) +
|
|
get_stem_hindo(loctset->loct.handle, stem_data)));
|
|
|
|
}
|
|
|
|
|
|
psrhCache->storebuff[abIdx_current].current = hindo_tmp_data;
|
|
|
|
|
|
if (hindo_tmp > hindo_max) {
|
|
hindo_max = hindo_tmp;
|
|
hindo_max_data = hindo_tmp_data;
|
|
}
|
|
} else {
|
|
|
|
abIdx_current = abIdx_old;
|
|
|
|
|
|
stem_data = data_top + psrhCache->storebuff[abIdx_current].top;
|
|
|
|
hindo = (NJ_UINT16) *((NJ_UINT8 *)(HINDO_NO_TOP_ADDR(loctset->loct.handle)
|
|
+ get_stem_hindo(loctset->loct.handle, stem_data)));
|
|
|
|
hindo_max = hindo;
|
|
hindo_max_data = 0;
|
|
}
|
|
|
|
|
|
loctset->loct.top = psrhCache->storebuff[abIdx_current].top;
|
|
loctset->loct.bottom = psrhCache->storebuff[abIdx_current].bottom;
|
|
|
|
loctset->cache_freq = CALCULATE_HINDO(hindo_max, loctset->dic_freq.base,
|
|
loctset->dic_freq.high, COMP_DIC_FREQ_DIV);
|
|
loctset->loct.current = hindo_max_data;
|
|
loctset->loct.current_cache = (NJ_UINT8)abIdx_current;
|
|
|
|
|
|
psrhCache->viewCnt = 1;
|
|
NJ_SET_AIMAI_TO_SCACHE(psrhCache);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static NJ_INT16 search_yomi_node(NJ_UINT8 operation, NJ_UINT8 *node, NJ_UINT8 *now,
|
|
NJ_UINT16 idx_no, NJ_CHAR *yomi, NJ_UINT16 yomilen,
|
|
NJ_UINT8 * root, NJ_UINT8 * node_mid,
|
|
NJ_UINT16 bit_left, NJ_UINT16 bit_data,
|
|
NJ_UINT8 * data_top,
|
|
NJ_INT16 ytbl_cnt, NJ_UINT16 y, NJ_UINT8 * ytbl_top,
|
|
NJ_CACHE_INFO * storebuf,
|
|
NJ_UINT8 ** con_node,
|
|
NJ_UINT32 * data_offset)
|
|
{
|
|
|
|
NJ_UINT8 index;
|
|
NJ_UINT8 *wkc;
|
|
NJ_UINT8 *byomi;
|
|
NJ_INT16 idx;
|
|
NJ_INT16 char_size;
|
|
NJ_INT16 left, right, mid;
|
|
NJ_UINT16 c, d;
|
|
NJ_UINT8 c1 = 0, c2 = 0;
|
|
NJ_UINT16 ysize = yomilen * sizeof(NJ_CHAR);
|
|
NJ_UINT16 idx_cnt;
|
|
NJ_UINT16 nd_index;
|
|
NJ_UINT16 data;
|
|
NJ_UINT16 pos, j, bit_all, bit_tmp, bit_idx;
|
|
NJ_UINT32 data_l;
|
|
NJ_UINT8 restart_flg = 0;
|
|
|
|
|
|
*con_node = NULL;
|
|
|
|
|
|
idx_cnt = 1;
|
|
storebuf->idx_no = 0;
|
|
|
|
byomi = (NJ_UINT8*)yomi;
|
|
|
|
|
|
while (ysize > 0) {
|
|
if (ytbl_cnt != 0) {
|
|
char_size = UTL_CHAR(byomi) * sizeof(NJ_CHAR);
|
|
if (char_size > 2) {
|
|
return -1;
|
|
}
|
|
|
|
|
|
|
|
if (char_size == 2) {
|
|
if (y == 1) {
|
|
return -1;
|
|
}
|
|
c1 = *byomi;
|
|
c2 = *(byomi + 1);
|
|
c = (NJ_UINT16)((c1 << 8) | c2);
|
|
} else {
|
|
|
|
c1 = *byomi;
|
|
c2 = 0x00;
|
|
c = (NJ_UINT16)(*byomi);
|
|
}
|
|
|
|
idx = -1;
|
|
left = 0;
|
|
right = ytbl_cnt;
|
|
|
|
if (y == 2) {
|
|
while (left <= right) {
|
|
mid = (left + right) >> 1;
|
|
wkc = ytbl_top + (mid << 1);
|
|
|
|
if (c1 == *wkc) {
|
|
if (c2 == *(wkc + 1)) {
|
|
idx = (NJ_UINT16) (mid + 1);
|
|
break;
|
|
}
|
|
if (c2 < *(wkc + 1)) {
|
|
right = mid - 1;
|
|
} else {
|
|
left = mid + 1;
|
|
}
|
|
} else if (c1 < *wkc) {
|
|
right = mid - 1;
|
|
} else {
|
|
left = mid + 1;
|
|
}
|
|
}
|
|
} else {
|
|
while (left <= right) {
|
|
mid = (left + right) >> 1;
|
|
wkc = ytbl_top + (mid * y);
|
|
d = (NJ_UINT16) (*wkc);
|
|
if (c == d) {
|
|
idx = (NJ_UINT16) (mid + 1);
|
|
break;
|
|
}
|
|
if (c < d) {
|
|
right = mid - 1;
|
|
} else {
|
|
left = mid + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (idx < 0) {
|
|
return -1;
|
|
}
|
|
index = (NJ_UINT8) idx;
|
|
} else {
|
|
index = *byomi;
|
|
char_size = 1;
|
|
}
|
|
|
|
byomi += char_size;
|
|
ysize -= char_size;
|
|
|
|
while (now < data_top) {
|
|
if (NODE_IDX_EXIST(now)) {
|
|
bit_idx = 8;
|
|
idx_cnt = NODE_IDX_CNT(now);
|
|
} else {
|
|
bit_idx = 4;
|
|
idx_cnt = 1;
|
|
}
|
|
bit_all = bit_idx;
|
|
|
|
|
|
if (NODE_LEFT_EXIST(now)) {
|
|
bit_all += bit_left;
|
|
}
|
|
|
|
|
|
if (NODE_DATA_EXIST(now)) {
|
|
bit_all += bit_data;
|
|
}
|
|
|
|
bit_tmp = bit_all;
|
|
|
|
|
|
bit_all += (NJ_UINT16) (idx_no << 3);
|
|
|
|
pos = (NJ_UINT16) (bit_all >> 3);
|
|
|
|
data = (NJ_UINT16) (NJ_INT16_READ(now + pos));
|
|
|
|
j = (NJ_UINT16) (bit_all & 0x0007);
|
|
|
|
nd_index = GET_BITFIELD_16(data, j, INDEX_BIT);
|
|
if (index == (NJ_UINT8) nd_index) {
|
|
|
|
break;
|
|
} else {
|
|
if ((!NODE_TERM(now)) && (index > (NJ_UINT8) nd_index) && (idx_no == 0)) {
|
|
|
|
now += GET_BIT_TO_BYTE(bit_tmp + (idx_cnt * 8));
|
|
if (now == node_mid) {
|
|
|
|
return -1;
|
|
}
|
|
continue;
|
|
} else {
|
|
if ((now == node_mid) && (restart_flg == 0)
|
|
&& (index < (NJ_UINT8) nd_index) && (idx_no == 0)
|
|
&& (root != node_mid)) {
|
|
now = root;
|
|
idx_no = 0;
|
|
restart_flg = 1;
|
|
continue;
|
|
}
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( (idx_cnt > (NJ_UINT16) (idx_no + 1))) {
|
|
if (ysize == 0) {
|
|
if (operation == NJ_CUR_OP_FORE) {
|
|
|
|
storebuf->node = now;
|
|
storebuf->now = now;
|
|
storebuf->idx_no = idx_no + 1;
|
|
node = now;
|
|
break;
|
|
}
|
|
return -2;
|
|
}
|
|
idx_no++;
|
|
continue;
|
|
}
|
|
|
|
node = now;
|
|
storebuf->node = now;
|
|
idx_no = 0;
|
|
|
|
if (ysize == 0) {
|
|
*con_node = now;
|
|
} else {
|
|
if (!(NODE_LEFT_EXIST(now))) {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
if (NODE_LEFT_EXIST(now)) {
|
|
if (NODE_IDX_EXIST(now)) {
|
|
bit_idx = 8;
|
|
} else {
|
|
bit_idx = 4;
|
|
}
|
|
pos = (NJ_UINT16) (bit_idx >> 3);
|
|
data_l = (NJ_UINT32) (NJ_INT32_READ(now + pos));
|
|
|
|
|
|
j = (NJ_UINT16) (bit_idx & 0x0007);
|
|
|
|
now += GET_BITFIELD_32(data_l, j, bit_left);
|
|
storebuf->now = now;
|
|
} else {
|
|
storebuf->now = now;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
if (*con_node == NULL) {
|
|
*con_node = now;
|
|
}
|
|
|
|
|
|
if ((node == NULL) || !(NODE_DATA_EXIST(node))) {
|
|
|
|
if ((operation == NJ_CUR_OP_FORE) && (node != NULL)) {
|
|
while (!NODE_DATA_EXIST(node)) {
|
|
if (!(NODE_LEFT_EXIST(node))) {
|
|
|
|
return -2;
|
|
}
|
|
|
|
if (NODE_IDX_EXIST(node)) {
|
|
bit_idx = 8;
|
|
} else {
|
|
bit_idx = 4;
|
|
}
|
|
pos = (NJ_UINT16) (bit_idx >> 3);
|
|
data_l = (NJ_UINT32) (NJ_INT32_READ(node + pos));
|
|
|
|
|
|
j = (NJ_UINT16) (bit_idx & 0x0007);
|
|
node += GET_BITFIELD_32(data_l, j, bit_left);
|
|
}
|
|
} else {
|
|
return -2;
|
|
}
|
|
}
|
|
|
|
if (NODE_IDX_EXIST(node)) {
|
|
bit_idx = 8;
|
|
} else {
|
|
bit_idx = 4;
|
|
}
|
|
|
|
|
|
if (NODE_LEFT_EXIST(node)) {
|
|
bit_all = bit_idx + bit_left;
|
|
} else {
|
|
bit_all = bit_idx;
|
|
}
|
|
|
|
pos = (NJ_UINT16) (bit_all >> 3);
|
|
data_l = (NJ_UINT32) (NJ_INT32_READ(node + pos));
|
|
|
|
|
|
j = (NJ_UINT16) (bit_all & 0x0007);
|
|
*data_offset = GET_BITFIELD_32(data_l, j, bit_data);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static NJ_INT16 get_node_bottom(NJ_CHAR * yomi, NJ_UINT8 * now, NJ_UINT8 * node_mid,
|
|
NJ_UINT8 * data_top, NJ_UINT16 bit_left, NJ_UINT16 bit_data,
|
|
NJ_UINT32 top, NJ_DIC_HANDLE handle,
|
|
NJ_UINT32 * ret_bottom)
|
|
{
|
|
NJ_UINT8 *node;
|
|
NJ_UINT16 idx_cnt;
|
|
NJ_UINT32 data_offset;
|
|
NJ_UINT16 pos, j, bit_all;
|
|
NJ_UINT32 data_l;
|
|
NJ_UINT8 bottom_flg = 0;
|
|
NJ_UINT8 *stem_data;
|
|
NJ_UINT32 bottom, next;
|
|
|
|
|
|
|
|
bottom = top;
|
|
|
|
if (NJ_CHAR_STRLEN_IS_0(yomi)) {
|
|
node = node_mid;
|
|
|
|
} else {
|
|
|
|
node = now;
|
|
if (NODE_LEFT_EXIST(node)) {
|
|
|
|
if (NODE_IDX_EXIST(node)) {
|
|
bit_all = 8;
|
|
} else {
|
|
bit_all = 4;
|
|
}
|
|
|
|
pos = (NJ_UINT16) (bit_all >> 3);
|
|
data_l = (NJ_UINT32) (NJ_INT32_READ(node + pos));
|
|
|
|
|
|
j = (NJ_UINT16) (bit_all & 0x0007);
|
|
node += GET_BITFIELD_32(data_l, j, bit_left);
|
|
|
|
} else {
|
|
bottom_flg = 1;
|
|
}
|
|
}
|
|
|
|
|
|
if (!bottom_flg) {
|
|
while (node < data_top) {
|
|
|
|
if (!NODE_TERM(node)) {
|
|
|
|
if (NODE_IDX_EXIST(node)) {
|
|
bit_all = 8;
|
|
idx_cnt = NODE_IDX_CNT(node);
|
|
} else {
|
|
bit_all = 4;
|
|
idx_cnt = 1;
|
|
}
|
|
|
|
|
|
if (NODE_LEFT_EXIST(node)) {
|
|
bit_all += bit_left;
|
|
}
|
|
|
|
|
|
if (NODE_DATA_EXIST(node)) {
|
|
bit_all += bit_data;
|
|
}
|
|
|
|
|
|
node += GET_BIT_TO_BYTE(bit_all + (idx_cnt * 8));
|
|
} else {
|
|
|
|
if (!NODE_LEFT_EXIST(node)) {
|
|
|
|
if (NODE_DATA_EXIST(node)) {
|
|
|
|
if (NODE_IDX_EXIST(node)) {
|
|
bit_all = 8;
|
|
} else {
|
|
bit_all = 4;
|
|
}
|
|
|
|
pos = (NJ_UINT16) (bit_all >> 3);
|
|
data_l = (NJ_UINT32) (NJ_INT32_READ(node + pos));
|
|
|
|
|
|
j = (NJ_UINT16) (bit_all & 0x0007);
|
|
data_offset = GET_BITFIELD_32(data_l, j, bit_data);
|
|
|
|
bottom = data_offset;
|
|
break;
|
|
} else {
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_B_SEARCH_WORD, NJ_ERR_DIC_BROKEN);
|
|
}
|
|
|
|
} else {
|
|
|
|
if (NODE_IDX_EXIST(node)) {
|
|
bit_all = 8;
|
|
} else {
|
|
bit_all = 4;
|
|
}
|
|
|
|
pos = (NJ_UINT16) (bit_all >> 3);
|
|
data_l = (NJ_UINT32) (NJ_INT32_READ(node + pos));
|
|
|
|
|
|
j = (NJ_UINT16) (bit_all & 0x0007);
|
|
|
|
|
|
node += GET_BITFIELD_32(data_l, j, bit_left);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
stem_data = data_top + bottom;
|
|
|
|
while (!(STEM_TERMINETER(stem_data))) {
|
|
next = get_stem_next(handle, stem_data);
|
|
stem_data += next;
|
|
}
|
|
*ret_bottom = (NJ_UINT32) (stem_data - data_top);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static NJ_INT16 bdic_search_fore_data2(NJ_SEARCH_CONDITION *condition, NJ_SEARCH_LOCATION_SET *loctset, NJ_UINT16 hidx)
|
|
{
|
|
NJ_UINT8 *data, *data_top, *bottom, *data_end;
|
|
NJ_INT16 i = 0;
|
|
NJ_INT16 hindo = 0;
|
|
NJ_UINT32 current = loctset->loct.current;
|
|
|
|
|
|
NJ_SEARCH_CACHE *psrhCache = condition->ds->dic[hidx].srhCache;
|
|
|
|
NJ_UINT16 top_abIdx;
|
|
NJ_UINT16 bottom_abIdx;
|
|
NJ_UINT16 count_abIdx;
|
|
NJ_UINT16 current_abIdx;
|
|
NJ_UINT16 old_abIdx;
|
|
NJ_UINT8 freq_flag = 0;
|
|
NJ_INT16 save_hindo = 0;
|
|
NJ_UINT16 save_abIdx = 0;
|
|
NJ_UINT16 abPtrIdx;
|
|
NJ_UINT16 m;
|
|
NJ_INT16 ret;
|
|
NJ_INT16 loop_check;
|
|
|
|
NJ_UINT16 abIdx;
|
|
NJ_UINT16 abIdx_old;
|
|
NJ_UINT16 hindo_max, hindo_tmp;
|
|
NJ_UINT32 hindo_max_data, hindo_tmp_data;
|
|
NJ_UINT16 abIdx_current;
|
|
|
|
|
|
|
|
|
|
if (GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_NO_INIT) {
|
|
loctset->loct.status = NJ_ST_SEARCH_READY;
|
|
loctset->loct.current_info = CURRENT_INFO_SET;
|
|
return 1;
|
|
}
|
|
|
|
if (NJ_GET_AIMAI_FROM_SCACHE(psrhCache)) {
|
|
NJ_UNSET_AIMAI_TO_SCACHE(psrhCache);
|
|
|
|
data_top = STEM_AREA_TOP_ADDR(loctset->loct.handle);
|
|
if (condition->operation == NJ_CUR_OP_FORE) {
|
|
if (condition->ylen) {
|
|
|
|
abPtrIdx = condition->yclen;
|
|
|
|
|
|
abIdx = psrhCache->keyPtr[abPtrIdx];
|
|
abIdx_old = psrhCache->keyPtr[abPtrIdx - 1];
|
|
if ((abIdx > NJ_SEARCH_CACHE_SIZE) || (abIdx_old >= NJ_SEARCH_CACHE_SIZE)) {
|
|
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_B_SEARCH_WORD, NJ_ERR_CACHE_BROKEN);
|
|
}
|
|
|
|
if (condition->mode == NJ_CUR_MODE_FREQ) {
|
|
hindo_max = 0;
|
|
hindo_max_data = 0;
|
|
abIdx_current = abIdx_old;
|
|
|
|
for (m = abIdx_old; m < abIdx; m++) {
|
|
|
|
data = data_top + psrhCache->storebuff[m].top;
|
|
|
|
hindo = (NJ_UINT16) *((NJ_UINT8 *)(HINDO_NO_TOP_ADDR(loctset->loct.handle) +
|
|
get_stem_hindo(loctset->loct.handle, data)));
|
|
|
|
hindo_tmp = 0;
|
|
hindo_tmp_data = 0;
|
|
current = 0;
|
|
|
|
|
|
while (data <= (data_top + psrhCache->storebuff[m].bottom)) {
|
|
|
|
if (hindo > hindo_tmp) {
|
|
hindo_tmp = hindo;
|
|
hindo_tmp_data = current;
|
|
}
|
|
|
|
|
|
i = get_stem_next(loctset->loct.handle, data);
|
|
current += i;
|
|
data += i;
|
|
|
|
|
|
hindo = (NJ_UINT16) *((NJ_UINT8 *) (HINDO_NO_TOP_ADDR(loctset->loct.handle) +
|
|
get_stem_hindo(loctset->loct.handle, data)));
|
|
|
|
}
|
|
|
|
|
|
psrhCache->storebuff[m].current = hindo_tmp_data;
|
|
|
|
|
|
if (hindo_tmp > hindo_max) {
|
|
hindo_max = hindo_tmp;
|
|
hindo_max_data = hindo_tmp_data;
|
|
abIdx_current = m;
|
|
}
|
|
}
|
|
} else {
|
|
|
|
abIdx_current = abIdx_old;
|
|
|
|
|
|
data = data_top + psrhCache->storebuff[abIdx_current].top;
|
|
|
|
hindo = (NJ_UINT16) *((NJ_UINT8 *)(HINDO_NO_TOP_ADDR(loctset->loct.handle)
|
|
+ get_stem_hindo(loctset->loct.handle, data)));
|
|
|
|
hindo_max = hindo;
|
|
hindo_max_data = 0;
|
|
}
|
|
|
|
|
|
loctset->loct.top = psrhCache->storebuff[abIdx_current].top;
|
|
loctset->loct.bottom = psrhCache->storebuff[abIdx_current].bottom;
|
|
|
|
loctset->cache_freq = CALCULATE_HINDO(hindo_max, loctset->dic_freq.base,
|
|
loctset->dic_freq.high, COMP_DIC_FREQ_DIV);
|
|
loctset->loct.current = hindo_max_data;
|
|
loctset->loct.current_cache = (NJ_UINT8)abIdx_current;
|
|
|
|
|
|
psrhCache->viewCnt = 1;
|
|
} else {
|
|
|
|
data = data_top + loctset->loct.top;
|
|
|
|
hindo = (NJ_UINT16) *((NJ_UINT8 *)(HINDO_NO_TOP_ADDR(loctset->loct.handle) +
|
|
get_stem_hindo(loctset->loct.handle, data)));
|
|
|
|
hindo_max = hindo;
|
|
hindo_max_data = 0;
|
|
|
|
if (condition->mode == NJ_CUR_MODE_FREQ) {
|
|
|
|
|
|
i = get_stem_next(loctset->loct.handle, data);
|
|
current = i;
|
|
data += i;
|
|
|
|
|
|
while (data <= (data_top + loctset->loct.bottom)) {
|
|
|
|
|
|
hindo = (NJ_UINT16)*((NJ_UINT8 *)(HINDO_NO_TOP_ADDR(loctset->loct.handle) +
|
|
get_stem_hindo(loctset->loct.handle, data)));
|
|
|
|
|
|
if (hindo > hindo_max) {
|
|
hindo_max = hindo;
|
|
hindo_max_data = current;
|
|
}
|
|
|
|
|
|
i = get_stem_next(loctset->loct.handle, data);
|
|
current += i;
|
|
data += i;
|
|
}
|
|
}
|
|
loctset->cache_freq = CALCULATE_HINDO(hindo_max,
|
|
loctset->dic_freq.base,
|
|
loctset->dic_freq.high, COMP_DIC_FREQ_DIV);
|
|
loctset->loct.current = hindo_max_data;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
|
|
data_top = STEM_AREA_TOP_ADDR(loctset->loct.handle);
|
|
|
|
|
|
data = data_top + loctset->loct.top + loctset->loct.current;
|
|
|
|
|
|
|
|
bottom = data_top + loctset->loct.bottom;
|
|
|
|
if (NJ_GET_DIC_FMT(loctset->loct.handle) == NJ_DIC_FMT_KANAKAN) {
|
|
data_end = loctset->loct.handle
|
|
+ NJ_DIC_COMMON_HEADER_SIZE
|
|
+ NJ_INT32_READ(loctset->loct.handle + NJ_DIC_POS_DATA_SIZE)
|
|
+ NJ_INT32_READ(loctset->loct.handle + NJ_DIC_POS_EXT_SIZE)
|
|
- NJ_DIC_ID_LEN;
|
|
} else {
|
|
data_end = CAND_IDX_AREA_TOP_ADDR(loctset->loct.handle);
|
|
}
|
|
|
|
if (condition->mode == NJ_CUR_MODE_FREQ) {
|
|
|
|
|
|
abPtrIdx = condition->yclen;
|
|
|
|
|
|
bottom_abIdx = psrhCache->keyPtr[abPtrIdx];
|
|
top_abIdx = psrhCache->keyPtr[abPtrIdx - 1];
|
|
if ((bottom_abIdx > NJ_SEARCH_CACHE_SIZE) || (top_abIdx >= NJ_SEARCH_CACHE_SIZE)) {
|
|
|
|
return NJ_SET_ERR_VAL(NJ_FUNC_NJD_B_SEARCH_WORD, NJ_ERR_CACHE_BROKEN);
|
|
}
|
|
|
|
|
|
count_abIdx = bottom_abIdx - top_abIdx;
|
|
if (!count_abIdx) {
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return 0;
|
|
}
|
|
|
|
old_abIdx = loctset->loct.current_cache;
|
|
|
|
loop_check = 0;
|
|
|
|
|
|
ret = bdic_get_next_data(data_top, data_end, loctset, psrhCache, old_abIdx);
|
|
|
|
if (ret == loctset->cache_freq) {
|
|
|
|
psrhCache->viewCnt++;
|
|
if (psrhCache->viewCnt <= NJ_CACHE_VIEW_CNT) {
|
|
|
|
loctset->loct.status = NJ_ST_SEARCH_READY;
|
|
loctset->loct.current_info = CURRENT_INFO_SET;
|
|
loctset->loct.current = psrhCache->storebuff[old_abIdx].current;
|
|
loctset->loct.current_cache = (NJ_UINT8)old_abIdx;
|
|
return 1;
|
|
} else {
|
|
|
|
freq_flag = 1;
|
|
psrhCache->viewCnt = 0;
|
|
}
|
|
} else {
|
|
if (ret == -1) {
|
|
|
|
loop_check++;
|
|
}
|
|
save_hindo = ret;
|
|
save_abIdx = old_abIdx;
|
|
}
|
|
|
|
|
|
current_abIdx = old_abIdx + 1;
|
|
if (current_abIdx >= bottom_abIdx) {
|
|
|
|
current_abIdx = top_abIdx;
|
|
}
|
|
|
|
while (loop_check != count_abIdx) {
|
|
|
|
|
|
ret = bdic_get_word_freq(data_top, loctset, psrhCache, current_abIdx);
|
|
|
|
if ((ret == loctset->cache_freq) &&
|
|
(loctset->loct.top == psrhCache->storebuff[current_abIdx].top) &&
|
|
(loctset->loct.current == psrhCache->storebuff[current_abIdx].current)) {
|
|
ret = bdic_get_next_data(data_top, data_end, loctset, psrhCache, current_abIdx);
|
|
}
|
|
|
|
if (ret == loctset->cache_freq) {
|
|
|
|
loctset->loct.status = NJ_ST_SEARCH_READY;
|
|
loctset->loct.current_info = CURRENT_INFO_SET;
|
|
loctset->loct.top = psrhCache->storebuff[current_abIdx].top;
|
|
loctset->loct.bottom = psrhCache->storebuff[current_abIdx].bottom;
|
|
loctset->loct.current = psrhCache->storebuff[current_abIdx].current;
|
|
loctset->loct.current_cache = (NJ_UINT8)current_abIdx;
|
|
psrhCache->viewCnt = 1;
|
|
return 1;
|
|
|
|
} else {
|
|
if (ret == -1) {
|
|
|
|
loop_check++;
|
|
}
|
|
if (save_hindo < ret) {
|
|
|
|
save_hindo = ret;
|
|
save_abIdx = current_abIdx;
|
|
}
|
|
}
|
|
|
|
|
|
current_abIdx++;
|
|
if (current_abIdx >= bottom_abIdx) {
|
|
|
|
current_abIdx = top_abIdx;
|
|
}
|
|
|
|
|
|
if (current_abIdx == old_abIdx) {
|
|
if (freq_flag == 1) {
|
|
|
|
loctset->loct.status = NJ_ST_SEARCH_READY;
|
|
loctset->loct.current_info = CURRENT_INFO_SET;
|
|
loctset->loct.top = psrhCache->storebuff[current_abIdx].top;
|
|
loctset->loct.bottom = psrhCache->storebuff[current_abIdx].bottom;
|
|
loctset->loct.current = psrhCache->storebuff[current_abIdx].current;
|
|
loctset->loct.current_cache = (NJ_UINT8)current_abIdx;
|
|
psrhCache->viewCnt = 1;
|
|
return 1;
|
|
} else if (save_hindo != -1) {
|
|
|
|
loctset->cache_freq = save_hindo;
|
|
loctset->loct.status = NJ_ST_SEARCH_READY;
|
|
loctset->loct.current_info = CURRENT_INFO_SET;
|
|
loctset->loct.top = psrhCache->storebuff[save_abIdx].top;
|
|
loctset->loct.bottom = psrhCache->storebuff[save_abIdx].bottom;
|
|
loctset->loct.current = psrhCache->storebuff[save_abIdx].current;
|
|
loctset->loct.current_cache = (NJ_UINT8)save_abIdx;
|
|
psrhCache->viewCnt = 1;
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
|
|
|
|
|
|
i = get_stem_next(loctset->loct.handle, data);
|
|
data += i;
|
|
current += i;
|
|
|
|
|
|
if (data > bottom) {
|
|
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return 0;
|
|
}
|
|
|
|
|
|
hindo = (NJ_INT16)*((NJ_UINT8 *)(HINDO_NO_TOP_ADDR(loctset->loct.handle)
|
|
+ get_stem_hindo(loctset->loct.handle, data)));
|
|
loctset->cache_freq = CALCULATE_HINDO(hindo, loctset->dic_freq.base,
|
|
loctset->dic_freq.high, COMP_DIC_FREQ_DIV);
|
|
loctset->loct.status = NJ_ST_SEARCH_READY;
|
|
loctset->loct.current_info = CURRENT_INFO_SET;
|
|
loctset->loct.current = current;
|
|
return 1;
|
|
}
|
|
|
|
loctset->loct.status = NJ_ST_SEARCH_END;
|
|
return 0;
|
|
}
|
|
|
|
static NJ_INT16 bdic_get_next_data(NJ_UINT8 *data_top, NJ_UINT8 *data_end,
|
|
NJ_SEARCH_LOCATION_SET *loctset,
|
|
NJ_SEARCH_CACHE *psrhCache,
|
|
NJ_UINT16 abIdx)
|
|
{
|
|
NJ_UINT8 *data, *bottom;
|
|
NJ_INT16 i = 0;
|
|
NJ_INT16 hindo = 0;
|
|
NJ_INT16 hindo_max = -1;
|
|
NJ_UINT8 no_hit = 0;
|
|
NJ_UINT32 current = psrhCache->storebuff[abIdx].current;
|
|
NJ_UINT8 *current_org;
|
|
NJ_UINT32 hindo_data = 0;
|
|
NJ_INT16 freq_org = loctset->cache_freq;
|
|
|
|
|
|
if (psrhCache->storebuff[abIdx].current == LOC_CURRENT_NO_ENTRY) {
|
|
return (-1);
|
|
}
|
|
|
|
|
|
data = data_top + psrhCache->storebuff[abIdx].top + psrhCache->storebuff[abIdx].current;
|
|
|
|
|
|
current_org = data;
|
|
|
|
|
|
bottom = data_top + psrhCache->storebuff[abIdx].bottom;
|
|
|
|
|
|
|
|
|
|
while (data < data_end) {
|
|
|
|
i = get_stem_next(loctset->loct.handle, data);
|
|
data += i;
|
|
current += i;
|
|
|
|
|
|
if (data > bottom) {
|
|
if ((freq_org == 0) || (no_hit == 1)) {
|
|
|
|
psrhCache->storebuff[abIdx].current = LOC_CURRENT_NO_ENTRY;
|
|
return -1;
|
|
}
|
|
|
|
freq_org -= 1;
|
|
|
|
|
|
data = data_top + psrhCache->storebuff[abIdx].top;
|
|
current = 0;
|
|
|
|
no_hit = 1;
|
|
}
|
|
|
|
|
|
if ((hindo_max != -1) && (data == current_org)) {
|
|
psrhCache->storebuff[abIdx].current = hindo_data;
|
|
return hindo_max;
|
|
}
|
|
|
|
|
|
hindo = (NJ_INT16)*((NJ_UINT8 *)(HINDO_NO_TOP_ADDR(loctset->loct.handle)
|
|
+ get_stem_hindo(loctset->loct.handle, data)));
|
|
|
|
hindo = CALCULATE_HINDO(hindo, loctset->dic_freq.base, loctset->dic_freq.high, COMP_DIC_FREQ_DIV);
|
|
|
|
|
|
if (hindo == freq_org) {
|
|
psrhCache->storebuff[abIdx].current = current;
|
|
return hindo;
|
|
}
|
|
|
|
if (hindo < freq_org) {
|
|
if ((hindo > hindo_max) || ((hindo == hindo_max) && (current < hindo_data))) {
|
|
hindo_max = hindo;
|
|
hindo_data = current;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
psrhCache->storebuff[abIdx].current = LOC_CURRENT_NO_ENTRY;
|
|
return -1;
|
|
}
|
|
|
|
static NJ_INT16 bdic_get_word_freq(NJ_UINT8 * data_top, NJ_SEARCH_LOCATION_SET * loctset,
|
|
NJ_SEARCH_CACHE * psrhCache, NJ_UINT16 abIdx)
|
|
{
|
|
NJ_UINT8 *data;
|
|
NJ_INT16 hindo = 0;
|
|
|
|
|
|
if (psrhCache->storebuff[abIdx].current != LOC_CURRENT_NO_ENTRY) {
|
|
|
|
data = data_top + psrhCache->storebuff[abIdx].top + psrhCache->storebuff[abIdx].current;
|
|
|
|
|
|
hindo = (NJ_INT16)*((NJ_UINT8 *)(HINDO_NO_TOP_ADDR(loctset->loct.handle)
|
|
+ get_stem_hindo(loctset->loct.handle, data)));
|
|
|
|
hindo = CALCULATE_HINDO(hindo, loctset->dic_freq.base, loctset->dic_freq.high, COMP_DIC_FREQ_DIV);
|
|
|
|
} else {
|
|
|
|
hindo = -1;
|
|
}
|
|
|
|
return hindo;
|
|
}
|