1/*
2 * Copyright (C) 2008-2012  OMRON SOFTWARE Co., Ltd.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "nj_lib.h"
18#include "nj_err.h"
19#include "nj_ext.h"
20#include "nj_dic.h"
21#include "njd.h"
22#ifdef NJ_LEARN_MUHENKAN_DEBUG
23#include <stdio.h>
24#include <def_mojicode.h>
25#endif
26#ifdef NJ_AWNN22_DEBUG
27#include <stdio.h>
28#include <def_mojicode.h>
29#endif
30
31#define QUE_TYPE_EMPTY  0
32#define QUE_TYPE_NEXT   0
33#define QUE_TYPE_JIRI   1
34#define QUE_TYPE_FZK    2
35#define POS_DATA_OFFSET  0x20
36#define POS_LEARN_WORD   0x24
37#define POS_MAX_WORD     0x28
38#define POS_QUE_SIZE     0x2C
39#define POS_NEXT_QUE     0x30
40#define POS_WRITE_FLG    0x34
41#define POS_INDEX_OFFSET        0x3C
42#define POS_INDEX_OFFSET2       0x40
43
44#define LEARN_INDEX_TOP_ADDR(x) ((x) + (NJ_INT32_READ((x) + POS_INDEX_OFFSET)))
45#define LEARN_INDEX_TOP_ADDR2(x) ((x) + (NJ_INT32_READ((x) + POS_INDEX_OFFSET2)))
46#define LEARN_DATA_TOP_ADDR(x)  ((x) + (NJ_INT32_READ((x) + POS_DATA_OFFSET)))
47
48#define LEARN_INDEX_BOTTOM_ADDR(x) (LEARN_DATA_TOP_ADDR(x) - 1)
49
50#define LEARN_QUE_STRING_OFFSET 5
51
52#define ADDRESS_TO_POS(x,adr)   (((adr) - LEARN_DATA_TOP_ADDR(x)) / QUE_SIZE(x))
53#define POS_TO_ADDRESS(x,pos)   (LEARN_DATA_TOP_ADDR(x) + QUE_SIZE(x) * (pos))
54
55#define GET_UINT16(ptr) ((((NJ_UINT16)(*(ptr))) << 8) | (*((ptr) + 1) & 0x00ff))
56
57#define GET_FPOS_FROM_DATA(x) ((NJ_UINT16)NJ_INT16_READ((x)+1) >> 7)
58#define GET_YSIZE_FROM_DATA(x) ((NJ_UINT8)((NJ_UINT16)NJ_INT16_READ((x)+1) & 0x7F))
59#define GET_BPOS_FROM_DATA(x) ((NJ_UINT16)NJ_INT16_READ((x)+3) >> 7)
60#define GET_KSIZE_FROM_DATA(x) ((NJ_UINT8)((NJ_UINT16)NJ_INT16_READ((x)+3) & 0x7F))
61#define GET_BPOS_FROM_EXT_DATA(x) ((NJ_UINT16)NJ_INT16_READ(x) >> 7)
62#define GET_YSIZE_FROM_EXT_DATA(x) ((NJ_UINT8)((NJ_UINT16)NJ_INT16_READ(x) & 0x7F))
63
64#define SET_BPOS_AND_YSIZE(x,bpos,ysize)                                \
65    NJ_INT16_WRITE((x), ((NJ_UINT16)((bpos) << 7) | ((ysize) & 0x7F)))
66#define SET_FPOS_AND_YSIZE(x,fpos,ysize)                                \
67    NJ_INT16_WRITE(((x)+1), ((NJ_UINT16)((fpos) << 7) | ((ysize) & 0x7F)))
68#define SET_BPOS_AND_KSIZE(x,bpos,ksize)                                \
69    NJ_INT16_WRITE(((x)+3), ((NJ_UINT16)((bpos) << 7) | ((ksize) & 0x7F)))
70
71#define GET_TYPE_FROM_DATA(x) (*(x) & 0x03)
72#define GET_UFLG_FROM_DATA(x) (*(x) >> 7)
73#define GET_FFLG_FROM_DATA(x) ((*(x) >> 6) & 0x01)
74#define GET_MFLG_FROM_DATA(x) (*(x) & 0x10)
75
76#define SET_TYPE_UFLG_FFLG(x,type,u,f)                                  \
77    (*(x) = (NJ_UINT8)(((type) & 0x03) |                                \
78                       (((u) & 0x01) << 7) | (((f) & 0x01) << 6)))
79#define SET_TYPE_ALLFLG(x,type,u,f,m)                                   \
80    (*(x) = (NJ_UINT8)(((type) & 0x03) |                                \
81                       (((u) & 0x01) << 7) | (((f) & 0x01) << 6) | (((m) & 0x01) << 4)))
82
83#define RESET_FFLG(x) (*(x) &= 0xbf)
84
85#define STATE_COPY(to, from)                                    \
86    { ((NJ_UINT8*)(to))[0] = ((NJ_UINT8*)(from))[0];            \
87        ((NJ_UINT8*)(to))[1] = ((NJ_UINT8*)(from))[1];          \
88        ((NJ_UINT8*)(to))[2] = ((NJ_UINT8*)(from))[2];          \
89        ((NJ_UINT8*)(to))[3] = ((NJ_UINT8*)(from))[3]; }
90
91#define USE_QUE_NUM(que_size, str_size)    \
92    ( (((str_size) % ((que_size) - 1)) == 0)                           \
93      ? ((str_size) / ((que_size) - 1))                                \
94      : ((str_size) / ((que_size) - 1) + 1) )
95
96#define NEXT_QUE(que, max)  ( ((que) < ((max) - 1)) ? ((que) + 1) : 0 )
97
98#define PREV_QUE(que, max)  ( ((que) == 0) ? ((max) - 1) : ((que) - 1) )
99
100#define COPY_QUE(handle, src, dst)                                      \
101    nj_memcpy(POS_TO_ADDRESS((handle), (dst)), POS_TO_ADDRESS((handle), (src)), QUE_SIZE(handle))
102
103
104#define INIT_HINDO          (-10000)
105
106#define LOC_CURRENT_NO_ENTRY  0xffffffffU
107
108
109
110static NJ_WQUE *get_que(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT16 que_id);
111static NJ_INT16 is_continued(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT16 que_id);
112static NJ_UINT16 search_next_que(NJ_DIC_HANDLE handle, NJ_UINT16 que_id);
113static NJ_INT16 que_strcmp_complete_with_hyouki(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT16 que_id, NJ_CHAR *yomi, NJ_UINT16 yomi_len, NJ_CHAR *hyouki, NJ_UINT8 multi_flg);
114static NJ_CHAR  *get_string(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT16 que_id, NJ_UINT8 *slen);
115static NJ_CHAR  *get_hyouki(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT16 que_id, NJ_UINT8 *slen);
116static NJ_INT16 get_cand_by_sequential(NJ_CLASS *iwnn, NJ_SEARCH_CONDITION *cond, NJ_SEARCH_LOCATION_SET *loctset, NJ_UINT8 search_pattern, NJ_UINT8 comp_flg);
117static NJ_INT16 get_cand_by_evaluate(NJ_CLASS *iwnn, NJ_SEARCH_CONDITION *cond, NJ_SEARCH_LOCATION_SET *loctset, NJ_UINT8 search_pattern);
118static NJ_INT16 get_cand_by_evaluate2(NJ_CLASS *iwnn, NJ_SEARCH_CONDITION *cond, NJ_SEARCH_LOCATION_SET *loctset, NJ_UINT8 search_pattern, NJ_UINT16 hIdx);
119static NJ_INT16 search_range_by_yomi(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT8 op, NJ_CHAR *yomi, NJ_UINT16 ylen, NJ_UINT16 *from, NJ_UINT16 *to, NJ_UINT8 *forward_flag);
120static NJ_INT16 search_range_by_yomi2(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT8 op, NJ_CHAR *yomi, NJ_UINT16 ylen, NJ_UINT16 sfrom, NJ_UINT16 sto, NJ_UINT16 *from, NJ_UINT16 *to,
121                                      NJ_UINT8 *forward_flag);
122static NJ_INT16 search_range_by_yomi_multi(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_CHAR *yomi, NJ_UINT16 ylen, NJ_UINT16 *from, NJ_UINT16 *to);
123static NJ_INT16 str_que_cmp(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_CHAR *yomi, NJ_UINT16 yomiLen, NJ_UINT16 que_id, NJ_UINT8 mode);
124static NJ_WQUE *get_que_type_and_next(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT16 que_id);
125static NJ_WQUE *get_que_allHinsi(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT16 que_id);
126static NJ_WQUE *get_que_yomiLen_and_hyoukiLen(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT16 que_id);
127static NJ_INT16 continue_cnt(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT16 que_id);
128
129static NJ_UINT8 *get_search_index_address(NJ_DIC_HANDLE handle, NJ_UINT8 search_pattern);
130
131static NJ_HINDO get_hindo(NJ_CLASS *iwnn, NJ_SEARCH_LOCATION_SET *loctset, NJ_UINT8 search_pattern);
132
133static NJ_HINDO calculate_hindo(NJ_DIC_HANDLE handle, NJ_INT32 freq, NJ_DIC_FREQ *dic_freq, NJ_INT16 freq_max, NJ_INT16 freq_min);
134static NJ_INT16 que_strcmp_include(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT16 que_id, NJ_CHAR *yomi);
135
136#define GET_LEARN_MAX_WORD_COUNT(h) ((NJ_UINT16)NJ_INT32_READ((h) + POS_MAX_WORD))
137
138#define GET_LEARN_WORD_COUNT(h)                         \
139    ((NJ_UINT16)NJ_INT32_READ((h) + POS_LEARN_WORD))
140#define SET_LEARN_WORD_COUNT(h, n)                      \
141    NJ_INT32_WRITE((h)+POS_LEARN_WORD, (NJ_UINT32)(n))
142#define GET_LEARN_NEXT_WORD_POS(h)                      \
143    ((NJ_UINT16)NJ_INT32_READ((h) + POS_NEXT_QUE))
144#define SET_LEARN_NEXT_WORD_POS(h, id)                  \
145    NJ_INT32_WRITE((h)+POS_NEXT_QUE, (NJ_UINT32)(id))
146#define QUE_SIZE(h)     ((NJ_UINT16)NJ_INT32_READ((h) + POS_QUE_SIZE))
147
148#define COPY_UINT16(dst,src)    (*(NJ_UINT16 *)(dst) = *(NJ_UINT16 *)(src))
149
150static NJ_UINT8 *get_search_index_address(NJ_DIC_HANDLE handle, NJ_UINT8 search_pattern) {
151
152
153
154    return LEARN_INDEX_TOP_ADDR(handle);
155}
156
157NJ_INT16 njd_l_search_word(NJ_CLASS *iwnn, NJ_SEARCH_CONDITION *con,
158                           NJ_SEARCH_LOCATION_SET *loctset,
159                           NJ_UINT8 comp_flg) {
160
161    NJ_UINT16    word_count;
162    NJ_UINT32    type;
163    NJ_DIC_INFO *pdicinfo;
164    NJ_UINT16    hIdx;
165    NJ_INT16     ret;
166
167
168    word_count = GET_LEARN_WORD_COUNT(loctset->loct.handle);
169    if (word_count == 0) {
170
171        loctset->loct.status = NJ_ST_SEARCH_END_EXT;
172        return 0;
173    }
174
175    type = NJ_GET_DIC_TYPE_EX(loctset->loct.type, loctset->loct.handle);
176
177    if (type == NJ_DIC_TYPE_CUSTOM_INCOMPRESS) {
178        if ((con->operation == NJ_CUR_OP_COMP) ||
179            (con->operation == NJ_CUR_OP_FORE)){
180
181            if (con->ylen > NJ_GET_MAX_YLEN(loctset->loct.handle)) {
182                loctset->loct.status = NJ_ST_SEARCH_END_EXT;
183                return 0;
184            }
185        }
186    }
187
188
189    switch (con->operation) {
190    case NJ_CUR_OP_COMP:
191        if (con->mode != NJ_CUR_MODE_FREQ) {
192
193            loctset->loct.status = NJ_ST_SEARCH_END_EXT;
194            break;
195        }
196
197
198        return get_cand_by_sequential(iwnn, con, loctset, con->operation, comp_flg);
199
200    case NJ_CUR_OP_FORE:
201
202        if (con->mode == NJ_CUR_MODE_YOMI) {
203
204            return get_cand_by_sequential(iwnn, con, loctset, con->operation, 0);
205        } else {
206
207
208            pdicinfo = con->ds->dic;
209            for (hIdx = 0; (hIdx < NJ_MAX_DIC) && (pdicinfo->handle != loctset->loct.handle); hIdx++) {
210                pdicinfo++;
211            }
212
213            if (hIdx == NJ_MAX_DIC) {
214
215                loctset->loct.status = NJ_ST_SEARCH_END;
216                return 0;
217            }
218
219
220
221            if ((con->ds->dic[hIdx].srhCache == NULL) || (con->ylen == 0) ||
222                !(con->ds->mode & 0x0001)) {
223                return get_cand_by_evaluate(iwnn, con, loctset, con->operation);
224            } else {
225                ret = get_cand_by_evaluate2(iwnn, con, loctset, con->operation, hIdx);
226                if (ret == NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_CACHE_NOT_ENOUGH)) {
227
228                    NJ_SET_CACHEOVER_TO_SCACHE(con->ds->dic[hIdx].srhCache);
229                    ret = get_cand_by_evaluate2(iwnn, con, loctset, con->operation, hIdx);
230                }
231                return ret;
232            }
233        }
234
235    case NJ_CUR_OP_LINK:
236
237        if (NJ_GET_DIC_TYPE_EX(loctset->loct.type, loctset->loct.handle) == NJ_DIC_TYPE_USER) {
238
239            loctset->loct.status = NJ_ST_SEARCH_END_EXT;
240            break;
241        }
242        if (con->mode != NJ_CUR_MODE_FREQ) {
243
244            loctset->loct.status = NJ_ST_SEARCH_END_EXT;
245            break;
246        }
247
248        if (comp_flg == 0) {
249
250            return get_cand_by_sequential(iwnn, con, loctset, con->operation, 0);
251        } else {
252
253            return get_cand_by_evaluate(iwnn, con, loctset, con->operation);
254        }
255
256    default:
257        loctset->loct.status = NJ_ST_SEARCH_END_EXT;
258    }
259
260    return 0;
261}
262
263static NJ_WQUE *get_que_type_and_next(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle,
264                                      NJ_UINT16 que_id) {
265    NJ_UINT8 *ptr;
266    NJ_WQUE *que = &(iwnn->que_tmp);
267
268
269    if (que_id >= GET_LEARN_MAX_WORD_COUNT(handle)) {
270        return NULL;
271    }
272
273    ptr = POS_TO_ADDRESS(handle, que_id);
274
275    que->type = GET_TYPE_FROM_DATA(ptr);
276    que->next_flag  = GET_FFLG_FROM_DATA(ptr);
277
278    switch (que->type) {
279    case QUE_TYPE_EMPTY:
280    case QUE_TYPE_JIRI:
281    case QUE_TYPE_FZK:
282        return que;
283    default:
284        break;
285    }
286#ifdef LEARN_DEBUG
287    printf("FATAL : Illegal que was gotten (que_id=%d)\n", que_id);
288#endif
289    return NULL;
290}
291
292static NJ_WQUE *get_que_yomiLen_and_hyoukiLen(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle,
293                                              NJ_UINT16 que_id) {
294    NJ_UINT8 *ptr;
295    NJ_WQUE *que = &(iwnn->que_tmp);
296
297
298    if (que_id >= GET_LEARN_MAX_WORD_COUNT(handle)) {
299        return NULL;
300    }
301
302    ptr = POS_TO_ADDRESS(handle, que_id);
303
304    que->type        = GET_TYPE_FROM_DATA(ptr);
305    que->yomi_byte   = GET_YSIZE_FROM_DATA(ptr);
306    que->yomi_len    = que->yomi_byte / sizeof(NJ_CHAR);
307    que->hyouki_byte = GET_KSIZE_FROM_DATA(ptr);
308    que->hyouki_len  = que->hyouki_byte / sizeof(NJ_CHAR);
309
310    switch (que->type) {
311    case QUE_TYPE_JIRI:
312    case QUE_TYPE_FZK:
313        return que;
314    default:
315        break;
316    }
317#ifdef LEARN_DEBUG
318    printf("FATAL : Illegal que was gotten (que_id=%d)\n", que_id);
319#endif
320    return NULL;
321}
322
323static NJ_WQUE *get_que_allHinsi(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle,
324                                 NJ_UINT16 que_id) {
325    NJ_UINT8 *ptr;
326    NJ_WQUE *que = &(iwnn->que_tmp);
327
328
329    if (que_id >= GET_LEARN_MAX_WORD_COUNT(handle)) {
330        return NULL;
331    }
332
333    ptr = POS_TO_ADDRESS(handle, que_id);
334
335    que->type      = GET_TYPE_FROM_DATA(ptr);
336    que->mae_hinsi = GET_FPOS_FROM_DATA(ptr);
337    que->ato_hinsi = GET_BPOS_FROM_DATA(ptr);
338
339    switch (que->type) {
340    case QUE_TYPE_JIRI:
341    case QUE_TYPE_FZK:
342        return que;
343    default:
344        break;
345    }
346#ifdef LEARN_DEBUG
347    printf("FATAL : Illegal que was gotten (que_id=%d)\n", que_id);
348#endif
349    return NULL;
350}
351
352static NJ_WQUE *get_que(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT16 que_id) {
353    NJ_UINT8 *ptr;
354    NJ_WQUE *que = &(iwnn->que_tmp);
355
356
357    if (que_id >= GET_LEARN_MAX_WORD_COUNT(handle)) {
358        return NULL;
359    }
360
361    ptr = POS_TO_ADDRESS(handle, que_id);
362
363    que->entry      = que_id;
364    que->type       = GET_TYPE_FROM_DATA(ptr);
365    que->mae_hinsi  = GET_FPOS_FROM_DATA(ptr);
366    que->ato_hinsi  = GET_BPOS_FROM_DATA(ptr);
367    que->yomi_byte  = GET_YSIZE_FROM_DATA(ptr);
368    que->yomi_len   = que->yomi_byte / sizeof(NJ_CHAR);
369    que->hyouki_byte= GET_KSIZE_FROM_DATA(ptr);
370    que->hyouki_len = que->hyouki_byte / sizeof(NJ_CHAR);
371    que->next_flag  = GET_FFLG_FROM_DATA(ptr);
372
373    switch (que->type) {
374    case QUE_TYPE_JIRI:
375    case QUE_TYPE_FZK:
376        return que;
377    default:
378        break;
379    }
380#ifdef LEARN_DEBUG
381    printf("FATAL : Illegal que was gotten (que_id=%d)\n", que_id);
382#endif
383    return NULL;
384}
385
386static NJ_INT16 is_continued(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT16 que_id) {
387    NJ_WQUE *que;
388    NJ_UINT16 i;
389    NJ_UINT16 max, end;
390
391
392    max = GET_LEARN_MAX_WORD_COUNT(handle);
393    end = GET_LEARN_NEXT_WORD_POS(handle);
394
395    for (i = 0; i < max; i++) {
396        que_id++;
397        if (que_id >= GET_LEARN_MAX_WORD_COUNT(handle)) {
398
399            que_id = 0;
400        }
401
402
403        if (que_id == end) {
404
405            return 0;
406        }
407
408        que = get_que_type_and_next(iwnn, handle, que_id);
409#ifdef IWNN_ERR_CHECK
410        if (iwnn->err_check_flg == 1) {
411            que = NULL;
412        }
413#endif
414        if (que == NULL) {
415            return NJ_SET_ERR_VAL(NJ_FUNC_IS_CONTINUED, NJ_ERR_DIC_BROKEN);
416        }
417        if (que->type != QUE_TYPE_EMPTY) {
418
419            if (que->next_flag != 0) {
420
421                return 1;
422            } else {
423
424                return 0;
425            }
426        }
427    }
428
429
430    return 0;
431}
432
433static NJ_INT16 continue_cnt(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT16 que_id) {
434    NJ_WQUE *que;
435    NJ_UINT16 i;
436    NJ_UINT16 max, end;
437    NJ_INT16 cnt = 0;
438
439
440    max = GET_LEARN_MAX_WORD_COUNT(handle);
441    end = GET_LEARN_NEXT_WORD_POS(handle);
442
443    for (i = 0; i < max; i++) {
444        que_id++;
445        if (que_id >= max) {
446
447            que_id = 0;
448        }
449
450
451        if (que_id == end) {
452
453            return cnt;
454        }
455
456        que = get_que_type_and_next(iwnn, handle, que_id);
457        if (que == NULL) {
458            return NJ_SET_ERR_VAL(NJ_FUNC_CONTINUE_CNT, NJ_ERR_DIC_BROKEN);
459        }
460        if (que->type != QUE_TYPE_EMPTY) {
461
462            if (que->next_flag != 0) {
463
464                cnt++;
465
466
467                if (cnt >= (NJD_MAX_CONNECT_CNT - 1)) {
468                    return cnt;
469                }
470            } else {
471
472                return cnt;
473            }
474        }
475    }
476
477
478    return 0;
479}
480
481static NJ_UINT16 search_next_que(NJ_DIC_HANDLE handle, NJ_UINT16 que_id) {
482    NJ_UINT16 max;
483    NJ_UINT16 i;
484
485
486    max = GET_LEARN_MAX_WORD_COUNT(handle);
487
488    for (i = 0; i < max; i++) {
489        que_id++;
490        if (que_id >= max) {
491
492            que_id = 0;
493        }
494
495        if (GET_TYPE_FROM_DATA(POS_TO_ADDRESS(handle, que_id)) != QUE_TYPE_EMPTY) {
496
497            return que_id;
498        }
499    }
500
501
502    return 0;
503}
504
505static NJ_INT16 que_strcmp_complete_with_hyouki(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle,
506                                                NJ_UINT16 que_id, NJ_CHAR *yomi, NJ_UINT16 yomi_len, NJ_CHAR *hyouki,
507                                                NJ_UINT8 multi_flg) {
508    NJ_CHAR *str;
509    NJ_INT16 ret;
510    NJ_UINT8 slen;
511    NJ_UINT16 hyouki_len;
512    NJ_UINT16 que_yomilen, que_hyoukilen;
513    NJ_INT16 que_count = 1;
514    NJ_INT16 cnt = 0;
515
516
517
518    hyouki_len = nj_strlen(hyouki);
519
520    if (multi_flg == 0) {
521
522        cnt = 1;
523    } else {
524
525
526        cnt = GET_LEARN_WORD_COUNT(handle);
527    }
528
529    while (cnt--) {
530        str = get_string(iwnn, handle, que_id, &slen);
531        if (str == NULL) {
532            return NJ_SET_ERR_VAL(NJ_FUNC_QUE_STRCMP_COMPLETE_WITH_HYOUKI,
533                                  NJ_ERR_DIC_BROKEN);
534        }
535        que_yomilen = slen;
536
537        ret = nj_strncmp(yomi, str, que_yomilen);
538        if (ret != 0) {
539
540            return 0;
541        }
542
543        str = get_hyouki(iwnn, handle, que_id, &slen);
544        if (str == NULL) {
545            return NJ_SET_ERR_VAL(NJ_FUNC_QUE_STRCMP_COMPLETE_WITH_HYOUKI,
546                                  NJ_ERR_DIC_BROKEN);
547        }
548        que_hyoukilen = slen;
549
550        ret = nj_strncmp(hyouki, str, que_hyoukilen);
551        if (ret != 0) {
552
553            return 0;
554        }
555
556        if ((yomi_len == que_yomilen) &&
557            (hyouki_len == que_hyoukilen)) {
558
559            return que_count;
560        }
561
562        if ((que_yomilen > yomi_len) ||
563            (que_hyoukilen > hyouki_len)) {
564
565            return 0;
566        }
567
568        ret = is_continued(iwnn, handle, que_id);
569        if (ret <= 0) {
570
571            return ret;
572        }
573
574
575        if (que_count >= (NJD_MAX_CONNECT_CNT - 1)) {
576
577            return 0;
578        }
579
580        yomi_len -= que_yomilen;
581        yomi     += que_yomilen;
582
583        hyouki_len -= que_hyoukilen;
584        hyouki     += que_hyoukilen;
585
586
587        que_id = search_next_que(handle, que_id);
588        que_count++;
589    }
590    return 0;
591}
592
593static NJ_INT16 que_strcmp_include(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle,
594                                   NJ_UINT16 que_id, NJ_CHAR *yomi) {
595    NJ_CHAR *str;
596    NJ_UINT16 que_len;
597    NJ_UINT16 yomi_len;
598    NJ_INT16 ret;
599    NJ_INT16 que_count = 1;
600    NJ_UINT16 i = 0;
601    NJ_UINT8 slen;
602
603
604#ifdef LEARN_DEBUG
605    printf("que_strcmp_include(que_id=%d, yomi=[%s])\n", que_id, yomi);
606#endif
607    yomi_len = nj_strlen(yomi);
608    if (yomi_len == 0) {
609        return que_count;
610    }
611
612    i = GET_LEARN_WORD_COUNT(handle);
613
614    while (--i) {
615
616
617        ret = is_continued(iwnn, handle, que_id);
618        if (ret < 0) {
619
620            return ret;
621        } else if (ret == 0) {
622
623            return que_count;
624        }
625
626
627        que_id = search_next_que(handle, que_id);
628
629        str = get_string(iwnn, handle, que_id, &slen);
630#ifdef IWNN_ERR_CHECK
631        if (iwnn->err_check_flg == 2) {
632            str = NULL;
633        }
634#endif
635        if (str == NULL) {
636            return NJ_SET_ERR_VAL(NJ_FUNC_QUE_STRCMP_INCLUDE, NJ_ERR_DIC_BROKEN);
637        }
638        que_len = slen;
639
640
641        if (que_len > yomi_len) {
642#ifdef LEARN_DEBUG
643            printf("  >> mismatch [%s] (que_len > yomi_len)\n", str);
644#endif
645            return que_count;
646        }
647
648
649        ret = nj_strncmp(yomi, str, que_len);
650        if (ret != 0) {
651#ifdef LEARN_DEBUG
652            printf("  >> mismatch [%s]\n", str);
653#endif
654
655            return que_count;
656        }
657
658
659        if (que_len == yomi_len) {
660#ifdef LEARN_DEBUG
661            printf("  >> match! [%s](%d)\n", str, que_count);
662#endif
663            return (que_count + 1);
664        }
665
666        que_count++;
667        if (que_count >= NJD_MAX_CONNECT_CNT) {
668
669            return que_count;
670        }
671
672
673        yomi_len -= que_len;
674        yomi     += que_len;
675    }
676
677    return que_count;
678}
679
680static NJ_CHAR *get_string(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle,
681                           NJ_UINT16 que_id, NJ_UINT8 *slen) {
682    NJ_UINT8 *src, *dst;
683    NJ_UINT8 copy_size, size;
684    NJ_UINT8 i;
685    NJ_UINT8 *top_addr;
686    NJ_UINT8 *bottom_addr;
687    NJ_UINT16 que_size;
688
689
690    src = POS_TO_ADDRESS(handle, que_id);
691    switch (GET_TYPE_FROM_DATA(src)) {
692    case QUE_TYPE_JIRI:
693    case QUE_TYPE_FZK:
694        size =  GET_YSIZE_FROM_DATA(src);
695        *slen = (NJ_UINT8)(size / sizeof(NJ_CHAR));
696        break;
697
698    default:
699#ifdef LEARN_DEBUG
700        printf("get_string(handle=%p, que_id=%d) : broken que\n", handle, que_id);
701#endif
702        return NULL;
703    }
704
705    if (NJ_GET_DIC_TYPE(handle) == NJ_DIC_TYPE_USER) {
706        if (*slen > NJ_MAX_USER_LEN) {
707            return NULL;
708        }
709    } else {
710        if (*slen > NJ_MAX_LEN) {
711            return NULL;
712        }
713    }
714
715
716    src += LEARN_QUE_STRING_OFFSET;
717
718    que_size = QUE_SIZE(handle);
719
720
721    copy_size = (NJ_UINT8)que_size - LEARN_QUE_STRING_OFFSET;
722    dst = (NJ_UINT8*)&(iwnn->learn_string_tmp[0]);
723    if (copy_size > size) {
724
725        copy_size = size;
726    }
727    for (i = 0; i < copy_size; i++) {
728        *dst++ = *src++;
729    }
730
731
732    top_addr = LEARN_DATA_TOP_ADDR(handle);
733    bottom_addr = top_addr;
734    bottom_addr += que_size * GET_LEARN_MAX_WORD_COUNT(handle) - 1;
735
736    while (size -= copy_size) {
737
738        if (src >= bottom_addr) {
739            src = top_addr;
740        }
741
742
743        if (*src != QUE_TYPE_NEXT) {
744#ifdef LEARN_DEBUG
745            printf("FATAL: src que was broken(not QUE_TYPE_NEXT) [src=%x]\n", src);
746#endif
747            return NULL;
748        }
749
750        src++;
751        if (size < que_size) {
752
753            copy_size = size;
754        } else {
755            copy_size = (NJ_UINT8)(que_size - 1);
756        }
757        for (i = 0; i < copy_size; i++) {
758            *dst++ = *src++;
759        }
760    }
761    iwnn->learn_string_tmp[*slen] = NJ_CHAR_NUL;
762
763    return &(iwnn->learn_string_tmp[0]);
764}
765
766static NJ_CHAR *get_hyouki(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle,
767                           NJ_UINT16 que_id, NJ_UINT8 *slen) {
768    NJ_UINT8 *src, *dst;
769    NJ_WQUE *que;
770    NJ_UINT8 copy_size, size;
771    NJ_UINT8 i;
772    NJ_UINT8 *top_addr;
773    NJ_UINT8 *bottom_addr;
774    NJ_CHAR  *hira;
775    NJ_UINT16 que_size;
776    NJ_UINT32 dictype;
777
778
779    que = get_que_yomiLen_and_hyoukiLen(iwnn, handle, que_id);
780    if (que == NULL) {
781        return NULL;
782    }
783
784    dictype = NJ_GET_DIC_TYPE(handle);
785    if (dictype == NJ_DIC_TYPE_USER) {
786        if (que->yomi_len > NJ_MAX_USER_LEN) {
787            return NULL;
788        }
789        if (que->hyouki_len > NJ_MAX_USER_KOUHO_LEN) {
790            return NULL;
791        }
792    } else {
793        if (que->yomi_len > NJ_MAX_LEN) {
794            return NULL;
795        }
796        if (que->hyouki_len > NJ_MAX_RESULT_LEN) {
797            return NULL;
798        }
799    }
800
801    src = POS_TO_ADDRESS(handle, que_id);
802
803    if (que->hyouki_len == 0) {
804        hira = get_string(iwnn, handle, que_id, slen);
805        if (hira == NULL) {
806            return NULL;
807        }
808
809        if (GET_MFLG_FROM_DATA(src) != 0) {
810            *slen = (NJ_UINT8)nje_convert_hira_to_kata(hira, &(iwnn->muhenkan_tmp[0]), *slen);
811            return &(iwnn->muhenkan_tmp[0]);
812        } else {
813            return hira;
814        }
815    }
816
817    src += LEARN_QUE_STRING_OFFSET;
818
819    que_size = QUE_SIZE(handle);
820
821
822    size = que->yomi_byte;
823    copy_size = (NJ_UINT8)que_size - LEARN_QUE_STRING_OFFSET;
824    dst = (NJ_UINT8*)&(iwnn->learn_string_tmp[0]);
825    if (copy_size > size) {
826
827        copy_size = size;
828    }
829
830
831    top_addr = LEARN_DATA_TOP_ADDR(handle);
832    bottom_addr = top_addr;
833    bottom_addr += que_size * GET_LEARN_MAX_WORD_COUNT(handle) - 1;
834
835    src += copy_size;
836    while (size -= copy_size) {
837
838
839        if (src >= bottom_addr) {
840            src = top_addr;
841        }
842
843
844        if (*src != QUE_TYPE_NEXT) {
845#ifdef LEARN_DEBUG
846            printf("FATAL: src que was broken(not QUE_TYPE_NEXT) [src=%x]\n", src);
847#endif
848            return NULL;
849        }
850
851        src++;
852        if (size < que_size) {
853
854            copy_size = size;
855        } else {
856            copy_size = (NJ_UINT8)(que_size - 1);
857        }
858        src += copy_size;
859    }
860
861
862
863    if (((src - top_addr) % que_size) == 0) {
864
865        if (src >= bottom_addr) {
866            src = top_addr;
867        }
868
869        if (*src++ != QUE_TYPE_NEXT) {
870#ifdef LEARN_DEBUG
871            printf("FATAL: src que was broken(QUE_TYPE_NEXT) [src=%x]\n", src - 1);
872#endif
873            return NULL;
874        }
875    }
876
877    size = que->hyouki_byte;
878
879
880    copy_size = (NJ_UINT8)(que_size);
881    copy_size -= (NJ_UINT8)((src - top_addr) % que_size);
882    if (copy_size > size) {
883
884        copy_size = size;
885    }
886    for (i = 0; i < copy_size; i++) {
887        *dst++ = *src++;
888    }
889
890    while (size -= copy_size) {
891
892
893        if (src >= bottom_addr) {
894            src = top_addr;
895        }
896
897
898        if (*src != QUE_TYPE_NEXT) {
899#ifdef LEARN_DEBUG
900            printf("FATAL: src que was broken(not QUE_TYPE_NEXT) [src=%x]\n", src);
901#endif
902            return NULL;
903        }
904
905        src++;
906        if (size < que_size) {
907
908            copy_size = size;
909        } else {
910            copy_size = (NJ_UINT8)(que_size - 1);
911        }
912
913        for (i = 0; i < copy_size; i++) {
914            *dst++ = *src++;
915        }
916    }
917
918    *slen = que->hyouki_len;
919    iwnn->learn_string_tmp[*slen] = NJ_CHAR_NUL;
920
921    return &(iwnn->learn_string_tmp[0]);
922}
923
924static NJ_INT16 get_cand_by_sequential(NJ_CLASS *iwnn, NJ_SEARCH_CONDITION *cond,
925                                       NJ_SEARCH_LOCATION_SET *loctset, NJ_UINT8 search_pattern,
926                                       NJ_UINT8 comp_flg) {
927    NJ_UINT16 current, from, to;
928    NJ_UINT16 que_id;
929    NJ_UINT8  *ptr, *p;
930    NJ_INT16 ret, num_count;
931    NJ_CHAR  *yomi;
932    NJ_WQUE  *que;
933    NJ_UINT8 forward_flag = 0;
934
935
936
937    if (GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_NO_INIT) {
938
939        ret = search_range_by_yomi(iwnn, loctset->loct.handle, search_pattern,
940                                   cond->yomi, cond->ylen, &from, &to, &forward_flag);
941        if (ret < 0) {
942            return ret;
943        }
944        if (ret == 0) {
945            if (forward_flag) {
946                loctset->loct.status = NJ_ST_SEARCH_END;
947            } else {
948                loctset->loct.status = NJ_ST_SEARCH_END_EXT;
949            }
950            return 0;
951        }
952        loctset->loct.top = from;
953        loctset->loct.bottom = to;
954        current = from;
955    } else if (GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_READY) {
956
957        current = (NJ_UINT16)(loctset->loct.current + 1);
958    } else {
959        loctset->loct.status = NJ_ST_SEARCH_END;
960        return 0;
961    }
962
963
964    ptr = get_search_index_address(loctset->loct.handle, cond->operation);
965    p = ptr + (current * NJ_INDEX_SIZE);
966
967    while (current <= loctset->loct.bottom) {
968        que_id = GET_UINT16(p);
969        if (search_pattern == NJ_CUR_OP_COMP) {
970
971            ret = str_que_cmp(iwnn, loctset->loct.handle, cond->yomi, cond->ylen, que_id, 1);
972
973
974            if (ret == 2) {
975                ret = 0;
976            }
977        } else if (search_pattern == NJ_CUR_OP_FORE) {
978
979            ret = str_que_cmp(iwnn, loctset->loct.handle, cond->yomi, cond->ylen, que_id, 2);
980
981
982            if (ret == 2) {
983                ret = 0;
984            }
985        } else {
986
987
988
989            ret = que_strcmp_complete_with_hyouki(iwnn, loctset->loct.handle, que_id,
990                                                  cond->yomi, cond->ylen, cond->kanji, 0);
991        }
992
993        if (ret < 0) {
994            return ret;
995        }
996        if (ret > 0) {
997            if (search_pattern == NJ_CUR_OP_LINK) {
998
999
1000                num_count = continue_cnt(iwnn, loctset->loct.handle, que_id);
1001                if (num_count < 0) {
1002
1003                    return num_count;
1004                }
1005
1006
1007                if (num_count >= ret) {
1008
1009                    loctset->loct.current_info = (NJ_UINT8)(((num_count + 1) << 4) | ret);
1010                    loctset->loct.current = current;
1011                    loctset->loct.status = NJ_ST_SEARCH_READY;
1012                    loctset->cache_freq = get_hindo(iwnn, loctset, search_pattern);
1013                    return 1;
1014                }
1015            } else {
1016
1017
1018
1019
1020
1021
1022                que = get_que_allHinsi(iwnn, loctset->loct.handle, que_id);
1023                if (njd_connect_test(cond, que->mae_hinsi, que->ato_hinsi)) {
1024
1025
1026                    switch (NJ_GET_DIC_TYPE_EX(loctset->loct.type, loctset->loct.handle)) {
1027                    case NJ_DIC_TYPE_CUSTOM_INCOMPRESS:
1028                        if ((search_pattern == NJ_CUR_OP_COMP) && (comp_flg == 1)) {
1029                            yomi = cond->yomi + cond->ylen;
1030                            ret = que_strcmp_include(iwnn, loctset->loct.handle, que_id, yomi);
1031                            if (ret < 0) {
1032                                return ret;
1033                            }
1034                        }
1035                        break;
1036                    default:
1037                        break;
1038                    }
1039                    loctset->loct.current = current;
1040                    loctset->loct.status = NJ_ST_SEARCH_READY;
1041
1042                    loctset->loct.current_info = (ret & 0x0f) << 4;
1043                    loctset->cache_freq = get_hindo(iwnn, loctset, search_pattern);
1044                    return 1;
1045                }
1046            }
1047        }
1048        p += NJ_INDEX_SIZE;
1049        current++;
1050    }
1051
1052
1053    loctset->loct.status = NJ_ST_SEARCH_END;
1054    return 0;
1055}
1056
1057static NJ_INT16 get_cand_by_evaluate(NJ_CLASS *iwnn, NJ_SEARCH_CONDITION *cond,
1058                                     NJ_SEARCH_LOCATION_SET *loctset, NJ_UINT8 search_pattern) {
1059    NJ_UINT16 from, to, i;
1060    NJ_UINT16 que_id, oldest;
1061    NJ_UINT32 max_value, eval, current;
1062    NJ_UINT8  *ptr, *p;
1063    NJ_WQUE  *que;
1064    NJ_INT16 ret, num_count;
1065    NJ_INT32 found = 0;
1066    NJ_UINT8 forward_flag = 0;
1067    NJ_INT32 is_first_search, is_better_freq;
1068
1069
1070
1071    ptr = get_search_index_address(loctset->loct.handle, cond->operation);
1072
1073
1074    oldest = GET_LEARN_NEXT_WORD_POS(loctset->loct.handle);
1075
1076
1077    current = 0;
1078    if (GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_NO_INIT) {
1079        if (search_pattern == NJ_CUR_OP_LINK) {
1080
1081
1082
1083            ret = search_range_by_yomi_multi(iwnn, loctset->loct.handle,
1084                                             cond->yomi, cond->ylen, &from, &to);
1085        } else {
1086
1087
1088            ret = search_range_by_yomi(iwnn, loctset->loct.handle, search_pattern,
1089                                       cond->yomi, cond->ylen, &from, &to, &forward_flag);
1090        }
1091        if (ret <= 0) {
1092            loctset->loct.status = NJ_ST_SEARCH_END;
1093            return ret;
1094        }
1095        loctset->loct.top = from;
1096        loctset->loct.bottom = to;
1097        is_first_search = 1;
1098    } else if (GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_READY) {
1099        current = GET_UINT16(ptr + (loctset->loct.current * NJ_INDEX_SIZE));
1100        if (current < oldest) {
1101            current += GET_LEARN_MAX_WORD_COUNT(loctset->loct.handle);
1102        }
1103        is_first_search = 0;
1104    } else {
1105        loctset->loct.status = NJ_ST_SEARCH_END;
1106        return 0;
1107    }
1108
1109
1110    max_value = oldest;
1111
1112    p = ptr + (loctset->loct.top * NJ_INDEX_SIZE);
1113    eval = current;
1114    for (i = (NJ_UINT16)loctset->loct.top; i <= (NJ_UINT16)loctset->loct.bottom; i++) {
1115        que_id = GET_UINT16(p);
1116        if (que_id < oldest) {
1117            eval = que_id + GET_LEARN_MAX_WORD_COUNT(loctset->loct.handle);
1118        } else {
1119            eval = que_id;
1120        }
1121#ifdef LEARN_DEBUG
1122        printf("que(%d) : eval = %d\n", que_id, eval);
1123#endif
1124        is_better_freq = ((eval >= max_value) && ((is_first_search) || (eval < current))) ? 1 : 0;
1125
1126        if (is_better_freq) {
1127
1128            if (search_pattern == NJ_CUR_OP_LINK) {
1129
1130                ret = que_strcmp_complete_with_hyouki(iwnn, loctset->loct.handle, que_id,
1131                                                      cond->yomi, cond->ylen, cond->kanji, 1);
1132            } else {
1133
1134                ret = str_que_cmp(iwnn, loctset->loct.handle, cond->yomi, cond->ylen, que_id, 2);
1135
1136                if (ret == 2) {
1137                    ret = 0;
1138                }
1139            }
1140            if (ret < 0) {
1141                return ret;
1142            }
1143            if (ret >= 1) {
1144                if (search_pattern == NJ_CUR_OP_LINK) {
1145
1146
1147                    num_count = continue_cnt(iwnn, loctset->loct.handle, que_id);
1148                    if (num_count < 0) {
1149
1150                        return num_count;
1151                    }
1152
1153
1154                    if (num_count >= ret) {
1155
1156                        loctset->loct.current_info = (NJ_UINT8)(((num_count + 1) << 4) | ret);
1157                        loctset->loct.current = i;
1158                        max_value = eval;
1159                        found = 1;
1160                    }
1161                } else {
1162
1163
1164
1165
1166
1167                    que = get_que_allHinsi(iwnn, loctset->loct.handle, que_id);
1168                    if (njd_connect_test(cond, que->mae_hinsi, que->ato_hinsi)) {
1169
1170                        loctset->loct.current_info = (NJ_UINT8)0x10;
1171                        loctset->loct.current = i;
1172                        max_value = eval;
1173                        found = 1;
1174#ifdef LEARN_DEBUG
1175                        printf("---keep.");
1176#endif
1177                    }
1178                }
1179            }
1180        }
1181        p += NJ_INDEX_SIZE;
1182    }
1183
1184
1185    if (found == 0) {
1186        loctset->loct.status = NJ_ST_SEARCH_END;
1187        return 0;
1188    } else {
1189        loctset->loct.status = NJ_ST_SEARCH_READY;
1190        loctset->cache_freq = get_hindo(iwnn, loctset, search_pattern);
1191        return 1;
1192    }
1193
1194}
1195
1196static NJ_INT16 search_range_by_yomi(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT8 op,
1197                                     NJ_CHAR  *yomi, NJ_UINT16 len, NJ_UINT16 *from, NJ_UINT16 *to,
1198                                     NJ_UINT8 *forward_flag) {
1199    NJ_UINT16 right, mid = 0, left, max;
1200    NJ_UINT16 que_id;
1201    NJ_UINT8  *ptr, *p;
1202    NJ_CHAR  *str;
1203    NJ_INT16 ret = 0;
1204    NJ_INT32 found = 0;
1205    NJ_UINT8 slen;
1206    NJ_INT32 cmp;
1207
1208
1209
1210    ptr = get_search_index_address(handle, op);
1211
1212    max = GET_LEARN_WORD_COUNT(handle);
1213
1214    right = max - 1;
1215    left = 0;
1216
1217#ifdef LEARN_DEBUG
1218    printf("src:[%s]\n", yomi);
1219#endif
1220
1221    *forward_flag = 0;
1222
1223
1224    switch (op) {
1225    case NJ_CUR_OP_COMP:
1226    case NJ_CUR_OP_LINK:
1227    case NJ_CUR_OP_FORE:
1228
1229
1230
1231        break;
1232    default:
1233        return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_PARAM_OPERATION);
1234    }
1235
1236    while (left <= right) {
1237        mid = left + ((right - left) / 2);
1238        p = ptr + (mid * NJ_INDEX_SIZE);
1239        que_id = GET_UINT16(p);
1240        str = get_string(iwnn, handle, que_id, &slen);
1241
1242#ifdef IWNN_ERR_CHECK
1243        if (iwnn->err_check_flg == 3) {
1244            str = NULL;
1245        }
1246#endif
1247        if (str == NULL) {
1248            return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_DIC_BROKEN);
1249        }
1250
1251        ret = nj_strncmp(yomi, str, len);
1252        if (op != NJ_CUR_OP_FORE) {
1253
1254
1255            if (ret == 0) {
1256                if ((*forward_flag == 0) && (len <= (NJ_UINT16)slen)) {
1257
1258                    *forward_flag = 1;
1259                }
1260                if (len > (NJ_UINT16)slen) {
1261                    ret = 1;
1262                } else if (len < (NJ_UINT16)slen) {
1263                    ret = -1;
1264                }
1265            }
1266        }
1267#ifdef LEARN_DEBUG
1268        printf("   [%d][%d][%d]COMPARE:[%s] = %d\n", left, mid, right, str, ret);
1269#endif
1270        if (ret == 0) {
1271
1272            found = 1;
1273            break;
1274        } else if (ret < 0) {
1275
1276            right = mid - 1;
1277            if (mid == 0) {
1278                break;
1279            }
1280        } else {
1281
1282            left = mid + 1;
1283        }
1284    }
1285
1286    if (!found) {
1287        return 0;
1288    }
1289
1290    if (mid == 0) {
1291        *from = mid;
1292    } else {
1293
1294        p = ((mid - 1) * NJ_INDEX_SIZE) + ptr;
1295
1296        for (cmp = mid - 1; cmp >= 0; cmp--) {
1297            que_id = GET_UINT16(p);
1298            str = get_string(iwnn, handle, que_id, &slen);
1299
1300#ifdef IWNN_ERR_CHECK
1301            if (iwnn->err_check_flg == 4) {
1302                str = NULL;
1303            }
1304#endif
1305            if (str == NULL) {
1306                return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_DIC_BROKEN);
1307            }
1308
1309            if (op != NJ_CUR_OP_FORE) {
1310                ret = nj_strncmp(yomi, str, len);
1311                if (ret == 0) {
1312                    if (len > (NJ_UINT16)slen) {
1313                        ret = 1;
1314                    } else if (len < (NJ_UINT16)slen) {
1315                        ret = -1;
1316                    }
1317                }
1318                if (ret > 0) {
1319
1320                    break;
1321                }
1322            } else {
1323
1324                if (nj_strncmp(yomi, str, len) != 0) {
1325                    break;
1326                }
1327            }
1328            p -= NJ_INDEX_SIZE;
1329        }
1330        if (cmp < 0) {
1331            *from = 0;
1332        } else {
1333            *from = (NJ_UINT16)cmp + 1;
1334        }
1335    }
1336
1337#ifdef LEARN_DEBUG
1338    printf("  >> from:(%d)\n", *from);
1339#endif
1340
1341#ifdef IWNN_ERR_CHECK
1342    if (iwnn->err_check_flg == 5) {
1343        mid = max - 2;
1344    }
1345#endif
1346    if ((mid + 1) >= max) {
1347        *to = mid;
1348    } else {
1349
1350        p = ((mid + 1) * NJ_INDEX_SIZE) + ptr;
1351
1352        for (right = mid + 1; right < max; right++) {
1353            que_id = GET_UINT16(p);
1354            str = get_string(iwnn, handle, que_id, &slen);
1355
1356#ifdef IWNN_ERR_CHECK
1357            if (iwnn->err_check_flg == 5) {
1358                str = NULL;
1359            }
1360#endif
1361            if (str == NULL) {
1362                return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_DIC_BROKEN);
1363            }
1364
1365            if (op != NJ_CUR_OP_FORE) {
1366                ret = nj_strncmp(yomi, str, len);
1367                if (ret == 0) {
1368                    if (len > (NJ_UINT16)slen) {
1369                        ret = 1;
1370                    } else if (len < (NJ_UINT16)slen) {
1371                        ret = -1;
1372                    }
1373                }
1374                if (ret < 0) {
1375
1376                    break;
1377                }
1378            } else {
1379
1380                if (nj_strncmp(yomi, str, len) != 0) {
1381                    break;
1382                }
1383            }
1384            p += NJ_INDEX_SIZE;
1385        }
1386        *to = right - 1;
1387    }
1388
1389#ifdef LEARN_DEBUG
1390    printf("  >> to:(%d)\n", *to);
1391#endif
1392    return 1;
1393}
1394
1395static NJ_INT16 search_range_by_yomi_multi(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle,
1396                                           NJ_CHAR *yomi, NJ_UINT16 len, NJ_UINT16 *from, NJ_UINT16 *to) {
1397    NJ_UINT16 right, mid = 0, left, max = 0;
1398    NJ_UINT16 que_id;
1399    NJ_UINT8  *ptr, *p;
1400    NJ_INT16 ret = 0;
1401    NJ_UINT16 comp_len;
1402    NJ_UINT16 i, char_len;
1403    NJ_INT32 found = 0;
1404    NJ_INT32 cmp;
1405    NJ_CHAR  comp_yomi[NJ_MAX_LEN + NJ_TERM_LEN];
1406    NJ_CHAR  *pYomi;
1407
1408
1409
1410
1411    ptr = LEARN_INDEX_TOP_ADDR(handle);
1412
1413
1414    max = GET_LEARN_WORD_COUNT(handle);
1415
1416#ifdef LEARN_DEBUG
1417    printf("src:[%s]\n", yomi);
1418#endif
1419
1420    comp_len = 0;
1421    pYomi = &yomi[0];
1422    while (comp_len < len) {
1423
1424
1425        char_len = NJ_CHAR_LEN(pYomi);
1426        for (i = 0; i < char_len; i++) {
1427            *(comp_yomi + comp_len) = *pYomi;
1428            comp_len++;
1429            pYomi++;
1430        }
1431        *(comp_yomi + comp_len) = NJ_CHAR_NUL;
1432
1433        right = max - 1;
1434        left = 0;
1435        while (left <= right) {
1436            mid = left + ((right - left) / 2);
1437            p = ptr + (mid * NJ_INDEX_SIZE);
1438            que_id = GET_UINT16(p);
1439
1440
1441            ret = str_que_cmp(iwnn, handle, comp_yomi, comp_len, que_id, 1);
1442            if (ret < 0) {
1443                return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI_MULTI, NJ_ERR_DIC_BROKEN);
1444            }
1445
1446#ifdef LEARN_DEBUG
1447            printf("   [%d][%d][%d]COMPARE:[%s] = %d\n", left, mid, right, str, ret);
1448#endif
1449            if (ret == 1) {
1450
1451                found = 1;
1452                break;
1453            } else if (ret == 0) {
1454
1455                right = mid - 1;
1456                if (mid == 0) {
1457                    break;
1458                }
1459            } else {
1460
1461                left = mid + 1;
1462            }
1463        }
1464
1465        if (found) {
1466            break;
1467        }
1468    }
1469
1470    if (!found) {
1471
1472        return 0;
1473    }
1474
1475
1476    if (mid == 0) {
1477        *from = mid;
1478    } else {
1479
1480        p = ((mid - 1) * NJ_INDEX_SIZE) + ptr;
1481
1482        for (cmp = mid - 1; cmp >= 0; cmp--) {
1483            que_id = GET_UINT16(p);
1484            ret = str_que_cmp(iwnn, handle, comp_yomi, comp_len, que_id, 1);
1485            if (ret < 0) {
1486                return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI_MULTI, NJ_ERR_DIC_BROKEN);
1487            }
1488            if (ret == 2) {
1489                break;
1490            }
1491            p -= NJ_INDEX_SIZE;
1492        }
1493        if (cmp < 0) {
1494            *from = 0;
1495        } else {
1496            *from = (NJ_UINT16)cmp + 1;
1497        }
1498    }
1499
1500#ifdef LEARN_DEBUG
1501    printf("  >> from:(%d)\n", *from);
1502#endif
1503
1504
1505    if ((mid + 1) >= max) {
1506        *to = mid;
1507    } else {
1508
1509        p = ((mid + 1) * NJ_INDEX_SIZE) + ptr;
1510
1511        for (right = mid + 1; right < max; right++) {
1512            que_id = GET_UINT16(p);
1513            ret = str_que_cmp(iwnn, handle, yomi, len, que_id, 1);
1514            if (ret < 0) {
1515                return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI_MULTI, NJ_ERR_DIC_BROKEN);
1516            }
1517            if (ret == 0) {
1518                break;
1519            }
1520            p += NJ_INDEX_SIZE;
1521        }
1522        *to = right - 1;
1523    }
1524
1525#ifdef LEARN_DEBUG
1526    printf("  >> to:(%d)\n", *to);
1527#endif
1528    return 1;
1529}
1530
1531static NJ_INT16 str_que_cmp(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_CHAR *yomi,
1532                            NJ_UINT16 yomiLen, NJ_UINT16 que_id, NJ_UINT8 mode) {
1533    NJ_UINT8  *queYomi;
1534    NJ_UINT8  *yomiPtr;
1535    NJ_UINT16 yomiByte;
1536    NJ_UINT16 yomiPos;
1537    NJ_UINT8  queYomiByte, queKouhoByte;
1538    NJ_UINT8  queYomiPos, queYomiSearchArea;
1539    NJ_INT16  complete;
1540    NJ_UINT8  *top_addr;
1541    NJ_UINT8  *bottom_addr;
1542    NJ_UINT16 que_size;
1543
1544
1545#ifdef IWNN_ERR_CHECK
1546    if (iwnn->err_check_flg == 6) {
1547        que_id = GET_LEARN_MAX_WORD_COUNT(handle);
1548    }
1549#endif
1550    if (que_id >= GET_LEARN_MAX_WORD_COUNT(handle)) {
1551
1552        return NJ_SET_ERR_VAL(NJ_FUNC_STR_QUE_CMP, NJ_ERR_DIC_BROKEN);
1553    }
1554
1555    queYomi = POS_TO_ADDRESS(handle, que_id);
1556#ifdef IWNN_ERR_CHECK
1557    if (iwnn->err_check_flg == 7) {
1558        *queYomi = 0x03;
1559    }
1560#endif
1561    switch (GET_TYPE_FROM_DATA(queYomi)) {
1562    case QUE_TYPE_EMPTY:
1563    case QUE_TYPE_JIRI:
1564    case QUE_TYPE_FZK:
1565        break;
1566    default:
1567
1568        return NJ_SET_ERR_VAL(NJ_FUNC_STR_QUE_CMP, NJ_ERR_DIC_BROKEN);
1569    }
1570
1571
1572    if ((mode == 2) && (yomiLen == 0)) {
1573        return 1;
1574    }
1575
1576
1577    queYomiByte = GET_YSIZE_FROM_DATA(queYomi);
1578    queKouhoByte= GET_KSIZE_FROM_DATA(queYomi);
1579
1580    top_addr = LEARN_DATA_TOP_ADDR(handle);
1581    que_size = QUE_SIZE(handle);
1582
1583
1584    queYomi += LEARN_QUE_STRING_OFFSET;
1585    queYomiSearchArea = (NJ_UINT8)(QUE_SIZE(handle) - LEARN_QUE_STRING_OFFSET);
1586
1587    complete = 0;
1588    yomiPos = 0; queYomiPos = 0;
1589    yomiPtr  = (NJ_UINT8*)yomi;
1590    yomiByte = yomiLen * sizeof(NJ_CHAR);
1591
1592
1593    while ((complete = (*yomiPtr - *queYomi)) == 0) {
1594        yomiPos++; queYomiPos++;
1595
1596        if (queYomiPos >= queYomiByte) {
1597            if (queYomiByte == yomiByte) {
1598
1599                return 1;
1600            } else if (mode == 2) {
1601
1602                return 2;
1603            } else {
1604
1605                return (mode + 1);
1606            }
1607        }
1608        if (yomiPos >= yomiByte) {
1609
1610            break;
1611        } else {
1612            yomiPtr++; queYomi++;
1613#ifdef IWNN_ERR_CHECK
1614            if (iwnn->err_check_flg == 8) {
1615                queYomiPos = queYomiSearchArea;
1616            }
1617#endif
1618            if (queYomiPos >= queYomiSearchArea) {
1619
1620                bottom_addr = top_addr;
1621                bottom_addr += que_size * GET_LEARN_MAX_WORD_COUNT(handle) - 1;
1622                if (queYomi >= bottom_addr) {
1623                    queYomi = top_addr;
1624                }
1625
1626
1627                if (*queYomi++ != QUE_TYPE_NEXT) {
1628
1629                    return NJ_SET_ERR_VAL(NJ_FUNC_STR_QUE_CMP, NJ_ERR_DIC_BROKEN);
1630                }
1631                queYomiSearchArea += (NJ_UINT8)(que_size - 1);
1632            }
1633        }
1634    }
1635    if (complete == 0) {
1636        if (yomiByte < queYomiByte) {
1637
1638            if (mode == 2) {
1639                return 1;
1640            }
1641
1642            return 0;
1643        } else {
1644
1645            return 2;
1646        }
1647    } else if (complete < 0) {
1648
1649        return 0;
1650    } else {
1651
1652        return 2;
1653    }
1654}
1655
1656static NJ_HINDO calculate_hindo(NJ_DIC_HANDLE handle, NJ_INT32 freq, NJ_DIC_FREQ *dic_freq, NJ_INT16 freq_max, NJ_INT16 freq_min) {
1657    NJ_UINT16 max;
1658    NJ_HINDO  hindo;
1659
1660
1661    max = GET_LEARN_MAX_WORD_COUNT(handle);
1662
1663
1664
1665
1666    if (NJ_GET_DIC_TYPE(handle) == NJ_DIC_TYPE_USER) {
1667
1668        hindo = (NJ_INT16)dic_freq->base;
1669    } else {
1670
1671        if (max > 1) {
1672
1673            hindo = CALCULATE_HINDO(freq, dic_freq->base, dic_freq->high, (max-1));
1674        } else {
1675
1676            hindo = (NJ_INT16)dic_freq->high;
1677        }
1678    }
1679    return NORMALIZE_HINDO(hindo, freq_max, freq_min);
1680}
1681
1682static NJ_HINDO get_hindo(NJ_CLASS *iwnn, NJ_SEARCH_LOCATION_SET *loctset,
1683                          NJ_UINT8 search_pattern) {
1684    NJ_WQUE   *que;
1685    NJ_UINT16 que_id, oldest;
1686    NJ_UINT8  offset;
1687    NJ_INT32  dic_freq;
1688    NJ_UINT16 max;
1689    NJ_UINT8  *learn_index_top_addr;
1690
1691
1692
1693    learn_index_top_addr = get_search_index_address(loctset->loct.handle, search_pattern);
1694
1695    que_id = (NJ_UINT16)GET_UINT16(learn_index_top_addr +
1696                                   ((loctset->loct.current & 0xffffU) * NJ_INDEX_SIZE));
1697    oldest = GET_LEARN_NEXT_WORD_POS(loctset->loct.handle);
1698
1699    offset = (loctset->loct.current_info & 0x0f);
1700    while (offset--) {
1701        que_id = search_next_que(loctset->loct.handle, que_id);
1702    }
1703
1704    que = get_que(iwnn, loctset->loct.handle, que_id);
1705    if (que == NULL) {
1706        return INIT_HINDO;
1707    }
1708
1709    max = GET_LEARN_MAX_WORD_COUNT(loctset->loct.handle);
1710    if (que_id >= oldest) {
1711        dic_freq = que_id - oldest;
1712    } else {
1713        dic_freq = que_id - oldest + max;
1714    }
1715
1716
1717    return calculate_hindo(loctset->loct.handle, dic_freq, &(loctset->dic_freq), 1000, 0);
1718}
1719
1720NJ_INT16 njd_l_get_word(NJ_CLASS *iwnn, NJ_SEARCH_LOCATION_SET *loctset, NJ_WORD *word) {
1721    NJ_WQUE *que;
1722    NJ_UINT16 que_id;
1723    NJ_UINT8 offset;
1724    NJ_UINT8 *learn_index_top_addr;
1725
1726
1727
1728    learn_index_top_addr = get_search_index_address(loctset->loct.handle, GET_LOCATION_OPERATION(loctset->loct.status));
1729
1730    que_id = (NJ_UINT16)GET_UINT16(learn_index_top_addr +
1731                                   ((loctset->loct.current & 0xffff) * NJ_INDEX_SIZE));
1732
1733    offset = (loctset->loct.current_info & 0x0f);
1734    while (offset--) {
1735        que_id = search_next_que(loctset->loct.handle, que_id);
1736    }
1737
1738    que = get_que(iwnn, loctset->loct.handle, que_id);
1739    if (que == NULL) {
1740        return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_GET_WORD, NJ_ERR_CANNOT_GET_QUE);
1741    }
1742
1743    word->stem.loc = loctset->loct;
1744
1745    word->stem.loc.current &= 0x0000ffff;
1746    word->stem.loc.current |= ((NJ_UINT32)que_id << 16);
1747
1748
1749    word->stem.hindo = loctset->cache_freq;
1750
1751    NJ_SET_FPOS_TO_STEM(word, que->mae_hinsi);
1752    NJ_SET_YLEN_TO_STEM(word, que->yomi_len);
1753    if (que->hyouki_len > 0) {
1754        NJ_SET_KLEN_TO_STEM(word, que->hyouki_len);
1755    } else {
1756
1757        NJ_SET_KLEN_TO_STEM(word, que->yomi_len);
1758    }
1759    NJ_SET_BPOS_TO_STEM(word, que->ato_hinsi);
1760
1761
1762    word->stem.type = 0;
1763
1764    return 1;
1765}
1766
1767NJ_INT16 njd_l_get_stroke(NJ_CLASS *iwnn, NJ_WORD *word, NJ_CHAR *stroke, NJ_UINT16 size) {
1768    NJ_UINT16 que_id;
1769    NJ_CHAR   *str;
1770    NJ_UINT8  slen;
1771    NJ_UINT8  ylen;
1772
1773
1774    que_id = (NJ_UINT16)(word->stem.loc.current >> 16);
1775
1776
1777    ylen = (NJ_UINT8)NJ_GET_YLEN_FROM_STEM(word);
1778
1779    if ((NJ_UINT16)((ylen+ NJ_TERM_LEN)*sizeof(NJ_CHAR)) > size) {
1780
1781        return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_GET_STROKE, NJ_ERR_BUFFER_NOT_ENOUGH);
1782    }
1783    if (ylen == 0) {
1784        return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_GET_STROKE, NJ_ERR_INVALID_RESULT);
1785    }
1786    str = get_string(iwnn, word->stem.loc.handle, que_id, &slen);
1787
1788#ifdef IWNN_ERR_CHECK
1789    if (iwnn->err_check_flg == 9) {
1790        str = NULL;
1791    }
1792#endif
1793
1794    if (str == NULL) {
1795        return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_GET_STROKE, NJ_ERR_DIC_BROKEN);
1796    }
1797
1798
1799    nj_strcpy(stroke, str);
1800
1801    return slen;
1802}
1803
1804NJ_INT16 njd_l_get_candidate(NJ_CLASS *iwnn, NJ_WORD *word,
1805                             NJ_CHAR *candidate, NJ_UINT16 size) {
1806    NJ_UINT16 que_id;
1807    NJ_CHAR   *str;
1808    NJ_UINT16 klen;
1809    NJ_UINT8  slen;
1810
1811
1812    que_id = (NJ_UINT16)(word->stem.loc.current >> 16);
1813
1814
1815    klen = NJ_GET_KLEN_FROM_STEM(word);
1816
1817    if (size < ((klen+NJ_TERM_LEN)*sizeof(NJ_CHAR))) {
1818
1819        return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_GET_CANDIDATE, NJ_ERR_BUFFER_NOT_ENOUGH);
1820    }
1821    str = get_hyouki(iwnn, word->stem.loc.handle, que_id, &slen);
1822#ifdef IWNN_ERR_CHECK
1823    if (iwnn->err_check_flg == 10) {
1824        str = NULL;
1825    }
1826#endif
1827    if (str == NULL) {
1828
1829        return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_GET_CANDIDATE, NJ_ERR_DIC_BROKEN);
1830    }
1831
1832
1833    nj_strcpy(candidate, str);
1834
1835    return klen;
1836}
1837
1838NJ_INT16 njd_l_check_dic(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle) {
1839    NJ_UINT16 flg;
1840    NJ_UINT16 word_cnt, max;
1841    NJ_UINT8 *ptr;
1842    NJ_UINT16 target_id;
1843    NJ_UINT16 i;
1844    NJ_UINT16 id1 = 0;
1845    NJ_UINT8 slen;
1846
1847
1848
1849    if ((NJ_GET_DIC_TYPE(handle) != NJ_DIC_TYPE_USER)) {
1850
1851        return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_CHECK_DIC, NJ_ERR_DIC_TYPE_INVALID);
1852    }
1853
1854
1855    word_cnt = GET_LEARN_WORD_COUNT(handle);
1856    max = GET_LEARN_MAX_WORD_COUNT(handle);
1857    if (word_cnt > max) {
1858
1859        return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_CHECK_DIC,
1860                              NJ_ERR_DIC_BROKEN);
1861    }
1862
1863    ptr = LEARN_INDEX_TOP_ADDR(handle);
1864    for (i = 0; i < word_cnt; i++) {
1865        id1 = GET_UINT16(ptr);
1866
1867        if (id1 >= max) {
1868            return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_CHECK_DIC,
1869                                  NJ_ERR_DIC_BROKEN);
1870        }
1871        ptr += NJ_INDEX_SIZE;
1872    }
1873
1874
1875    ptr = LEARN_INDEX_TOP_ADDR2(handle);
1876    for (i = 0; i < word_cnt; i++) {
1877        id1 = GET_UINT16(ptr);
1878
1879        if (id1 >= max) {
1880            return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_CHECK_DIC,
1881                                  NJ_ERR_DIC_BROKEN);
1882        }
1883        ptr += NJ_INDEX_SIZE;
1884    }
1885
1886
1887    flg = GET_UINT16(handle + POS_WRITE_FLG);
1888
1889    target_id = GET_UINT16(handle + POS_WRITE_FLG + 2);
1890
1891
1892
1893    if (((flg != word_cnt) && (flg != (word_cnt + 1)) && (flg != (word_cnt - 1))) ||
1894        (target_id >= max)) {
1895        return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_CHECK_DIC,
1896                              NJ_ERR_DIC_BROKEN);
1897    }
1898
1899
1900    if (flg == (word_cnt + 1)) {
1901        return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_CHECK_DIC, NJ_ERR_DIC_BROKEN);
1902    } else if (flg == (word_cnt - 1)) {
1903        return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_CHECK_DIC, NJ_ERR_DIC_BROKEN);
1904    }
1905
1906    word_cnt = GET_LEARN_WORD_COUNT(handle);
1907
1908    ptr = LEARN_INDEX_TOP_ADDR(handle);
1909    for (i = 0; i < word_cnt; i++) {
1910        id1 = GET_UINT16(ptr);
1911        if (get_hyouki(iwnn, handle, id1, &slen) == NULL) {
1912            return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_CHECK_DIC,
1913                                  NJ_ERR_DIC_BROKEN);
1914        }
1915        ptr += NJ_INDEX_SIZE;
1916    }
1917
1918    ptr = LEARN_INDEX_TOP_ADDR2(handle);
1919    for (i = 0; i < word_cnt; i++) {
1920        id1 = GET_UINT16(ptr);
1921
1922        if (id1 >= max) {
1923            return NJ_SET_ERR_VAL(NJ_FUNC_NJD_L_CHECK_DIC,
1924                                  NJ_ERR_DIC_BROKEN);
1925        }
1926        ptr += NJ_INDEX_SIZE;
1927    }
1928
1929    return 0;
1930}
1931
1932static NJ_INT16 get_cand_by_evaluate2(NJ_CLASS *iwnn, NJ_SEARCH_CONDITION *cond,
1933                                      NJ_SEARCH_LOCATION_SET *loctset,
1934                                      NJ_UINT8 search_pattern,
1935                                      NJ_UINT16 idx) {
1936    NJ_UINT16 from, to, i;
1937    NJ_UINT16 que_id, oldest;
1938    NJ_UINT32 max_value, eval, current;
1939    NJ_UINT8  *ptr, *p;
1940    NJ_WQUE *que;
1941    NJ_INT16 ret = 0;
1942    NJ_INT32 found = 0;
1943    NJ_UINT8 forward_flag = 0;
1944
1945
1946    NJ_UINT16               abIdx;
1947    NJ_UINT16               abIdx_old;
1948    NJ_UINT16               tmp_len;
1949    NJ_UINT16               yomi_clen;
1950    NJ_UINT16               j,l,m;
1951    NJ_UINT8                cmpflg;
1952    NJ_UINT8                endflg = 0;
1953    NJ_CHAR                 *str;
1954    NJ_CHAR                 *key;
1955    NJ_CHAR                 char_tmp[NJ_MAX_LEN + NJ_TERM_LEN];
1956    NJ_CHAR                 *pchar_tmp;
1957    NJ_SEARCH_CACHE         *psrhCache = cond->ds->dic[idx].srhCache;
1958    NJ_UINT16               endIdx;
1959    NJ_UINT8                slen;
1960    NJ_UINT16               addcnt = 0;
1961    NJ_CHAR                 *yomi;
1962    NJ_UINT8                aimai_flg = 0x01;
1963    NJ_CHARSET              *pCharset = cond->charset;
1964
1965
1966    if (NJ_GET_CACHEOVER_FROM_SCACHE(psrhCache)) {
1967        aimai_flg = 0x00;
1968    }
1969
1970
1971    ptr = get_search_index_address(loctset->loct.handle, cond->operation);
1972
1973
1974    oldest = GET_LEARN_NEXT_WORD_POS(loctset->loct.handle);
1975    max_value = oldest;
1976
1977
1978    current = 0;
1979    if (GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_NO_INIT) {
1980
1981
1982        key       = cond->ds->keyword;
1983        yomi      = cond->yomi;
1984        yomi_clen = cond->yclen;
1985
1986
1987        endflg = 0x00;
1988
1989        if (psrhCache->keyPtr[0] == 0xFFFF) {
1990            cmpflg = 0x01;
1991            psrhCache->keyPtr[0] = 0x0000;
1992        } else {
1993            cmpflg = 0x00;
1994        }
1995
1996        for (i = 0; i < yomi_clen; i++) {
1997            j = i;
1998
1999
2000            if (!cmpflg) {
2001
2002                if (((j != 0) && (psrhCache->keyPtr[j] == 0)) || (psrhCache->keyPtr[j+1] == 0)) {
2003
2004                    cmpflg = 0x01;
2005                } else {
2006
2007                }
2008            }
2009
2010            if (cmpflg) {
2011
2012                if (!j) {
2013
2014                    abIdx = 0;
2015                    addcnt = 0;
2016                    nj_charncpy(char_tmp, yomi, 1);
2017                    tmp_len = nj_strlen(char_tmp);
2018                    ret = search_range_by_yomi(iwnn, loctset->loct.handle, search_pattern,
2019                                               char_tmp, tmp_len, &from,
2020                                               &to, &forward_flag);
2021                    if (ret < 0) {
2022
2023
2024                        psrhCache->keyPtr[j+1] = abIdx;
2025                        loctset->loct.status = NJ_ST_SEARCH_END;
2026                        return ret;
2027                    } else if (ret > 0) {
2028
2029                        psrhCache->storebuff[abIdx].top    = from;
2030                        psrhCache->storebuff[abIdx].bottom = to;
2031                        psrhCache->storebuff[abIdx].idx_no = (NJ_INT8)tmp_len;
2032                        addcnt++;
2033                        abIdx++;
2034                        psrhCache->keyPtr[j+1] = abIdx;
2035                    } else {
2036                        psrhCache->keyPtr[j+1] = abIdx;
2037                    }
2038
2039                    if ((!endflg) && (pCharset != NULL) && aimai_flg) {
2040
2041                        for (l = 0; l < pCharset->charset_count; l++) {
2042
2043                            if (nj_charncmp(yomi, pCharset->from[l], 1) == 0) {
2044
2045                                nj_strcpy(char_tmp, pCharset->to[l]);
2046                                tmp_len = nj_strlen(char_tmp);
2047                                ret = search_range_by_yomi(iwnn, loctset->loct.handle, search_pattern,
2048                                                           char_tmp, tmp_len, &from, &to, &forward_flag);
2049                                if (ret < 0) {
2050
2051
2052                                    psrhCache->keyPtr[j+1] = abIdx;
2053                                    loctset->loct.status = NJ_ST_SEARCH_END;
2054                                    return ret;
2055                                } else if (ret > 0) {
2056
2057
2058                                    if (abIdx >= NJ_SEARCH_CACHE_SIZE) {
2059                                        psrhCache->keyPtr[j+1] = 0;
2060                                        return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_CACHE_NOT_ENOUGH);
2061                                    }
2062                                    psrhCache->storebuff[abIdx].top    = from;
2063                                    psrhCache->storebuff[abIdx].bottom = to;
2064                                    psrhCache->storebuff[abIdx].idx_no = (NJ_INT8)tmp_len;
2065                                    if (addcnt == 0) {
2066                                        psrhCache->keyPtr[j] = abIdx;
2067                                    }
2068                                    abIdx++;
2069                                    addcnt++;
2070                                    psrhCache->keyPtr[j+1] = abIdx;
2071                                } else {
2072                                    psrhCache->keyPtr[j+1] = abIdx;
2073                                }
2074                            }
2075                        }
2076                    }
2077                } else {
2078
2079                    if (psrhCache->keyPtr[j] == psrhCache->keyPtr[j-1]) {
2080
2081                        psrhCache->keyPtr[j+1] = psrhCache->keyPtr[j-1];
2082                        endflg = 0x01;
2083                    } else {
2084
2085                        endIdx = psrhCache->keyPtr[j];
2086                        abIdx_old = psrhCache->keyPtr[j-1];
2087
2088                        if (NJ_GET_CACHEOVER_FROM_SCACHE(psrhCache)) {
2089                            abIdx = psrhCache->keyPtr[j - 1];
2090                            psrhCache->keyPtr[j] = abIdx;
2091                        } else {
2092                            abIdx = psrhCache->keyPtr[j];
2093                        }
2094                        addcnt = 0;
2095
2096                        if ((abIdx > NJ_SEARCH_CACHE_SIZE) || (abIdx_old >= NJ_SEARCH_CACHE_SIZE) ||
2097                            (endIdx > NJ_SEARCH_CACHE_SIZE)) {
2098
2099                            return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_CACHE_BROKEN);
2100                        }
2101                        for (m = abIdx_old; m < endIdx; m++) {
2102
2103                            p = ptr + (psrhCache->storebuff[m].top * NJ_INDEX_SIZE);
2104                            que_id = GET_UINT16(p);
2105
2106
2107                            str = get_string(iwnn, loctset->loct.handle, que_id, &slen);
2108
2109                            if (str == NULL) {
2110                                return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_DIC_BROKEN);
2111                            }
2112
2113
2114                            nj_strncpy(char_tmp, str, psrhCache->storebuff[m].idx_no);
2115                            char_tmp[psrhCache->storebuff[m].idx_no] = NJ_CHAR_NUL;
2116
2117                            pchar_tmp = &char_tmp[psrhCache->storebuff[m].idx_no];
2118                            nj_charncpy(pchar_tmp, yomi, 1);
2119                            tmp_len = nj_strlen(char_tmp);
2120
2121
2122                            ret = search_range_by_yomi2(iwnn, loctset->loct.handle, search_pattern,
2123                                                        char_tmp, tmp_len,
2124                                                        (NJ_UINT16)(psrhCache->storebuff[m].top),
2125                                                        (NJ_UINT16)(psrhCache->storebuff[m].bottom),
2126                                                        &from, &to, &forward_flag);
2127                            if (ret < 0) {
2128
2129
2130                                psrhCache->keyPtr[j+1] = abIdx;
2131                                loctset->loct.status = NJ_ST_SEARCH_END;
2132                                return ret;
2133                            } else if (ret > 0) {
2134
2135
2136                                if (abIdx >= NJ_SEARCH_CACHE_SIZE) {
2137                                    psrhCache->keyPtr[j+1] = 0;
2138                                    return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_CACHE_NOT_ENOUGH);
2139                                }
2140                                psrhCache->storebuff[abIdx].top    = from;
2141                                psrhCache->storebuff[abIdx].bottom = to;
2142                                psrhCache->storebuff[abIdx].idx_no = (NJ_INT8)tmp_len;
2143                                if (addcnt == 0) {
2144                                    psrhCache->keyPtr[j] = abIdx;
2145                                }
2146                                abIdx++;
2147                                addcnt++;
2148                                psrhCache->keyPtr[j+1] = abIdx;
2149                            } else {
2150                                psrhCache->keyPtr[j+1] = abIdx;
2151                            }
2152
2153                            if ((!endflg) && (pCharset != NULL) && aimai_flg) {
2154
2155                                for (l = 0; l < pCharset->charset_count; l++) {
2156
2157                                    if (nj_charncmp(yomi, pCharset->from[l], 1) == 0) {
2158
2159                                        tmp_len = nj_strlen(pCharset->to[l]);
2160
2161                                        nj_strncpy(pchar_tmp, pCharset->to[l], tmp_len);
2162                                        *(pchar_tmp + tmp_len) = NJ_CHAR_NUL;
2163                                        tmp_len = nj_strlen(char_tmp);
2164                                        ret = search_range_by_yomi2(iwnn, loctset->loct.handle, search_pattern,
2165                                                                    char_tmp, tmp_len,
2166                                                                    (NJ_UINT16)(psrhCache->storebuff[m].top),
2167                                                                    (NJ_UINT16)(psrhCache->storebuff[m].bottom),
2168                                                                    &from, &to, &forward_flag);
2169                                        if (ret < 0) {
2170
2171
2172                                            psrhCache->keyPtr[j+1] = abIdx;
2173                                            loctset->loct.status = NJ_ST_SEARCH_END;
2174                                            return ret;
2175                                        } else if (ret > 0) {
2176
2177
2178                                            if (abIdx >= NJ_SEARCH_CACHE_SIZE) {
2179                                                psrhCache->keyPtr[j+1] = 0;
2180                                                return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_CACHE_NOT_ENOUGH);
2181                                            }
2182                                            psrhCache->storebuff[abIdx].top    = from;
2183                                            psrhCache->storebuff[abIdx].bottom = to;
2184                                            psrhCache->storebuff[abIdx].idx_no = (NJ_INT8)tmp_len;
2185                                            abIdx++;
2186                                            addcnt++;
2187                                            psrhCache->keyPtr[j+1] = abIdx;
2188                                        } else {
2189                                            psrhCache->keyPtr[j+1] = abIdx;
2190                                        }
2191                                    }
2192                                }
2193                            }
2194                        }
2195                    }
2196                }
2197            }
2198            yomi += UTL_CHAR(yomi);
2199            key  += UTL_CHAR(key);
2200        }
2201
2202
2203        if ((addcnt == 0) && (psrhCache->keyPtr[yomi_clen - 1] == psrhCache->keyPtr[yomi_clen])) {
2204            endflg = 0x01;
2205        }
2206
2207        if (endflg) {
2208            loctset->loct.status = NJ_ST_SEARCH_END;
2209            return 0;
2210        }
2211    } else if (GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_READY) {
2212        current = GET_UINT16(ptr + (loctset->loct.current * NJ_INDEX_SIZE));
2213        if (current < oldest) {
2214            current += GET_LEARN_MAX_WORD_COUNT(loctset->loct.handle);
2215        }
2216    } else {
2217        loctset->loct.status = NJ_ST_SEARCH_END;
2218        return 0;
2219    }
2220
2221
2222    j = cond->yclen - 1;
2223
2224    abIdx = psrhCache->keyPtr[j];
2225    abIdx_old = psrhCache->keyPtr[j+1];
2226
2227    endIdx = abIdx_old;
2228    if ((abIdx >= NJ_SEARCH_CACHE_SIZE) || (abIdx_old > NJ_SEARCH_CACHE_SIZE)) {
2229
2230        return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_CACHE_BROKEN);
2231    }
2232    p = ptr + (psrhCache->storebuff[abIdx].top * NJ_INDEX_SIZE);
2233    que_id = GET_UINT16(p);
2234    eval = current;
2235
2236
2237
2238    if (psrhCache->keyPtr[j] < psrhCache->keyPtr[j + 1]) {
2239        if (GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_NO_INIT) {
2240            endIdx = abIdx + 1;
2241            NJ_SET_AIMAI_TO_SCACHE(psrhCache);
2242        }
2243
2244        for (m = abIdx; m < endIdx; m++) {
2245            p = ptr + (psrhCache->storebuff[m].top * NJ_INDEX_SIZE);
2246            que_id = GET_UINT16(p);
2247            eval = current;
2248
2249            for (i = (NJ_UINT16)psrhCache->storebuff[m].top; i <= (NJ_UINT16)psrhCache->storebuff[m].bottom; i++) {
2250                que_id = GET_UINT16(p);
2251                if (que_id < oldest) {
2252                    eval = que_id + GET_LEARN_MAX_WORD_COUNT(loctset->loct.handle);
2253                } else {
2254                    eval = que_id;
2255                }
2256#ifdef LEARN_DEBUG
2257                printf("que(%d) : eval = %d : %d\n", que_id, eval, i);
2258#endif
2259                if (eval >= max_value) {
2260                    if ((GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_NO_INIT)
2261                        || ((GET_LOCATION_STATUS(loctset->loct.status) == NJ_ST_SEARCH_READY)
2262                            && (NJ_GET_AIMAI_FROM_SCACHE(psrhCache)))
2263                        || (eval < current)) {
2264
2265
2266
2267                        str = get_string(iwnn, loctset->loct.handle, que_id, &slen);
2268                        if (str == NULL) {
2269                            return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_DIC_BROKEN);
2270                        }
2271
2272
2273
2274                        que = get_que_allHinsi(iwnn, loctset->loct.handle, que_id);
2275                        if (njd_connect_test(cond, que->mae_hinsi, que->ato_hinsi)) {
2276
2277                            loctset->loct.current_info = (NJ_UINT8)0x10;
2278                            loctset->loct.current = i;
2279                            max_value = eval;
2280                            found = 1;
2281#ifdef LEARN_DEBUG
2282                            printf("---keep.");
2283#endif
2284                        }
2285                    }
2286                }
2287                p += NJ_INDEX_SIZE;
2288            }
2289        }
2290    }
2291
2292    if (GET_LOCATION_STATUS(loctset->loct.status) != NJ_ST_SEARCH_NO_INIT) {
2293        NJ_UNSET_AIMAI_TO_SCACHE(psrhCache);
2294    }
2295
2296
2297    if (found == 0) {
2298        loctset->loct.status = NJ_ST_SEARCH_END;
2299        return 0;
2300    } else {
2301        loctset->loct.status = NJ_ST_SEARCH_READY;
2302        loctset->cache_freq = get_hindo(iwnn, loctset, search_pattern);
2303        return 1;
2304    }
2305}
2306
2307static NJ_INT16 search_range_by_yomi2(NJ_CLASS *iwnn, NJ_DIC_HANDLE handle, NJ_UINT8 op,
2308                                      NJ_CHAR  *yomi, NJ_UINT16 len,
2309                                      NJ_UINT16 sfrom, NJ_UINT16 sto,
2310                                      NJ_UINT16 *from, NJ_UINT16 *to,
2311                                      NJ_UINT8 *forward_flag) {
2312    NJ_UINT16 right, mid = 0, left, max;
2313    NJ_UINT16 que_id;
2314    NJ_UINT8  *ptr, *p;
2315    NJ_CHAR  *str;
2316    NJ_INT16 ret = 0;
2317    NJ_INT32 found = 0;
2318    NJ_UINT8 slen;
2319    NJ_INT32 cmp;
2320
2321
2322
2323    ptr = get_search_index_address(handle, op);
2324
2325    max = GET_LEARN_WORD_COUNT(handle);
2326
2327    right = sto;
2328    left = sfrom;
2329
2330#ifdef LEARN_DEBUG
2331    printf("src:[%s]\n", yomi);
2332#endif
2333
2334    *forward_flag = 0;
2335
2336    while (left <= right) {
2337        mid = left + ((right - left) / 2);
2338        p = ptr + (mid * NJ_INDEX_SIZE);
2339        que_id = GET_UINT16(p);
2340        str = get_string(iwnn, handle, que_id, &slen);
2341        if (str == NULL) {
2342            return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_DIC_BROKEN);
2343        }
2344
2345
2346        ret = nj_strncmp(yomi, str, len);
2347
2348#ifdef LEARN_DEBUG
2349        printf("   [%d][%d][%d]COMPARE:[%s] = %d\n", left, mid, right, str, ret);
2350#endif
2351        if (ret == 0) {
2352
2353            found = 1;
2354            break;
2355        } else if (ret < 0) {
2356
2357            right = mid - 1;
2358            if (mid == 0) {
2359                break;
2360            }
2361        } else {
2362
2363            left = mid + 1;
2364        }
2365    }
2366
2367    if (!found) {
2368        return 0;
2369    }
2370
2371    if (mid == 0) {
2372        *from = mid;
2373    } else {
2374
2375        p = ((mid - 1) * NJ_INDEX_SIZE) + ptr;
2376
2377        for (cmp = mid - 1; cmp >= 0; cmp--) {
2378            que_id = GET_UINT16(p);
2379            str = get_string(iwnn, handle, que_id, &slen);
2380            if (str == NULL) {
2381                return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_DIC_BROKEN);
2382            }
2383
2384
2385            if (nj_strncmp(yomi, str, len) != 0) {
2386                break;
2387            }
2388            p -= NJ_INDEX_SIZE;
2389        }
2390        if (cmp < 0) {
2391            *from = 0;
2392        } else {
2393            *from = (NJ_UINT16)cmp + 1;
2394        }
2395    }
2396
2397#ifdef LEARN_DEBUG
2398    printf("  >> from:(%d)\n", *from);
2399#endif
2400
2401    if ((mid + 1) >= max) {
2402        *to = mid;
2403    } else {
2404
2405        p = ((mid + 1) * NJ_INDEX_SIZE) + ptr;
2406
2407        for (right = mid + 1; right < max; right++) {
2408            que_id = GET_UINT16(p);
2409            str = get_string(iwnn, handle, que_id, &slen);
2410            if (str == NULL) {
2411                return NJ_SET_ERR_VAL(NJ_FUNC_SEARCH_RANGE_BY_YOMI, NJ_ERR_DIC_BROKEN);
2412            }
2413
2414
2415            if (nj_strncmp(yomi, str, len) != 0) {
2416                break;
2417            }
2418            p += NJ_INDEX_SIZE;
2419        }
2420        *to = right - 1;
2421    }
2422
2423#ifdef LEARN_DEBUG
2424    printf("  >> to:(%d)\n", *to);
2425#endif
2426    return 1;
2427}
2428
2429