Google Git
Sign in
android / platform / packages / inputmethods / OpenWnn / 59aefa242169b7a51c2381daee58ff22fd1834ce / . / libs / libwnnDictionary / engine / ndbdic.c
blob: 6cf73da713952f276b365c5655f1e86ad1b72dff [file] [log] [blame]
/*
* 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;
}