1 /*
2 * $Id: jbiki_b.c,v 1.3 2001/06/14 18:16:02 ura Exp $
3 */
4
5 /*
6 * FreeWnn is a network-extensible Kana-to-Kanji conversion system.
7 * This file is part of FreeWnn.
8 *
9 * Copyright Kyoto University Research Institute for Mathematical Sciences
10 * 1987, 1988, 1989, 1990, 1991, 1992
11 * Copyright OMRON Corporation. 1987, 1988, 1989, 1990, 1991, 1992, 1999
12 * Copyright ASTEC, Inc. 1987, 1988, 1989, 1990, 1991, 1992
13 * Copyright FreeWnn Project 1999, 2000
14 *
15 * Maintainer: FreeWnn Project <freewnn@tomo.gr.jp>
16 *
17 * This program is free software; you can redistribute it and/or modify
18 * it under the terms of the GNU General Public License as published by
19 * the Free Software Foundation; either version 2 of the License, or
20 * (at your option) any later version.
21 *
22 * This program is distributed in the hope that it will be useful,
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 * GNU General Public License for more details.
26 *
27 * You should have received a copy of the GNU General Public License
28 * along with this program; if not, write to the Free Software
29 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
30 */
31
32 /** cWnn Version 1.1 **/
33
34 /********************************************
35 Modified by Zhong in Sept.1 1990
36 *********************************************
37 */
38 #include <stdio.h>
39 #include "commonhd.h"
40
41 #include "de_header.h"
42 #include "jdata.h"
43 #include "kaiseki.h"
44
45 #ifdef CONVERT_by_STROKE
46
47 #ifndef min
48 #define min(a, b) ( ((a) > (b))? (b):(a) )
49 #define max(a, b) ( ((a) < (b))? (b):(a) )
50 #endif
51
52 #define MAX_B_KOHO 64
53 #define MIN_B_KOHO 5
54
55 static void rd_biki_b (), set_kohos (), koho_insert (), b_koho_put ();
56 static int set_value ();
57
58 static int number; /** ���饤����Ȥμ����ֹ� */
59 static int prior;
60 static unsigned short *hinsistart;
61 static UCHAR *hindoin;
62 static UCHAR *hindostart;
63 static UCHAR *hindo2start;
64
65 struct b_koho *p_kohos[MAX_B_KOHO]; /* BiXing koho Buffer' Index */
66 struct b_koho b_kohos[MAX_B_KOHO]; /* BiXing koho Buffer */
67 static struct b_koho *cur_koho; /* */
68 static struct b_koho *last_koho; /* */
69 int cnt_k; /* Current koho */
70 int max_b_koho; /* MAX num of b_koho */
71
72 int
is_bwnn_rev_dict()73 is_bwnn_rev_dict ()
74 {
75 int k;
76 struct JT *jt;
77
78 for (k = 0; k < c_env->jishomax; k++)
79 {
80 number = c_env->jisho[k];
81 if (dic_table[c_env->jisho[k]].enablef)
82 {
83 jt = (struct JT *) (files[dic_table[c_env->jisho[k]].body].area);
84 if (jt->syurui == BWNN_REV_DICT && dic_table[c_env->jisho[k]].rev == 0)
85 {
86 return (1);
87 }
88 else
89 {
90 return (0);
91 }
92 }
93 }
94 return (0);
95 }
96
97 int
jishobiki_b(b_bgn,b_end)98 jishobiki_b (b_bgn, b_end) /* return number of b_koho */
99 int b_bgn;
100 int b_end;
101 {
102 register struct JT *jt;
103 int b_ptr; /* point to b_node */
104 register int k;
105
106 max_b_koho = min (MAX_B_KOHO, c_env->fuzokogo_val);
107 max_b_koho = max (MIN_B_KOHO, max_b_koho);
108 cnt_k = 0;
109 cur_koho = b_kohos; /* set init koho address */
110 last_koho = NULL;
111
112 for (k = 0; k < c_env->jishomax; k++)
113 {
114 number = c_env->jisho[k];
115 if (dic_table[c_env->jisho[k]].enablef)
116 {
117 jt = (struct JT *) (files[dic_table[c_env->jisho[k]].body].area);
118 prior = dic_table[c_env->jisho[k]].nice;
119
120 hindo2start = (dic_table[c_env->jisho[k]].hindo != -1) ? jt->hindo : NULL;
121 hindostart = (dic_table[c_env->jisho[k]].hindo != -1) ? ((struct HJT *) (files[dic_table[c_env->jisho[k]].hindo].area))->hindo : jt->hindo;
122
123 hinsistart = jt->hinsi;
124 if (jt->syurui == BWNN_REV_DICT)
125 {
126 b_ptr = jt->bind[0].pter_son;
127 rd_biki_b (jt, b_bgn, b_end - 1, b_ptr);
128 }
129 }
130 }
131 if (last_koho == NULL)
132 return (-1);
133 cnt_k = 0;
134 b_koho_put (last_koho); /* put b_kohos in sequence */
135 return (cnt_k);
136 }
137
138 /****************************************
139 "rd_biki_b()" is a recursive function, used for recursively search the
140 "b_index". When it is first called by "jishobiki_b()", the second
141 param "cur" is equel to one. " cur will become 2,3 .., when it is
142 called by itself for further deep levels.
143 **************************************/
144 static void
rd_biki_b(jt,cur,bend,b_ptr)145 rd_biki_b (jt, cur, bend, b_ptr)
146 struct JT *jt; /* dic head */
147 int cur; /* Input: input lenths */
148 int bend;
149 int b_ptr; /* Input: point to current b_node */
150 {
151 w_char *yo_kanji; /*pointing to yomi or kanji of a tuple */
152 struct b_node *bind;
153 int tmp_b_ptr;
154
155 bind = jt->bind;
156
157 if (bun[cur] == Q_MARK)
158 { /* Ignored w_char */
159 while (b_ptr != -1)
160 {
161 if (cur == bend)
162 set_kohos (jt, bind[b_ptr].pter);
163 else
164 rd_biki_b (jt, cur + 1, bend, bind[b_ptr].pter_son);
165 b_ptr = bind[b_ptr].pter_next;
166 }
167 return;
168 }
169 while (b_ptr != -1)
170 {
171 tmp_b_ptr = b_ptr;
172 while (bind[tmp_b_ptr].pter == -1)
173 tmp_b_ptr = bind[tmp_b_ptr].pter_son;
174 yo_kanji = KANJI_str (jt->ri2[bind[tmp_b_ptr].pter].kanjipter + jt->kanji, 0);
175 if (bun[cur] > yo_kanji[cur - 1])
176 b_ptr = bind[b_ptr].pter_next;
177 else
178 break;
179 }
180
181 if (b_ptr == -1)
182 return; /* not searched */
183 tmp_b_ptr = b_ptr;
184 while (bind[tmp_b_ptr].pter == -1)
185 tmp_b_ptr = bind[tmp_b_ptr].pter_son;
186 yo_kanji = KANJI_str (jt->ri2[bind[tmp_b_ptr].pter].kanjipter + jt->kanji, 0);
187 if (bun[cur] < yo_kanji[cur - 1])
188 return; /* not searched */
189
190 if (bun[cur] == yo_kanji[cur - 1])
191 { /* searched */
192
193 if (cur == bend) /* Set kohos */
194 set_kohos (jt, bind[b_ptr].pter);
195 else if (bind[b_ptr].pter_son != -1)
196 rd_biki_b (jt, cur + 1, bend, bind[b_ptr].pter_son);
197 }
198 }
199
200 static void
set_kohos(jt,cur_off2)201 set_kohos (jt, cur_off2)
202 struct JT *jt;
203 int cur_off2;
204 {
205 for (; cur_off2 != -1; cur_off2 = jt->ri2[cur_off2].next[0])
206 {
207
208
209 if (hindo2start && (*(hindo2start + cur_off2) & 0x7f) == 0x7f || (*(hindostart + cur_off2) & 0x7f) == 0x7f)
210 continue; /* Check masked word */
211
212 if (cnt_k < max_b_koho) /* is not a full table */
213 cnt_k++;
214 else
215 {
216 cur_koho = last_koho;
217 last_koho = last_koho->previou;
218 }
219 cur_koho->p_yomi = KANJI_str (((jt->ri2) + cur_off2)->kanjipter + jt->kanji, 0);
220 cur_koho->p_kanji = KANJI_str (((jt->ri2) + cur_off2)->kanjipter + jt->kanji, 1);
221 cur_koho->p_hinsi = hinsistart + cur_off2;
222 /* cur_off2 is serial */
223 cur_koho->p_hindo = hindostart + cur_off2;
224 if (hindo2start)
225 hindoin = hindo2start + cur_off2;
226 else
227 hindoin = NULL;
228 cur_koho->dic_no = number;
229 cur_koho->serial = cur_off2;
230 koho_insert (cur_koho);
231 cur_koho++;
232 }
233 }
234
235 static void
koho_insert(c_koho)236 koho_insert (c_koho)
237 register struct b_koho *c_koho;
238 {
239 register struct b_koho *t_koho1;
240 register struct b_koho *t_koho2;
241
242 if (last_koho == NULL)
243 { /* for first koho */
244 c_koho->value = set_value (c_koho);
245 last_koho = c_koho;
246 c_koho->previou = NULL;
247 return;
248 }
249 t_koho1 = last_koho;
250 t_koho2 = last_koho;
251 c_koho->value = set_value (c_koho);
252
253 while ((t_koho1 != NULL) && ((t_koho1->value) <= (c_koho->value)))
254 {
255 t_koho2 = t_koho1;
256 t_koho1 = t_koho1->previou;
257 }
258 if (t_koho1 == t_koho2) /* c_koho is the last koho */
259 last_koho = c_koho;
260 else
261 t_koho2->previou = c_koho;
262 c_koho->previou = t_koho1;
263 }
264
265 static int
set_value(koho)266 set_value (koho)
267 struct b_koho *koho;
268 {
269 if (hindoin != NULL)
270 return (hyoka1 (*(koho->p_hindo), *hindoin, 0, 0, prior));
271 else
272 return (hyoka1 (*(koho->p_hindo), 0, 0, 0, prior));
273 }
274
275 static void
b_koho_put(last)276 b_koho_put (last) /* put b_kohos in sequence */
277 struct b_koho *last;
278 {
279 if (last->previou != NULL)
280 b_koho_put (last->previou);
281 p_kohos[cnt_k++] = last;
282 }
283 #endif /* CONVERT_by_STROKE */
284