0
|
1 /*
|
|
2 * $Id: jikouho_d.c,v 1.6 2002/05/12 22:51:16 hiroo 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, 2002
|
|
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 /************************************************
|
|
33 * 大文節次候補取りだし *
|
|
34 ************************************************/
|
|
35 #ifdef HAVE_CONFIG_H
|
|
36 # include <config.h>
|
|
37 #endif
|
|
38
|
|
39 #include <stdio.h>
|
|
40 #include <ctype.h>
|
|
41 #if STDC_HEADERS
|
|
42 # include <stdlib.h>
|
|
43 #else
|
|
44 # if HAVE_MALLOC_H
|
|
45 # include <malloc.h>
|
|
46 # endif
|
|
47 #endif /* STDC_HEADERS */
|
|
48
|
|
49 #include "commonhd.h"
|
|
50 #include "de_header.h"
|
|
51 #include "jdata.h"
|
|
52 #include "fzk.h"
|
|
53 #include "kaiseki.h"
|
|
54
|
|
55 #ifdef CONVERT_from_TOP
|
|
56 static void sbn_set (), sons_set ();
|
|
57 #endif /* CONVERT_from_TOP */
|
|
58
|
|
59 static void dsd_hyouka (), cnt_sbn (), cnt_dbn ();
|
|
60 static int cmp_dsd_dbn (), jkt_dbn (), jkt_sbjunjo (), set_jkt_dai (), zen_sbn (), cnt_par (), cnt_son ();
|
|
61 static struct JKT_SBN *jkt_que_reorder ();
|
|
62
|
|
63 static int yomi_sno_tmp;
|
|
64
|
|
65 /*
|
|
66 * jkt_get_dai : 次候補 all 取りだし (大文節)
|
|
67 */
|
|
68 int
|
|
69 #ifdef NO_FZK
|
|
70 jkt_get_dai (yomi_sno, yomi_eno, beginvect, endvect, endvect1, nmax, dsd_dbn)
|
|
71 #else
|
|
72 jkt_get_dai (yomi_sno, yomi_eno, beginvect, fzkchar, endvect, endvect1, nmax, dsd_dbn)
|
|
73 #endif /* NO_FZK */
|
|
74 int yomi_sno;
|
|
75 int yomi_eno;
|
|
76 int beginvect; /* 前端ベクタ(-1:文節先頭、-2:なんでも)品詞No. */
|
|
77 #ifndef NO_FZK
|
|
78 w_char *fzkchar;
|
|
79 #endif /* NO_FZK */
|
|
80 int endvect; /* 終端ベクタ */
|
|
81 int endvect1; /* 終端ベクタ */
|
|
82 int nmax; /* 1大文節中の最大小文節数 */
|
|
83 struct DSD_DBN **dsd_dbn;
|
|
84 {
|
|
85 register int i;
|
|
86 register int cnt;
|
|
87 struct JKT_DBN *rjkt_dbn = 0;
|
|
88 register struct DSD_DBN *dbn;
|
|
89 int divid;
|
|
90
|
|
91 if (c_env->fzk_fid == -1)
|
|
92 {
|
|
93 wnn_errorno = WNN_FZK_FILE_NO_LOAD;
|
|
94 return (-1);
|
|
95 }
|
|
96 ft = (struct FT *) files[c_env->fzk_fid].area;
|
|
97 if ((cnt = jkt_dbn (yomi_sno, yomi_eno, beginvect,
|
|
98 #ifndef NO_FZK
|
|
99 fzkchar,
|
|
100 #endif /* NO_FZK */
|
|
101 endvect, endvect1, nmax, &rjkt_dbn)) < 0)
|
|
102 {
|
|
103 init_work_areas ();
|
|
104 return (-1);
|
|
105 }
|
|
106 if ((cnt = dbn_set (dsd_dbn, rjkt_dbn)) < 0)
|
|
107 {
|
|
108 init_work_areas ();
|
|
109 return (-1);
|
|
110 }
|
|
111 for (dbn = *dsd_dbn, i = cnt; i > 0; i--, dbn++)
|
|
112 {
|
|
113 dsd_hyouka (dbn);
|
|
114 if ((divid = get_jkt_status (dbn->sbn->kangovect, beginvect,
|
|
115 #ifndef NO_FZK
|
|
116 fzkchar,
|
|
117 #endif /* NO_FZK */
|
|
118 &(dbn->sbn->status))) != 0)
|
|
119 dbn->v_jc = DIVID_HYOUKA (dbn->v_jc, divid);
|
|
120 }
|
|
121 /* SORT */
|
|
122 qsort ((char *) *dsd_dbn, cnt, sizeof (struct DSD_DBN), cmp_dsd_dbn);
|
|
123 return (cnt);
|
|
124 }
|
|
125
|
|
126 static int
|
|
127 cmp_dsd_dbn (dbn1, dbn2)
|
|
128 struct DSD_DBN *dbn1;
|
|
129 struct DSD_DBN *dbn2;
|
|
130 {
|
|
131 return (dbn2->v_jc - dbn1->v_jc);
|
|
132 }
|
|
133
|
|
134 static void
|
|
135 dsd_hyouka (dbn)
|
|
136 struct DSD_DBN *dbn;
|
|
137 {
|
|
138 struct DSD_SBN *sbn;
|
|
139 int len; /* 大文節長 */
|
|
140 int son_v = 0;
|
|
141 register int j_c;
|
|
142 register struct DSD_SBN *s_p;
|
|
143 int i;
|
|
144
|
|
145 sbn = dbn->sbn;
|
|
146 j_c = sbn->bun_jc;
|
|
147 len = j_c - dbn->bun_m + 1;
|
|
148
|
|
149 for (i = 0, s_p = sbn; i < dbn->sbncnt; s_p++, i++)
|
|
150 {
|
|
151 son_v += s_p->v_jc;
|
|
152 }
|
|
153
|
|
154 dbn->v_jc = hyoka_dbn (son_v, dbn->sbncnt, len);
|
|
155 }
|
|
156
|
|
157 /*******************/
|
|
158
|
|
159 static int
|
|
160 #ifdef NO_FZK
|
|
161 jkt_dbn (yomi_sno, yomi_eno, beginvect, endvect, endvect1, nmax, rjkt_dbn)
|
|
162 #else
|
|
163 jkt_dbn (yomi_sno, yomi_eno, beginvect, fzkchar, endvect, endvect1, nmax, rjkt_dbn)
|
|
164 #endif /* NO_FZK */
|
|
165 int yomi_sno;
|
|
166 int yomi_eno;
|
|
167 int beginvect; /* 前端ベクタ(-1:文節先頭、-2:なんでも)品詞No. */
|
|
168 #ifndef NO_FZK
|
|
169 w_char *fzkchar;
|
|
170 #endif /* NO_FZK */
|
|
171 int endvect; /* 終端ベクタ */
|
|
172 int endvect1; /* 終端ベクタ */
|
|
173 register int nmax; /* 1大文節中の最大小文節数 */
|
|
174 struct JKT_DBN **rjkt_dbn; /* 次候補解析結果 */
|
|
175 {
|
|
176 register struct JKT_SBN **sb_que_head; /* 小文節解析結果 */
|
|
177 int tmp; /* 次候補ベクター数 */
|
|
178 struct JKT_SBN *db_tmp;
|
|
179 register struct JKT_SBN *sb_one;
|
|
180 struct JKT_SBN *sbn_tmp;
|
|
181 register struct JKT_SBN **sb_que_newcomer;
|
|
182 struct JKT_DBN *jktdbn = 0;
|
|
183 int dbncnt = 0;
|
|
184 #ifndef NO_KANA
|
|
185 int gijiflag = 0; /* 疑似文節を作ったか:最初の小文節のみ */
|
|
186 #endif /* NO_KANA */
|
|
187
|
|
188 yomi_sno_tmp = yomi_sno;
|
|
189
|
|
190 sb_que_head = &db_tmp;
|
|
191 *sb_que_head = NULL;
|
|
192
|
|
193 if ((tmp = zen_sbn (yomi_sno, yomi_eno, endvect, endvect1, sb_que_head, 1, (struct JKT_SBN *) 0
|
|
194 #ifndef NO_KANA
|
|
195 , &gijiflag
|
|
196 #endif /* NO_KANA */
|
|
197 )) <= 0)
|
|
198 return (tmp);
|
|
199
|
|
200 while (*sb_que_head != NULL)
|
|
201 {
|
|
202 sb_one = *sb_que_head;
|
|
203 *sb_que_head = sb_one->lnk_br;
|
|
204 if (nmax > sb_one->kbcnt && yomi_eno > sb_one->j_c + 1)
|
|
205 {
|
|
206 sb_que_newcomer = &sbn_tmp;
|
|
207 *sb_que_newcomer = NULL;
|
|
208 tmp = zen_sbn (sb_one->j_c + 1, yomi_eno, sb_one->kangovect, WNN_VECT_NO, sb_que_newcomer, sb_one->kbcnt + 1, sb_one
|
|
209 #ifndef NO_KANA
|
|
210 , 0
|
|
211 #endif /* NO_KANA */
|
|
212 );
|
|
213 if (tmp < 0)
|
|
214 {
|
|
215 return (-1); /* ERROR */
|
|
216 }
|
|
217 else if (tmp > 0)
|
|
218 {
|
|
219 sb_one->reference += tmp;
|
|
220 if (*sb_que_head != 0)
|
|
221 *sb_que_head = jkt_que_reorder (*sb_que_head, *sb_que_newcomer);
|
|
222 else
|
|
223 *sb_que_head = *sb_que_newcomer;
|
|
224 }
|
|
225 else
|
|
226 {
|
|
227 freejktsbn (sb_one);
|
|
228 }
|
|
229 }
|
|
230 else if (yomi_eno == sb_one->j_c + 1)
|
|
231 {
|
|
232 if (set_jkt_dai (rjkt_dbn, &jktdbn, sb_one) < 0)
|
|
233 return (-1);
|
|
234 dbncnt++;
|
|
235 }
|
|
236 }
|
|
237 #ifndef NO_KANA
|
|
238 /* ひらがな候補 */
|
|
239 if (gijiflag == 0)
|
|
240 {
|
|
241 if ((sb_one = get_hira_kouho (&db_tmp, yomi_sno, yomi_eno)) < (struct JKT_SBN *) 0)
|
|
242 return (-1);
|
|
243
|
|
244 if (sb_one > (struct JKT_SBN *) 0)
|
|
245 {
|
|
246 sb_one->parent = 0;
|
|
247 sb_one->bend_m = yomi_sno;
|
|
248 sb_one->kbcnt = 1;
|
|
249 if (set_jkt_dai (rjkt_dbn, &jktdbn, sb_one) < 0)
|
|
250 return (-1);
|
|
251 dbncnt++;
|
|
252 }
|
|
253 }
|
|
254 #endif /* NO_KANA */
|
|
255
|
|
256 return (dbncnt);
|
|
257 }
|
|
258
|
|
259 /* 前(beginvect,fzkchar)と接続できるか調べ、
|
|
260 接続できるとき 1
|
|
261 大文節の先頭の時 0
|
|
262 接続できないとき -1
|
|
263 を返す
|
|
264 get_status 参照
|
|
265 */
|
|
266
|
|
267 int
|
|
268 #ifdef NO_FZK
|
|
269 get_jkt_status (kangovect, beginvect, status)
|
|
270 #else
|
|
271 get_jkt_status (kangovect, beginvect, fzkchar, status)
|
|
272 #endif /* NO_FZK */
|
|
273 int kangovect;
|
|
274 int beginvect;
|
|
275 #ifndef NO_FZK
|
|
276 w_char *fzkchar;
|
|
277 #endif /* NO_FZK */
|
|
278 short *status;
|
|
279 {
|
|
280 extern int _status;
|
|
281 _status = 0;
|
|
282 return (get_status (kangovect, beginvect,
|
|
283 #ifndef NO_FZK
|
|
284 fzkchar,
|
|
285 #endif /* NO_FZK */
|
|
286 status));
|
|
287 }
|
|
288
|
|
289 /*
|
|
290 int
|
|
291 get_dsd_status(kangovect, beginvect, fzkchar, status)
|
|
292 int kangovect;
|
|
293 int beginvect;
|
|
294 w_char *fzkchar;
|
|
295 int *status;
|
|
296 {
|
|
297 if (zentan_able(kangovect, beginvect, fzkchar) == YES) {
|
|
298 if (beginvect == WNN_ALL_HINSI) {
|
|
299 if (kan_ckvt(sentou_no, kangovect) == WNN_CONNECT_BK) {
|
|
300 *status = WNN_SENTOU;
|
|
301 } else {
|
|
302 *status = WNN_NOT_CONNECT;
|
|
303 return (-1);
|
|
304 }
|
|
305 } else if (beginvect == WNN_BUN_SENTOU) {
|
|
306 *status = WNN_SENTOU;
|
|
307 } else {
|
|
308 if ((fzkchar == NULL || *fzkchar == NULL) && beginvect == sentou_no)
|
|
309 *status = WNN_SENTOU;
|
|
310 else
|
|
311 *status = WNN_CONNECT;
|
|
312 return (1);
|
|
313 }
|
|
314 } else if (kan_ckvt(sentou_no, kangovect) == WNN_CONNECT_BK) {
|
|
315 sb_one->status = WNN_SENTOU;
|
|
316 } else {
|
|
317 *status = WNN_NOT_CONNECT;
|
|
318 return (-1);
|
|
319 }
|
|
320 return(0);
|
|
321 }
|
|
322 */
|
|
323
|
|
324 /* 小文節の並び替え 長さとベクタでソートする */
|
|
325 /* que の先頭を返す */
|
|
326 static struct JKT_SBN *
|
|
327 jkt_que_reorder (que, new)
|
|
328 register struct JKT_SBN *que, *new;
|
|
329 {
|
|
330 struct JKT_SBN *que_sv;
|
|
331 register struct JKT_SBN *tmp;
|
|
332 register struct JKT_SBN *next;
|
|
333
|
|
334 if (new == 0)
|
|
335 return (que);
|
|
336 if (jkt_sbjunjo (que, new) < 0)
|
|
337 {
|
|
338 que_sv = new;
|
|
339 }
|
|
340 else
|
|
341 que_sv = que;
|
|
342
|
|
343 while (new != NULL)
|
|
344 {
|
|
345 next = new->lnk_br;
|
|
346 if (jkt_sbjunjo (que, new) < 0)
|
|
347 {
|
|
348 /* NEW が前 */
|
|
349 tmp = que;
|
|
350 que = new;
|
|
351 que->lnk_br = tmp;
|
|
352 new = next;
|
|
353 continue;
|
|
354 }
|
|
355 /* QUE が前 */
|
|
356 while ((jkt_sbjunjo (que, new) > 0) && que->lnk_br != NULL)
|
|
357 que = (que->lnk_br);
|
|
358 tmp = que->lnk_br;
|
|
359 /* QUE の後にNEW */
|
|
360 que->lnk_br = new;
|
|
361 new->lnk_br = tmp;
|
|
362 new = next;
|
|
363 }
|
|
364 return (que_sv);
|
|
365 }
|
|
366
|
|
367 /* que と new の順序
|
|
368 1: que が前
|
|
369 0: que の後に new
|
|
370 -1:new が前
|
|
371 XXXXX -2:同一順位 */
|
|
372 static int
|
|
373 jkt_sbjunjo (que, new)
|
|
374 struct JKT_SBN *que, *new;
|
|
375 {
|
|
376 if (new == 0)
|
|
377 return (1);
|
|
378 if (que->j_c > new->j_c)
|
|
379 return (-1);
|
|
380 if (que->j_c < new->j_c)
|
|
381 {
|
|
382 if (que->lnk_br == 0)
|
|
383 return (0);
|
|
384 if (que->lnk_br->j_c > new->j_c)
|
|
385 return (0);
|
|
386 if (que->lnk_br->j_c < new->j_c)
|
|
387 return (1);
|
|
388 if (que->lnk_br->kangovect > new->kangovect)
|
|
389 return (0);
|
|
390 return (1);
|
|
391 }
|
|
392 if (que->kangovect == new->kangovect)
|
|
393 return (0); /* return (-2); */
|
|
394 if (que->kangovect > new->kangovect)
|
|
395 return (-1);
|
|
396 if (que->lnk_br == 0)
|
|
397 return (0);
|
|
398 if (que->lnk_br->j_c > new->j_c)
|
|
399 return (0);
|
|
400 if (que->lnk_br->kangovect > new->kangovect)
|
|
401 return (0);
|
|
402 return (1);
|
|
403 }
|
|
404
|
|
405
|
|
406 /* 文節の先頭になれれば、大文節の候補をセットする */
|
|
407 static int
|
|
408 set_jkt_dai (rjkt_dbn, jktdbn, sbn)
|
|
409 struct JKT_DBN **rjkt_dbn;
|
|
410 register struct JKT_DBN **jktdbn;
|
|
411 register struct JKT_SBN *sbn;
|
|
412 {
|
|
413 struct JKT_DBN *getjktdbn ();
|
|
414
|
|
415 if (*jktdbn != 0)
|
|
416 {
|
|
417 if (((*jktdbn)->lnk_br = getjktdbn ()) == 0)
|
|
418 return (-1);
|
|
419 (*jktdbn) = (*jktdbn)->lnk_br;
|
|
420 }
|
|
421 else
|
|
422 {
|
|
423 if ((*rjkt_dbn = *jktdbn = getjktdbn ()) == 0)
|
|
424 return (-1);
|
|
425 }
|
|
426 (*jktdbn)->j_c = sbn->j_c;
|
|
427 (*jktdbn)->sbn_cnt = sbn->kbcnt;
|
|
428 (*jktdbn)->lnk_br = 0;
|
|
429 (*jktdbn)->sbn = sbn;
|
|
430 (*jktdbn)->bend_m = yomi_sno_tmp;
|
|
431 return (0);
|
|
432 }
|
|
433
|
|
434 static int
|
|
435 zen_sbn (yomi_sno, yomi_eno, endvect, endvect1, tjktsbn, bnst_num, parent
|
|
436 #ifndef NO_KANA
|
|
437 , gijiflagp
|
|
438 #endif /* NO_KANA */
|
|
439 )
|
|
440 int yomi_sno;
|
|
441 int yomi_eno;
|
|
442 int endvect; /* 終端ベクタ */
|
|
443 int endvect1; /* 終端ベクタ */
|
|
444 struct JKT_SBN **tjktsbn; /* 小文節解析結果 */
|
|
445 int bnst_num; /* これまでに解析した小文節数 */
|
|
446 struct JKT_SBN *parent; /* 親の幹語ノード */
|
|
447 #ifndef NO_KANA
|
|
448 int *gijiflagp;
|
|
449 #endif /* NO_KANA */
|
|
450 {
|
|
451 register int fzkcnt, ii, jktcnt;
|
|
452 register int i, /* 幹語の終わりのインデックス */
|
|
453 j; /* 文節始めのインデックス */
|
|
454 struct JKT_SBN *jktsbn_top = 0;
|
|
455 struct ICHBNP *ichbnpbp;
|
|
456 struct JKT_SBN *gijisbn_top;
|
|
457 int get_giji_flg = -1; /* 擬似文節を作れたか */
|
|
458 int cnt;
|
|
459 #ifndef NO_KANA
|
|
460 struct JKT_SBN *jktsbn;
|
|
461 int index_tmp;
|
|
462 struct fzkkouho *fzkptr;
|
|
463 int *vector1;
|
|
464 #endif
|
|
465
|
|
466 #ifndef NO_KATA
|
|
467 struct JKT_SBN *get_kata_kouho ();
|
|
468 #endif
|
|
469 struct JKT_SBN *get_hira_kouho ();
|
|
470 struct SYO_BNSETSU *giji_sbn;
|
|
471 struct SYO_BNSETSU *getsbnsp ();
|
|
472
|
|
473 if (yomi_sno == yomi_eno)
|
|
474 return (NOTHING);
|
|
475
|
|
476 if (fzk_ckvt (endvect) == NO && fzk_ckvt (endvect1) == NO)
|
|
477 return (NOTHING);
|
|
478 fzkcnt = fzk_kai (&bun[yomi_sno], &bun[yomi_eno], endvect, endvect1, &ichbnpbp);
|
|
479 if (fzkcnt <= 0)
|
|
480 return (fzkcnt); /* ERROR */
|
|
481 for (ii = 0; ii < fzkcnt; ii++)
|
|
482 getfzkoh (ichbnpbp, ii)->offset += yomi_sno;
|
|
483
|
|
484
|
|
485 for (ii = 0; ii < fzkcnt; ii++)
|
|
486 {
|
|
487 i = getfzkoh (ichbnpbp, ii)->offset;
|
|
488 if (jmtp[i] == (struct jdata **) UN_KNOWN) /* もう引いた? */
|
|
489 jmt_set (i); /* 辞書引き */
|
|
490 }
|
|
491
|
|
492 j = j_max (ichbnpbp, fzkcnt);
|
|
493 j = (j >= yomi_eno) ? yomi_eno - 1 : j;
|
|
494
|
|
495 jktcnt = 0;
|
|
496
|
|
497 #if !defined(NO_KANA) && !defined(KOREAN)
|
|
498 /* カタカナ疑似文節を取り出します */
|
|
499 if (gijiflagp != 0 && j < yomi_eno - 1)
|
|
500 {
|
|
501 for (ii = 0; ii < fzkcnt; ii++)
|
|
502 { /* 付属語 */
|
|
503 fzkptr = getfzkoh (ichbnpbp, ii);
|
|
504 if (bnst_num == 1)
|
|
505 vector1 = getfzkoh1 (ichbnpbp, ii)->vector;
|
|
506 else
|
|
507 vector1 = fzkptr->vector;
|
|
508 index_tmp = fzkptr->offset;
|
|
509 if ((jktsbn = get_kata_kouho (&jktsbn_top, yomi_sno, yomi_eno, fzkptr->offset, fzkptr->vector, vector1, ii)) < (struct JKT_SBN *) 0)
|
|
510
|
|
511 return (-1);
|
|
512 if (jktsbn > (struct JKT_SBN *) 0)
|
|
513 {
|
|
514 jktsbn->parent = parent;
|
|
515 jktsbn->bend_m = yomi_sno;
|
|
516 jktsbn->kbcnt = bnst_num;
|
|
517 jktcnt++;
|
|
518 }
|
|
519 } /* 付属語 */
|
|
520 }
|
|
521 #endif /* !defined(NO_KANA) && !defined(KOREAN) */
|
|
522 if ((giji_sbn = getsbnsp ()) == NO)
|
|
523 return (-1);
|
|
524 gijisbn_top = 0;
|
|
525 giji_sbn->bend_m = yomi_sno;
|
|
526 if (getgiji (yomi_sno, yomi_eno, giji_sbn, ichbnpbp, fzkcnt, bnst_num) >= 0)
|
|
527 {
|
|
528 if (giji_sbn->hinsi_fk != katakanago_no && giji_sbn->hinsi_fk != giji_no && giji_sbn->hinsi_fk != fuzokugo_no)
|
|
529 {
|
|
530 if (get_zen_giji (giji_sbn, &gijisbn_top) < 0)
|
|
531 return (-1);
|
|
532 gijisbn_top->parent = parent;
|
|
533 gijisbn_top->kbcnt = bnst_num;
|
|
534 get_giji_flg = giji_sbn->j_c;
|
|
535 #ifndef NO_KANA
|
|
536 if (gijiflagp != 0 && giji_sbn->j_c == yomi_eno - 1)
|
|
537 *gijiflagp = 1;
|
|
538 #endif /* NO_KANA */
|
|
539 jktcnt++;
|
|
540 }
|
|
541 }
|
|
542 freesbn (giji_sbn);
|
|
543
|
|
544 if (gijisbn_top != 0)
|
|
545 {
|
|
546 if (get_giji_flg > j)
|
|
547 {
|
|
548 gijisbn_top->lnk_br = jktsbn_top;
|
|
549 jktsbn_top = gijisbn_top;
|
|
550 get_giji_flg = -1;
|
|
551 }
|
|
552 }
|
|
553
|
|
554 for (; j >= yomi_sno; j--)
|
|
555 {
|
|
556 /* 文節の長さ */
|
|
557 if (get_giji_flg == j)
|
|
558 {
|
|
559 gijisbn_top->lnk_br = jktsbn_top;
|
|
560 jktsbn_top = gijisbn_top;
|
|
561 get_giji_flg = -1;
|
|
562 }
|
|
563 if ((cnt = jkt_sbn_one (yomi_sno, j + 1, &jktsbn_top, bnst_num, parent, ichbnpbp, fzkcnt)) < 0)
|
|
564 return (-1);
|
|
565 jktcnt += cnt;
|
|
566
|
|
567 }
|
|
568 *tjktsbn = jktsbn_top; /* 短いものから並べる */
|
|
569 freeibsp (ichbnpbp);
|
|
570 return (jktcnt);
|
|
571 }
|
|
572
|
|
573 struct DSD_DBN *
|
|
574 get_dsd_dbn (cnt)
|
|
575 register int cnt;
|
|
576 {
|
|
577 static struct DSD_DBN *m_dbn = 0;
|
|
578 static int md_cnt = 0;
|
|
579
|
|
580 if (md_cnt < cnt)
|
|
581 {
|
|
582 /* どんどんふくれる Jserver */
|
|
583 if (m_dbn)
|
|
584 free (m_dbn);
|
|
585 m_dbn = (struct DSD_DBN *) malloc (cnt * sizeof (struct DSD_DBN));
|
|
586 if (m_dbn == NULL)
|
|
587 {
|
|
588 /* 大きくなって天まで届け! */
|
|
589 wnn_errorno = WNN_JKTAREA_FULL;
|
|
590 error1 ("malloc err in dbn_set (at daibnsetsu jikouho).\n");
|
|
591 md_cnt = 0;
|
|
592 return ((struct DSD_DBN *) -1);
|
|
593 }
|
|
594 else
|
|
595 md_cnt = cnt;
|
|
596 }
|
|
597 return (m_dbn);
|
|
598 }
|
|
599
|
|
600 struct DSD_SBN *
|
|
601 get_dsd_sbn (cnt)
|
|
602 register int cnt;
|
|
603 {
|
|
604 static struct DSD_SBN *m_sbn = 0;
|
|
605 static int ms_cnt = 0;
|
|
606
|
|
607 if (ms_cnt < cnt)
|
|
608 {
|
|
609 if (m_sbn)
|
|
610 free (m_sbn);
|
|
611 m_sbn = (struct DSD_SBN *) malloc (cnt * sizeof (struct DSD_SBN));
|
|
612 if (m_sbn == NULL)
|
|
613 {
|
|
614 wnn_errorno = WNN_JKTAREA_FULL;
|
|
615 error1 ("malloc err in dbn_set (at daibnsetsu jikouho).\n");
|
|
616 ms_cnt = 0;
|
|
617 return ((struct DSD_SBN *) -1);
|
|
618 }
|
|
619 else
|
|
620 ms_cnt = cnt;
|
|
621 }
|
|
622 return (m_sbn);
|
|
623 }
|
|
624
|
|
625 int
|
|
626 dbn_set (dsd_dbn, dbn)
|
|
627 struct DSD_DBN **dsd_dbn;
|
|
628 register struct JKT_DBN *dbn;
|
|
629 {
|
|
630 register struct JKT_SBN *sbn;
|
|
631 register struct JKT_SONE *sone;
|
|
632 int i;
|
|
633 #ifndef CONVERT_from_TOP
|
|
634 int j, son, par;
|
|
635 #endif
|
|
636 struct JKT_DBN *next_dbn;
|
|
637
|
|
638 int cnt;
|
|
639 int dbn_cnt;
|
|
640 int sbn_cnt;
|
|
641 struct DSD_DBN *d_dbn;
|
|
642 struct DSD_SBN *d_sbn;
|
|
643 register struct DSD_SBN *p_sbn;
|
|
644 struct DSD_SBN *sv_sbn;
|
|
645
|
|
646 cnt_dbn (dbn, &cnt, &sbn_cnt);
|
|
647
|
|
648 if ((d_dbn = *dsd_dbn = get_dsd_dbn (cnt)) <= (struct DSD_DBN *) 0)
|
|
649 return (-1);
|
|
650 if ((sv_sbn = d_sbn = get_dsd_sbn (sbn_cnt)) <= (struct DSD_SBN *) 0)
|
|
651 return (-1);
|
|
652
|
|
653 while (dbn)
|
|
654 {
|
|
655 sbn = dbn->sbn;
|
|
656 cnt_sbn (sbn, &dbn_cnt, &sbn_cnt);
|
|
657 p_sbn = d_sbn = sv_sbn;
|
|
658 sv_sbn += sbn_cnt;
|
|
659 for (i = 0; i < dbn_cnt; i++)
|
|
660 {
|
|
661 d_dbn->bun_m = dbn->bend_m;
|
|
662 d_dbn->bun_jc = dbn->j_c;
|
|
663 d_dbn->sbncnt = dbn->sbn_cnt;
|
|
664 d_dbn->sbn = p_sbn;
|
|
665 p_sbn += dbn->sbn_cnt;
|
|
666 d_dbn++;
|
|
667 }
|
|
668 #ifdef CONVERT_from_TOP
|
|
669 sbn_set (dbn, &d_sbn, sone, dbn->sbn);
|
|
670
|
|
671 next_dbn = dbn->lnk_br;
|
|
672 freejktdbn (dbn);
|
|
673 dbn = next_dbn;
|
|
674 #else /* CONVERT_from_TOP */
|
|
675 for (sbn = dbn->sbn; sbn != 0; sbn = sbn->parent, d_sbn++)
|
|
676 {
|
|
677 son = cnt_son (dbn->sbn, sbn);
|
|
678 par = cnt_par (sbn);
|
|
679 p_sbn = d_sbn;
|
|
680 for (j = 0; j < son; j++)
|
|
681 {
|
|
682 for (sone = sbn->sbn; sone != 0; sone = sone->lnk_br)
|
|
683 {
|
|
684 for (i = 0; i < par; i++)
|
|
685 {
|
|
686 p_sbn->bun_m = sbn->bend_m;
|
|
687 p_sbn->bun_jc = sbn->j_c;
|
|
688 p_sbn->i_jc = sone->i_jc;
|
|
689 p_sbn->jentptr = sone->jentptr;
|
|
690 p_sbn->t_jc = sone->t_jc;
|
|
691 p_sbn->hinsi = sone->hinsi_fk;
|
|
692 p_sbn->kangovect = sbn->kangovect;
|
|
693 p_sbn->v_jc = sone->v_jc;
|
|
694 p_sbn->status_bkwd = sone->status_bkwd;
|
|
695 if (sbn->status == WNN_NOT_CONNECT && sone->jentptr == 0)
|
|
696 p_sbn->status = WNN_GIJI;
|
|
697 else
|
|
698 p_sbn->status = sbn->status;
|
|
699 p_sbn += dbn->sbn_cnt;
|
|
700 }
|
|
701 }
|
|
702 }
|
|
703 }
|
|
704 next_dbn = dbn->lnk_br;
|
|
705 freejktdbn (dbn);
|
|
706 dbn = next_dbn;
|
|
707 #endif /* CONVERT_from_TOP */
|
|
708 }
|
|
709 return (cnt);
|
|
710 }
|
|
711
|
|
712 #ifdef CONVERT_from_TOP
|
|
713 static void
|
|
714 sbn_set (dbn, pr_d_sbn, sone, sbn)
|
|
715 register struct JKT_DBN *dbn;
|
|
716 register struct DSD_SBN **pr_d_sbn;
|
|
717 register struct JKT_SONE *sone;
|
|
718 register struct JKT_SBN *sbn;
|
|
719 {
|
|
720 int son, par;
|
|
721 register struct DSD_SBN *p_sbn;
|
|
722 if (sbn != 0)
|
|
723 {
|
|
724 sbn_set (dbn, pr_d_sbn, sone, sbn->parent);
|
|
725
|
|
726 son = cnt_son (dbn->sbn, sbn);
|
|
727 par = cnt_par (sbn);
|
|
728 p_sbn = *pr_d_sbn;
|
|
729 sons_set (dbn, sone, sbn, p_sbn, son, par);
|
|
730
|
|
731 (*pr_d_sbn)++;
|
|
732 }
|
|
733 }
|
|
734
|
|
735 static void
|
|
736 sons_set (dbn, sone, sbn, p_sbn, son, par)
|
|
737 register struct JKT_DBN *dbn;
|
|
738 register struct JKT_SONE *sone;
|
|
739 register struct JKT_SBN *sbn;
|
|
740 register struct DSD_SBN *p_sbn;
|
|
741 register int son, par;
|
|
742 {
|
|
743 register int i, j;
|
|
744
|
|
745 for (j = 0; j < son; j++)
|
|
746 {
|
|
747 for (sone = sbn->sbn; sone != 0; sone = sone->lnk_br)
|
|
748 {
|
|
749 for (i = 0; i < par; i++)
|
|
750 {
|
|
751 p_sbn->bun_m = sbn->bend_m;
|
|
752 p_sbn->bun_jc = sbn->j_c;
|
|
753 p_sbn->i_jc = sone->i_jc;
|
|
754 p_sbn->jentptr = sone->jentptr;
|
|
755 p_sbn->t_jc = sone->t_jc;
|
|
756 p_sbn->hinsi = sone->hinsi_fk;
|
|
757 p_sbn->kangovect = sbn->kangovect;
|
|
758 p_sbn->v_jc = sone->v_jc;
|
|
759 p_sbn->status_bkwd = sone->status_bkwd;
|
|
760 if (sbn->status == WNN_NOT_CONNECT && sone->jentptr == 0)
|
|
761 p_sbn->status = WNN_GIJI;
|
|
762 else
|
|
763 p_sbn->status = sbn->status;
|
|
764 p_sbn += dbn->sbn_cnt;
|
|
765 }
|
|
766 }
|
|
767 }
|
|
768 }
|
|
769 #endif /* CONVERT_from_TOP */
|
|
770
|
|
771 /* 小文節の次候補の数 */
|
|
772 int
|
|
773 cnt_sone (sone)
|
|
774 register struct JKT_SONE *sone;
|
|
775 {
|
|
776 register int i = 0;
|
|
777 while (sone)
|
|
778 {
|
|
779 i++;
|
|
780 sone = sone->lnk_br;
|
|
781 }
|
|
782 return (i);
|
|
783 }
|
|
784
|
|
785 /* その文節以後の総文節数 */
|
|
786 static int
|
|
787 cnt_par (sbn)
|
|
788 register struct JKT_SBN *sbn;
|
|
789 {
|
|
790 register int cnt;
|
|
791 cnt = 1;
|
|
792 while (sbn->parent)
|
|
793 {
|
|
794 sbn = sbn->parent;
|
|
795 cnt *= cnt_sone (sbn->sbn);
|
|
796 }
|
|
797 return (cnt);
|
|
798 }
|
|
799
|
|
800 /* その文節以前の総文節数 */
|
|
801 static int
|
|
802 cnt_son (son, sbn)
|
|
803 register struct JKT_SBN *son;
|
|
804 register struct JKT_SBN *sbn;
|
|
805 {
|
|
806 register int cnt;
|
|
807 cnt = 1;
|
|
808 while (son != sbn)
|
|
809 {
|
|
810 cnt *= cnt_sone (son->sbn);
|
|
811 son = son->parent;
|
|
812 }
|
|
813 return (cnt);
|
|
814 }
|
|
815
|
|
816 /* 1 大文節中の小文節の数 */
|
|
817 static void
|
|
818 cnt_sbn (sbn, d_cnt, s_cnt)
|
|
819 register struct JKT_SBN *sbn;
|
|
820 register int *d_cnt;
|
|
821 register int *s_cnt;
|
|
822 {
|
|
823 *s_cnt = 0;
|
|
824 *d_cnt = 1;
|
|
825 while (sbn)
|
|
826 {
|
|
827 *d_cnt *= cnt_sone (sbn->sbn);
|
|
828 (*s_cnt)++;
|
|
829 sbn = sbn->parent;
|
|
830 }
|
|
831 *s_cnt *= *d_cnt;
|
|
832 }
|
|
833
|
|
834 /* 1 大文節の数 */
|
|
835 static void
|
|
836 cnt_dbn (dbn, dbn_cnt, sbn_cnt)
|
|
837 register struct JKT_DBN *dbn;
|
|
838 register int *dbn_cnt;
|
|
839 register int *sbn_cnt;
|
|
840 {
|
|
841 int dbn_cnt_tmp;
|
|
842 int sbn_cnt_tmp;
|
|
843
|
|
844 *dbn_cnt = 0;
|
|
845 *sbn_cnt = 0;
|
|
846 while (dbn)
|
|
847 {
|
|
848 cnt_sbn (dbn->sbn, &dbn_cnt_tmp, &sbn_cnt_tmp);
|
|
849 *dbn_cnt += dbn_cnt_tmp;
|
|
850 *sbn_cnt += sbn_cnt_tmp;
|
|
851 dbn = dbn->lnk_br;
|
|
852 }
|
|
853 }
|