1 /*
2 * $Id: jishoop.c,v 1.6 2003/06/07 02:23:58 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, 2003
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 #if defined(HAVE_CONFIG_H)
33 #include <config.h>
34 #endif
35
36 #include <stdio.h>
37
38 #if defined(HAVE_SYS_TYPES_H)
39 #include <sys/types.h>
40 #endif
41
42 #include "commonhd.h"
43 #include "de_header.h"
44 #include "jdata.h"
45
46 static void make_space ();
47 static int word_add1 (), word_delete1 (), word_comment_set1 ();
48
49 #ifndef min
50 #define min(a, b) ((a > b)? b:a)
51 #define max(a, b) ((a < b)? b:a)
52 #endif
53
54 int
word_add(envi,dic_no,yomi,kanji,hinsi,hindo,comment)55 word_add (envi, dic_no, yomi, kanji, hinsi, hindo, comment)
56 int envi;
57 int dic_no;
58 w_char *yomi;
59 w_char *kanji, *comment;
60 int hinsi, hindo;
61 {
62 int fid, k;
63 struct JT *jtl;
64 struct HJT *hjtl;
65 int serial;
66
67 if (Strlen (yomi) >= LENGTHYOMI)
68 {
69 wnn_errorno = WNN_YOMI_LONG;
70 return (-1);
71 }
72 if (Strlen (kanji) + Strlen (comment) + Strlen (yomi) >= LENGTHKANJI)
73 {
74 wnn_errorno = WNN_KANJI_LONG;
75 return (-1);
76 }
77 if (Strlen (yomi) == 0)
78 {
79 wnn_errorno = WNN_NO_YOMI;
80 return (-1);
81 }
82 if (!dic_in_envp (dic_no, envi))
83 {
84 wnn_errorno = WNN_DICT_NOT_IN_ENV;
85 return (-1);
86 }
87 if (dic_table[dic_no].rw == WNN_DIC_RDONLY)
88 {
89 wnn_errorno = WNN_RDONLY;
90 return (-1);
91 }
92
93 jtl = (struct JT *) (files[dic_table[dic_no].body].area);
94
95 if (jtl->syurui == WNN_STATIC_DICT)
96 {
97 wnn_errorno = WNN_NOT_A_UD;
98 return (-1);
99 }
100
101 if (wnn_get_hinsi_name (hinsi) == NULL)
102 {
103 return (-1);
104 }
105 if (jtl->syurui == WNN_UD_DICT)
106 {
107 if ((serial = word_add1 (jtl, yomi, hinsi, kanji, comment)) == -1)
108 return (-1);
109 }
110 else
111 { /* jtl->syurui == WNN_REV_DICT || CWNN_REV_DICT */
112 if ((serial = rd_word_add1 (jtl, yomi, hinsi, kanji, comment)) == -1)
113 return (-1);
114 }
115 if (dic_table[dic_no].hindo != -1)
116 {
117 hjtl = (struct HJT *) (files[dic_table[dic_no].hindo].area);
118 if (serial >= hjtl->maxserial)
119 {
120 if (serial >= hjtl->bufsize_serial)
121 {
122 hindo_file_realloc (hjtl);
123 }
124 hjtl->maxserial = jtl->maxserial;
125 }
126 hjtl->hindo[serial] = asshuku (hindo) | 0x80;
127 hjtl->hdirty = 1;
128 }
129 else
130 {
131 jtl->hindo[serial] = asshuku (hindo) | 0x80;
132 jtl->hdirty = 1;
133 }
134 /* Since other hindo file may be used with this dictionary,
135 update the size of such hindo file */
136 fid = dic_table[dic_no].body;
137 for (k = 0; k < MAX_DIC; k++)
138 {
139 if (dic_table[k].body == fid && dic_table[k].hindo != -1)
140 {
141 hjtl = (struct HJT *) (files[dic_table[k].hindo].area);
142 if (serial >= hjtl->maxserial)
143 {
144 if (serial >= hjtl->bufsize_serial)
145 {
146 hindo_file_realloc (hjtl);
147 }
148 hjtl->maxserial = jtl->maxserial;
149 hjtl->hindo[serial] = 0;
150 hjtl->hdirty = 1;
151 }
152 }
153 }
154
155 jtl->dirty = 1;
156 return (0);
157 }
158
159
160 int
word_comment_set(envi,dic_no,serial,comment)161 word_comment_set (envi, dic_no, serial, comment)
162 int envi;
163 int dic_no;
164 int serial;
165 w_char *comment;
166 {
167 w_char yomi[LENGTHYOMI];
168 struct JT *jtl;
169
170 if (!dic_in_envp (dic_no, envi))
171 {
172 wnn_errorno = WNN_DICT_NOT_IN_ENV;
173 return (-1);
174 }
175
176 if (dic_table[dic_no].rw == WNN_DIC_RDONLY)
177 {
178 wnn_errorno = WNN_RDONLY;
179 return (-1);
180 }
181
182 jtl = (struct JT *) (files[dic_table[dic_no].body].area);
183
184 if (jtl->syurui == WNN_STATIC_DICT)
185 {
186 wnn_errorno = WNN_NOT_A_UD;
187 return (-1);
188 }
189
190 if (serial >= jtl->maxserial || serial < 0)
191 {
192 wnn_errorno = WNN_WORD_NO_EXIST;
193 return (-1);
194 }
195 get_yomi_from_serial (dic_no, serial, yomi);
196 jtl->dirty = 1;
197 return (word_comment_set1 ((struct JT *) (files[dic_table[dic_no].body].area), yomi, serial, comment));
198 }
199
200
201 int
word_delete(envi,dic_no,serial)202 word_delete (envi, dic_no, serial)
203 int envi;
204 int dic_no;
205 int serial;
206 {
207 w_char yomi[LENGTHYOMI];
208 struct JT *jtl;
209 struct HJT *hjtl;
210 int x, fid, k;
211
212 if (!dic_in_envp (dic_no, envi))
213 {
214 wnn_errorno = WNN_DICT_NOT_IN_ENV;
215 return (-1);
216 }
217
218 if (dic_table[dic_no].rw == WNN_DIC_RDONLY)
219 {
220 wnn_errorno = WNN_RDONLY;
221 return (-1);
222 }
223
224 jtl = (struct JT *) (files[dic_table[dic_no].body].area);
225 if (dic_table[dic_no].hindo != -1)
226 {
227 hjtl = (struct HJT *) (files[dic_table[dic_no].hindo].area);
228 }
229 else
230 hjtl = NULL;
231
232 if (jtl->syurui == WNN_STATIC_DICT)
233 {
234 wnn_errorno = WNN_NOT_A_UD;
235 return (-1);
236 }
237
238 if ((serial >= jtl->maxserial) || (serial < 0))
239 {
240 wnn_errorno = WNN_WORD_NO_EXIST;
241 return (-1);
242 }
243 if (get_yomi_from_serial (dic_no, serial, yomi) == -1)
244 {
245 wnn_errorno = WNN_WORD_NO_EXIST;
246 return (-1);
247 }
248 jtl->dirty = 1;
249 if (jtl->syurui == WNN_UD_DICT)
250 {
251 x = word_delete1 (jtl, hjtl, yomi, serial);
252 #if defined(CONVERT_by_STROKE) || defined(CONVERT_with_SiSheng)
253 }
254 else if ((jtl->syurui & 0xff) == WNN_REV_DICT)
255 {
256 #else
257 }
258 else if (jtl->syurui == WNN_REV_DICT)
259 {
260 #endif /* CONVERT_by_STROKE || CONVERT_with_SiSheng */
261 x = rd_word_delete1 (jtl, hjtl, serial);
262 }
263 else
264 {
265 wnn_errorno = WNN_NOT_A_UD;
266 x = -1;
267 }
268 if (x == -1)
269 return (-1);
270 /* Since other hindo file may be used with this dictionary,
271 update the size of such hindo file */
272 fid = dic_table[dic_no].body;
273 for (k = 0; k < MAX_DIC; k++)
274 {
275 if (dic_table[k].body == fid && dic_table[k].hindo != -1)
276 {
277 hjtl = (struct HJT *) (files[dic_table[k].hindo].area);
278 if (jtl->maxserial != hjtl->maxserial)
279 {
280 hjtl->maxserial = jtl->maxserial;
281 hjtl->hdirty = 1;
282 }
283 }
284 }
285 return (0);
286 }
287
288
289 static int
word_add1(jtl,pyomi,hinsi,kanji,comment)290 word_add1 (jtl, pyomi, hinsi, kanji, comment)
291 struct JT *jtl;
292 int hinsi;
293 w_char *kanji, *comment;
294 w_char *pyomi;
295 {
296 register struct uind1 *tary;
297 register struct uind2 *hopter, *hopter1;
298 register int key, key0, keye;
299 register struct uind2 *hop;
300 int len = Strlen (pyomi);
301 int serial = jtl->maxserial;
302 w_char yomi[LENGTHYOMI];
303
304 Sreverse (yomi, pyomi);
305
306 if ((jtl->bufsize_hontai <= jtl->maxhontai + sizeof (struct uind2) + Strlen (yomi))
307 && (ud_realloc_hontai (jtl) == NULL))
308 {
309 return (-1);
310 }
311 if ((jtl->bufsize_kanji <= jtl->maxkanji + (Strlen (kanji) + Strlen (comment) + Strlen (yomi) + 3) * sizeof (w_char) + 1)
312 && (ud_realloc_kanji (jtl) == NULL))
313 {
314 return (-1);
315 }
316 if (jtl->bufsize_serial <= jtl->maxserial + 4
317 && ud_realloc_serial (jtl) == NULL)
318 {
319 return (-1);
320 }
321 if (jtl->bufsize_table <= jtl->maxtable + sizeof (struct uind1)
322 && ud_realloc_table (jtl) == NULL)
323 {
324 return (-1);
325 }
326
327 tary = jtl->table;
328 hopter = (struct uind2 *) (jtl->hontai + jtl->maxhontai);
329
330 key = binary1 (tary, yomi, jtl->maxtable, jtl);
331 if (key < 0 || Strcmpud (&tary[key], yomi, jtl))
332 { /* No entry with same yomi */
333 key += 1;
334 for (key0 = key - 1; key0 >= 0; key0 = tary[key0].pter1)
335 {
336 hop = (struct uind2 *) (jtl->hontai + tary[key0].pter);
337 if (Substrud (&tary[key0], yomi, hop->yomi[0], jtl))
338 {
339 break;
340 }
341 }
342 make_space (tary, key, jtl);
343 for (keye = key + 1; keye < jtl->maxtable && Substrstud (yomi, &tary[keye], jtl); keye++)
344 {
345 if (tary[keye].pter1 == key0)
346 tary[keye].pter1 = key;
347 }
348 tary[key].pter1 = key0;
349 tary[key].yomi2 = 0;
350 tary[key].yomi1 = yomi[0] << 16;
351 if (yomi[1])
352 {
353 tary[key].yomi1 |= yomi[1];
354 if (yomi[2])
355 {
356 tary[key].yomi2 = yomi[2] << 16;
357 if (yomi[3])
358 {
359 tary[key].yomi2 |= yomi[3];
360 }
361 }
362 }
363 tary[key].pter = 0;
364 }
365 else
366 {
367 hopter1 = (struct uind2 *) (tary[key].pter + (char *) (jtl->hontai));
368 while (1)
369 {
370 w_char kanji1[LENGTHKANJI];
371 w_char comment1[LENGTHKANJI];
372 if (jtl->hinsi[hopter1->serial] == hinsi)
373 {
374 Get_kanji (hopter1->kanjipter + jtl->kanji, yomi, Strlen (yomi), kanji1, NULL, comment);
375 if (Strcmp (kanji, kanji1) == 0)
376 {
377 /* Same hinsi, same kanji, same yomi */
378 if (Strcmp (comment, comment1) != 0)
379 {
380 /* set_comment */
381 hopter1->kanjipter = jtl->maxkanji;
382 kanjiadd (jtl, kanji, yomi, comment);
383 }
384 return (hopter1->serial);
385 }
386 }
387 if (hopter1->next == 0)
388 break;
389 hopter1 = (struct uind2 *) (hopter1->next + (char *) (jtl->hontai));
390 }
391 }
392 hopter->next = tary[key].pter;
393 hopter->serial = jtl->maxserial++;
394 jtl->gosuu++;
395 hopter->kanjipter = jtl->maxkanji;
396 hopter->kosuu = 1;
397 hopter->yomi[0] = len;
398 Strncpy (hopter->yomi + 1, yomi + 4, len - 4);
399 tary[key].pter = (char *) hopter - (char *) (jtl->hontai);
400 jtl->maxhontai = (char *) (AL_INT (&(hopter->yomi[0]) + 1 + max ((len - 4), 0))) - (char *) (jtl->hontai);
401 jtl->hinsi[serial] = hinsi;
402 jtl->hindo[serial] = 0; /* Hindo is set later on upper module */
403 kanjiadd (jtl, kanji, yomi, comment);
404
405 return (serial);
406 }
407
408 void
kanjiadd(jtl,kanji,yomi,comment)409 kanjiadd (jtl, kanji, yomi, comment)
410 struct JT *jtl;
411 w_char *kanji, *comment, *yomi;
412 {
413 register UCHAR *dest = jtl->kanji + jtl->maxkanji;
414 int len;
415
416 #if defined(CONVERT_by_STROKE) || defined(CONVERT_with_SiSheng)
417 if ((jtl->syurui & 0xff) != WNN_REV_DICT)
418 {
419 #else
420 if (jtl->syurui != WNN_REV_DICT)
421 {
422 #endif /* CONVERT_by_STROKE || CONVERT_with_SiSheng */
423 yomi = NULL;
424 }
425 len = (int) kanjiaddr (dest, kanji, yomi, comment);
426 jtl->maxkanji += len;
427 }
428
429 static void
make_space(tary,key,jtl)430 make_space (tary, key, jtl)
431 register struct JT *jtl;
432 register struct uind1 *tary;
433 register int key;
434 {
435 register struct uind1 *p, *p1, *pend;
436 int end = jtl->maxtable;
437
438 pend = tary + key;
439 for (p = tary + end - 1, p1 = tary + end; p >= pend; p--, p1--)
440 {
441 *p1 = *p; /* struct no dainyuu! */
442 if (p1->pter1 >= key)
443 p1->pter1++;
444 }
445 jtl->maxtable++;
446 }
447
448 static void
remove_space(tary,key,jtl,newkey)449 remove_space (tary, key, jtl, newkey)
450 register struct JT *jtl;
451 register struct uind1 *tary;
452 register int key, newkey;
453 {
454 register struct uind1 *p, *p1, *pend;
455 register int end = jtl->maxtable;
456
457 pend = tary + end;
458 for (p = tary + key + 1, p1 = tary + key; p < pend; p++, p1++)
459 {
460 *p1 = *p;
461 if (p1->pter1 > key)
462 p1->pter1--;
463 else if (p1->pter1 == key)
464 p1->pter1 = newkey;
465 }
466 jtl->maxtable--;
467 }
468
469 int
dic_in_envp(dic_no,envi)470 dic_in_envp (dic_no, envi)
471 int dic_no;
472 int envi;
473 {
474 register int k;
475
476 for (k = 0; k < env[envi]->jishomax; k++)
477 {
478 if (env[envi]->jisho[k] == dic_no)
479 {
480 return (1);
481 }
482 }
483 return (0);
484 }
485
486 static int
word_delete1(jtl,hjtl,yomi,serial)487 word_delete1 (jtl, hjtl, yomi, serial)
488 struct JT *jtl;
489 struct HJT *hjtl;
490 w_char *yomi;
491 int serial;
492 {
493 int k;
494 register struct uind2 *hopter;
495 register struct uind2 *p;
496 register struct uind1 *tary;
497 register int ind1;
498 int *next_pter;
499 UCHAR *c;
500 int tmp;
501
502 tary = jtl->table;
503
504 ind1 = binary (tary, yomi, jtl->maxtable, jtl);
505 if (ind1 == -1)
506 {
507 wnn_errorno = WNN_WORD_NO_EXIST;
508 return (-1);
509 }
510
511 for (next_pter = &(tary[ind1].pter), p = ((struct uind2 *) ((tary[ind1].pter) + jtl->hontai));; next_pter = &p->next, p = ((struct uind2 *) ((p->next) + jtl->hontai)))
512 {
513
514 if ((int) p->serial <= (int) serial && (int) p->serial + (int) p->kosuu > (int) serial)
515 goto found_it;
516 if (p->next == ENDPTR)
517 break;
518 }
519 wnn_errorno = WNN_WORD_NO_EXIST;
520 return (-1);
521
522 found_it:
523 if (p->kosuu == 1)
524 {
525 *next_pter = p->next;
526 if (tary[ind1].pter == NULL)
527 remove_space (tary, ind1, jtl, tary[ind1].pter1);
528 if (p->serial == jtl->maxserial - 1)
529 {
530 jtl->maxserial--;
531 if (hjtl)
532 hjtl->maxserial--;
533 }
534 if ((int) p->kanjipter + (int) *(p->kanjipter + jtl->kanji) >= (int) jtl->maxkanji)
535 {
536 jtl->maxkanji = p->kanjipter;
537 }
538 if (jtl->maxhontai + (char *) (jtl->hontai) == (char *) (AL_INT (&(p->yomi[0]) + 1 + max (((int) p->yomi[0] - 4), 0))))
539 {
540 jtl->maxhontai = (char *) p - (char *) (jtl->hontai);
541 }
542 }
543 else if (p->serial == serial)
544 {
545 p->kosuu -= 1;
546 p->serial += 1;
547 p->kanjipter += *(p->kanjipter + jtl->kanji);
548 }
549 else if (p->serial + p->kosuu - 1 == serial)
550 {
551 p->kosuu -= 1;
552 }
553 else
554 { /* devide left space into 2 */
555
556 if (jtl->bufsize_hontai <= jtl->maxhontai + sizeof (struct uind2) + Strlen (yomi))
557 {
558 tmp = (char *) p - (char *) jtl->hontai;
559 if (ud_realloc_hontai (jtl) == NULL)
560 {
561 return (-1);
562 }
563 error1 ("Realloc in Word_delete for serial %d\n", serial);
564 p = (struct uind2 *) (tmp + jtl->hontai);
565
566 }
567 hopter = (struct uind2 *) (jtl->hontai + jtl->maxhontai);
568 hopter->next = p->next;
569 hopter->serial = serial + 1;
570
571 for (k = 0, c = p->kanjipter + jtl->kanji; k < serial - p->serial + 1; k++)
572 {
573 c += *c;
574 }
575 hopter->kanjipter = c - jtl->kanji;
576
577 hopter->kosuu = p->kosuu - (serial - p->serial) - 1;
578 hopter->yomi[0] = p->yomi[0];
579 Strncpy (hopter->yomi + 1, p->yomi + 1, max (((int) p->yomi[0] - 4), 0));
580 p->next = (char *) hopter - (char *) (jtl->hontai);
581 jtl->maxhontai = (char *) (AL_INT (&(hopter->yomi[0]) + 1 + max (((int) p->yomi[0] - 4), 0))) - (char *) (jtl->hontai);
582
583 p->kosuu = serial - p->serial;
584 }
585 jtl->hinsi[serial] = SAKUJO_HINSI;
586 jtl->gosuu--;
587 return (0);
588 }
589
590
591 static int
word_comment_set1(jtl,yomi,serial,comment)592 word_comment_set1 (jtl, yomi, serial, comment)
593 struct JT *jtl;
594 w_char *yomi;
595 int serial;
596 w_char *comment;
597 {
598 int k;
599 register struct uind2 *p;
600 register struct uind1 *tary;
601 register int ind1;
602 UCHAR *kptr;
603 w_char yomi1[LENGTHYOMI], kanji[LENGTHKANJI], ocomment[LENGTHKANJI];
604
605 tary = jtl->table;
606
607 if (jtl->syurui == WNN_UD_DICT)
608 {
609 ind1 = binary (tary, yomi, jtl->maxtable, jtl);
610 if (ind1 == -1)
611 {
612 wnn_errorno = WNN_WORD_NO_EXIST;
613 return (-1);
614 }
615
616 for (p = ((struct uind2 *) ((tary[ind1].pter) + jtl->hontai));; p = ((struct uind2 *) ((p->next) + jtl->hontai)))
617 {
618
619 if ((int) p->serial <= (int) serial && (int) p->serial + (int) p->kosuu > (int) serial)
620 {
621 kptr = p->kanjipter + jtl->kanji;
622 for (k = serial - p->serial; k > 0; k--)
623 {
624 kptr += *kptr;
625 }
626 goto found_it;
627 }
628 if (p->next == ENDPTR)
629 break;
630 }
631 wnn_errorno = WNN_WORD_NO_EXIST;
632 return (-1);
633 }
634 else
635 {
636 kptr = jtl->kanji + (jtl->ri2)[serial].kanjipter;
637 }
638 found_it:
639 get_kanji_str (kptr, kanji, yomi1, ocomment);
640 if (Strlen (ocomment) > Strlen (comment))
641 {
642 w_char *com, *kan, *yom;
643 Get_kanji_str_r (kptr, &kan, &yom, &com);
644 Strcpy (com, comment);
645 }
646 else
647 {
648 if (jtl->bufsize_kanji <= jtl->maxkanji + (Strlen (kanji) + Strlen (comment) + Strlen (yomi1) + 4) * 2)
649 {
650 if (ud_realloc_kanji (jtl) == NULL)
651 {
652 return (-1);
653 }
654 }
655 *(kptr + 1) = FORWARDED;
656 *(w_char *) (kptr + 2) = (jtl->maxkanji + jtl->kanji - kptr) >> 16;
657 *(w_char *) (kptr + 4) = (jtl->maxkanji + jtl->kanji - kptr) & 0xffff;
658
659 kanjiadd (jtl, kanji, yomi1, comment);
660 #if defined(CONVERT_by_STROKE) || defined(CONVERT_with_SiSheng)
661 if ((jtl->syurui & 0xff) == WNN_REV_DICT)
662 {
663 #else
664 if (jtl->syurui == WNN_REV_DICT)
665 {
666 #endif /* CONVERT_by_STROKE || CONVERT_with_SiSheng */
667 /* We need to spend one serial_no to ensure that the entry
668 before this and after this are not connected */
669 if (jtl->bufsize_serial <= jtl->maxserial + 4
670 && ud_realloc_serial (jtl) == NULL)
671 {
672 return (-1);
673 }
674 jtl->hinsi[jtl->maxserial] = SAKUJO_HINSI;
675 jtl->ri2[jtl->maxserial].kanjipter = 0xffffffff;
676 jtl->ri2[jtl->maxserial].next[D_YOMI] = jtl->ri2[jtl->maxserial].next[D_KANJI] = RD_ENDPTR;
677 jtl->maxserial++;
678 jtl->maxri2++;
679 }
680 }
681 return (0);
682
683 #ifdef nodef
684 /* UCHAR *c, *c0; */
685 /* int kan, len; */
686 if (p->kosuu == 1)
687 {
688 Get_kanji (p->kanjipter + jtl->kanji, yomi, Strlen (yomi), kanji, NULL, NULL);
689 if ((jtl->bufsize_kanji <= jtl->maxkanji + (Strlen (kanji) + Strlen (comment)) * sizeof (w_char) + 4)
690 && (ud_realloc_kanji (jtl) == NULL))
691 {
692 return (-1);
693 }
694 if (p->kanjipter + *(p->kanjipter + jtl->kanji) >= jtl->maxkanji)
695 {
696 jtl->maxkanji = p->kanjipter;
697 }
698 p->kanjipter = jtl->maxkanji;
699 kanjiadd (jtl, kanji, yomi, comment);
700 }
701 else
702 {
703 /*nagasa wo hakatte realloc */
704 for (k = 0, c = p->kanjipter + jtl->kanji; k < p->kosuu; k++)
705 c += *c;
706 len = c - (p->kanjipter + jtl->kanji);
707 while (jtl->bufsize_kanji <= jtl->maxkanji + (Strlen (kanji) + Strlen (comment)) * sizeof (w_char) + 4 + len)
708 {
709 if (ud_realloc_kanji (jtl) == NULL)
710 {
711 return (-1);
712 }
713 }
714 if (p->kanjipter + len >= jtl->maxkanji)
715 {
716 jtl->maxkanji = p->kanjipter;
717 }
718 kan = jtl->maxkanji;
719
720 /*mae made no nagasa wo hakatte bcopy */
721 for (k = 0, c = p->kanjipter + jtl->kanji; k < serial - p->serial; k++)
722 {
723 c += *c;
724 }
725 len = c - (p->kanjipter + jtl->kanji);
726 bcopy (p->kanjipter + jtl->kanji, jtl->maxkanji + jtl->kanji, len);
727
728 jtl->maxkanji += len;
729 Get_kanji (c, yomi, Strlen (yomi), kanji, NULL, NULL);
730 kanjiadd (jtl, kanji, yomi, comment);
731 c += *c;
732
733 c0 = c;
734 for (k = serial + 1, c = p->kanjipter + jtl->kanji; k < p->kosuu + p->serial; k++)
735 {
736 c += *c;
737 }
738 len = c - c0;
739 bcopy (c0, jtl->maxkanji + jtl->kanji, len);
740 jtl->maxkanji += len;
741 p->kanjipter = kan;
742 }
743 return (0);
744 #endif
745 }
746
747
748 int
hindo_file_size_justify(wfp,whfp)749 hindo_file_size_justify (wfp, whfp)
750 struct wnn_file *wfp, *whfp;
751 {
752 struct HJT *hjtp;
753 struct JT *jtp;
754 int k;
755
756 jtp = (struct JT *) (wfp->area);
757 hjtp = (struct HJT *) (whfp->area);
758
759 if (hjtp->maxserial != jtp->maxserial)
760 {
761 if (hjtp->maxserial < jtp->maxserial)
762 {
763 while (hjtp->bufsize_serial <= jtp->maxserial)
764 {
765 if (hindo_file_realloc (hjtp) == NULL)
766 return (-1);
767 }
768 error1 ("Dic file size is bigger than that of Hindo file!");
769 for (k = hjtp->maxserial; k < jtp->maxserial; k++)
770 {
771 hjtp->hindo[k] = 0;
772 }
773 }
774 else
775 {
776 error1 ("Hindo file size is bigger than that of Dic file!");
777 }
778 hjtp->maxserial = jtp->maxserial;
779 hjtp->hdirty = 1;
780 }
781 return (0);
782 }
783