Mercurial > freewnn
annotate PubdicPlus/pod.c @ 25:466fe6732d8d
- fixed more NULL pointer related errata
- suppress warnings
author | Yoshiki Yazawa <yaz@honeyplanet.jp> |
---|---|
date | Sat, 06 Mar 2010 04:37:31 +0900 |
parents | bbc77ca4def5 |
children | a7ccf412ba02 |
rev | line source |
---|---|
0 | 1 /* Copyright 1994 Pubdic Project. |
2 * | |
3 * Permission to use, copy, modify, distribute and sell this software | |
4 * and its documentation for any purpose is hereby granted without | |
5 * fee, provided that the above copyright notice appear in all copies | |
6 * and that both that copyright notice and this permission notice | |
7 * appear in supporting documentation, and that the name of Pubdic | |
8 * Project not be used in advertising or publicity pertaining to | |
9 * distribution of the software without specific, written prior | |
10 * permission. Pubdic Project makes no representations about the | |
11 * suitability of this software for any purpose. It is provided "as | |
12 * is" without express or implied warranty. | |
13 * | |
14 * PUBDIC PROJECT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, | |
15 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN | |
16 * NO EVENT SHALL PUBDIC PROJECT BE LIABLE FOR ANY SPECIAL, INDIRECT OR | |
17 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF | |
18 * USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR | |
19 * OTHER TORTUOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR | |
20 * PERFORMANCE OF THIS SOFTWARE. | |
21 */ | |
22 | |
23 #ifndef lint | |
24 static char rcsid[] = "$Id: pod.c,v 1.7 2005/12/10 18:50:43 aonoto Exp $"; | |
25 #endif | |
26 | |
27 #ifdef HAVE_CONFIG_H | |
28 # include <config.h> | |
29 #endif | |
30 | |
31 #include <stdio.h> | |
32 #if STDC_HEADERS | |
33 # include <stdlib.h> | |
34 # include <stddef.h> | |
35 # include <string.h> | |
36 #else | |
37 # if HAVE_MALLOC_H | |
38 # include <malloc.h> | |
39 # endif | |
40 # if HAVE_STRINGS_H | |
41 # include <strings.h> | |
42 # endif | |
43 #endif /* STDC_HEADERS */ | |
44 | |
45 #define POD_WCHAR | |
46 #ifdef POD_WCHAR | |
47 typedef unsigned short Wchar; | |
48 #else | |
49 #include <locale.h> | |
50 #include <widec.h> | |
51 #define Wchar wchar_t | |
52 #endif | |
53 | |
54 #if !(HAVE_BZERO) && (HAVE_MEMSET) | |
55 # define bzero(a, c) memset(a, 0, c) | |
56 #endif | |
57 | |
58 static char *program; | |
59 static int compare, ignore_hinshi_to_compare, sort_by_frequency, merge_sj3; | |
60 static int merge_kind, wnn_type_output, canna_type_output, sj3_type_output; | |
61 static int list_kinds; | |
62 static int copy_frequency, extract_kana = 0; | |
63 static long specific_kind; | |
64 static FILE *in1, *in2; | |
65 static char *common_out, *old_out, *new_out, *hinshi_table, *bunrui; | |
66 static char *description_table; | |
67 static int selhinshi = 0; | |
68 | |
69 /* hinshi_direction */ | |
70 #define INORDER 0 | |
71 #define REVERSE 1 | |
72 | |
73 static int hinshi_direction = INORDER; /* see above */ | |
74 | |
75 #define READBUFSIZE 128 | |
76 #define DICBUFSIZE (2 << 13) | |
77 #define DICBUFINDEXMASK (DICBUFSIZE - 1) | |
78 #define HINSHIBUFSIZE (2 << 13) | |
79 #define HINSHIBUFINDEXMASK (HINSHIBUFSIZE - 1) | |
80 | |
81 /* status of intern() */ | |
82 #define FOUND 0 | |
83 #define CREATE 1 | |
84 | |
85 /* 品詞を表す構造体 */ | |
86 | |
87 struct hinshipack | |
88 { | |
89 int nhinshis; | |
90 Wchar *hinshi; | |
91 unsigned flags; /* see below */ | |
92 struct hinshipack *next; | |
93 }; | |
94 | |
95 /* values of (struct hinshipack.)flags */ | |
96 #define REPLACED 1 | |
97 | |
98 /* 終止形を追加するためのルールファイルの内部表現(だと思う) */ | |
99 | |
100 struct descpack | |
101 { | |
102 Wchar *hinshi, *tandesc, *yomdesc; | |
103 struct descpack *next; | |
104 }; | |
105 | |
106 /* エントリの種別を表す構造体その他 */ | |
107 | |
108 struct kindpack | |
109 { | |
110 Wchar *kind; | |
111 long kindbit; | |
112 }; | |
113 | |
114 /* 辞書を表す構造体 */ | |
115 | |
116 struct dicpack | |
117 { | |
118 Wchar *yomi, *tango; | |
119 struct hinshipack *hinshi; | |
120 int hindo; | |
121 long kind; | |
122 Wchar *extdata; | |
123 unsigned flags; /* SEE BELOW */ | |
124 struct dicpack *next; | |
125 }; | |
126 | |
127 /* values of (struct dicpack.)flags */ | |
128 #define COMMON 001 | |
129 #define NEW 002 | |
130 | |
131 #if defined (__STDC__) || defined (_AIX) || (defined (__mips) && defined (_SYSTYPE_SVR4)) || defined(_WIN32) | |
132 /* Prototype for C89 (or later) */ | |
133 #ifdef POD_WCHAR | |
134 size_t Mbstowcs (Wchar *d, char *ss, int n); | |
135 size_t Wcstombs (char *d, Wchar *s, int n); | |
136 int Wscmp (register Wchar *s1, register Wchar *s2); | |
137 Wchar *Wscpy (Wchar *d, register Wchar *s); | |
138 int Wslen (Wchar *s); | |
139 int Watoi (Wchar *s); | |
140 static void Fputws (Wchar *s, FILE *f); | |
141 Wchar *Fgetws (Wchar *buf, int siz, FILE *f); | |
142 #endif /* POD_WCHAR */ | |
143 | |
144 static int all_kana (Wchar *s); | |
145 static Wchar *findslash (Wchar *s); | |
146 static Wchar *extstr (Wchar *p, Wchar **pp, int *key_return); | |
147 static void malloc_failed (void); | |
148 static struct hinshipack *internhinshi (Wchar *str, int flag); | |
149 static void replace_hinshi (void); | |
150 static void select_hinshi (int n); | |
151 static void freedesc (struct descpack *p); | |
152 static struct descpack *interndesc (Wchar *hin, Wchar *tan, Wchar *yom); | |
153 static struct descpack *searchdesc (Wchar *hin); | |
154 static void store_description (void); | |
155 static long internkind (Wchar *s); | |
156 static void listkinds (void); | |
25
466fe6732d8d
- fixed more NULL pointer related errata
Yoshiki Yazawa <yaz@honeyplanet.jp>
parents:
0
diff
changeset
|
157 static int kindcompar (const void *p1, const void *p2); |
0 | 158 static void sortkind (void); |
159 static struct dicpack *intern (int key, Wchar *yomi, Wchar *kouho, Wchar *hinshi, int hindo, long kind, int *stat, long flags); | |
160 static void storepd (FILE *file); | |
161 static void comparepd (FILE *file); | |
162 static void canna_output (FILE *cf, struct dicpack *p, Wchar *h, int n); | |
163 static void entry_out (FILE *cf, struct dicpack *p, Wchar *h, int n, Wchar *ex); | |
164 static void printentry (FILE *cf, struct dicpack *p); | |
165 static void showentry (struct dicpack **pd, int n); | |
25
466fe6732d8d
- fixed more NULL pointer related errata
Yoshiki Yazawa <yaz@honeyplanet.jp>
parents:
0
diff
changeset
|
166 static int diccompar (const void *pp1, const void *pp2); |
466fe6732d8d
- fixed more NULL pointer related errata
Yoshiki Yazawa <yaz@honeyplanet.jp>
parents:
0
diff
changeset
|
167 static int dichindocompar (const void *pp1, const void *pp2); |
0 | 168 void shrinkargs (char **argv, int n, int count); |
169 static void parseargs (int argc, char *argv[]); | |
170 #endif | |
171 | |
172 #ifndef POD_WCHAR | |
173 # define Mbstowcs mbstowcs | |
174 # define Wcstombs wcstombs | |
175 # define Wscmp wscmp | |
176 # define Wscpy wscpy | |
177 # define Wslen wslen | |
178 # define Fgetws fgetws | |
179 # define Fputws fputws | |
180 #else | |
181 # define SS2 0x8e | |
182 # define SS3 0x8f | |
183 # define MSB 0x80 | |
184 # define MSK 0x7f | |
185 | |
186 # define WCG0 0x0000 | |
187 # define WCG1 0x8080 | |
188 # define WCG2 0x0080 | |
189 # define WCG3 0x8000 | |
190 # define WCMSK 0x8080 | |
191 | |
192 size_t | |
193 Mbstowcs (d, ss, n) | |
194 Wchar *d; | |
195 char *ss; | |
196 int n; | |
197 { | |
198 register Wchar *p = d; | |
199 register int ch; | |
200 register unsigned char *s = (unsigned char *) ss; | |
201 | |
202 while ((ch = *s++) && (p - d < n)) | |
203 { | |
204 if (ch & MSB) | |
205 { | |
206 if (ch == SS2) | |
207 { /* kana */ | |
208 *p++ = (Wchar) * s++; | |
209 } | |
210 else if (ch == SS3) | |
211 { | |
212 *p++ = (Wchar) ((*s << 8) | (*(s + 1) & MSK)); | |
213 s += 2; | |
214 } | |
215 else | |
216 { | |
217 *p++ = (Wchar) ((ch << 8) | (*s++ & 0xff)); | |
218 } | |
219 } | |
220 else | |
221 { | |
222 *p++ = (Wchar) ch; | |
223 } | |
224 } | |
225 *p = (Wchar) 0; | |
226 return p - d; | |
227 } | |
228 | |
229 size_t | |
230 Wcstombs (d, s, n) | |
231 char *d; | |
232 Wchar *s; | |
233 int n; | |
234 { | |
235 register char *p = d; | |
236 register Wchar ch; | |
237 | |
238 while ((ch = *s++) && (p - d + 2 < n)) | |
239 { | |
240 switch (ch & WCMSK) | |
241 { | |
242 case WCG0: | |
243 *p++ = (char) ch; | |
244 break; | |
245 | |
246 case WCG1: | |
247 *p++ = (char) ((ch >> 8) & 0xff); | |
248 *p++ = (char) (ch & 0xff); | |
249 break; | |
250 | |
251 case WCG2: | |
252 *p++ = SS2; | |
253 *p++ = (char) ch; | |
254 break; | |
255 | |
256 case WCG3: | |
257 *p++ = SS3; | |
258 *p++ = (char) ((ch >> 8) & 0xff); | |
259 *p++ = (char) ((ch & 0xff) | MSB); | |
260 break; | |
261 } | |
262 } | |
263 *p = '\0'; | |
264 return p - d; | |
265 } | |
266 | |
267 int | |
268 Wscmp (s1, s2) | |
269 register Wchar *s1, *s2; | |
270 { | |
271 register int res; | |
272 | |
273 /* 以下のコードはいささかトリッキーなので、説明を加えておこう。 | |
274 以下ではこのコメント内にあるようなことをしたいわけである。 | |
275 | |
276 while (*s1 && *s2 && && *s1 == *s2) { | |
277 s1++; s2++; | |
278 } | |
279 return *s1 - *s2; | |
280 | |
281 すなわち、s1 も s2 も EOS ('\0') を指していなくて、しかも値が | |
282 異なる間はそれぞれのポインタを進める。いずれかが EOS になるか、 | |
283 値が違ってきた場合には、*s1 - *s2 を返す。 | |
284 */ | |
285 | |
286 while (!(res = *s1 - *s2++) && *s1++) | |
287 ; | |
288 return res; | |
289 } | |
290 | |
291 Wchar * | |
292 Wscpy (d, s) | |
293 Wchar *d; | |
294 register Wchar *s; | |
295 { | |
296 register Wchar *p = d, ch; | |
297 | |
298 while (ch = *s++) | |
299 { | |
300 *p++ = ch; | |
301 } | |
302 *p = (Wchar) 0; | |
303 return d; | |
304 } | |
305 | |
306 int | |
307 Wslen (s) | |
308 Wchar *s; | |
309 { | |
310 register Wchar *p = s; | |
311 | |
312 while (*p) | |
313 p++; | |
314 return p - s; | |
315 } | |
316 | |
317 int | |
318 Watoi (s) | |
319 Wchar *s; | |
320 { | |
321 register int res = 0; | |
322 register Wchar ch; | |
323 | |
324 while ((ch = *s++) && ((Wchar) '0' <= ch) && (ch <= (Wchar) '9')) | |
325 { | |
326 res *= 10; | |
327 res += ch - (Wchar) '0'; | |
328 } | |
329 return res; | |
330 } | |
331 | |
332 static void | |
333 Fputws (s, f) | |
334 Wchar *s; | |
335 FILE *f; | |
336 { | |
337 char buf[READBUFSIZE]; | |
338 | |
339 if (Wcstombs (buf, s, READBUFSIZE)) | |
340 { | |
341 (void) fputs (buf, f); | |
342 } | |
343 } | |
344 | |
345 Wchar * | |
346 Fgetws (buf, siz, f) | |
347 Wchar *buf; | |
348 int siz; | |
349 FILE *f; | |
350 { | |
351 char mbuf[READBUFSIZE], *p; | |
352 | |
353 p = fgets (mbuf, READBUFSIZE, f); | |
354 if (p) | |
355 { | |
356 if (Mbstowcs (buf, mbuf, siz)) | |
357 { | |
358 return buf; | |
359 } | |
360 } | |
361 return (Wchar *) 0; | |
362 } | |
363 #endif | |
364 | |
365 /* s が全てカタカナから構成されているかどうかを返す関数 */ | |
366 | |
367 static int | |
368 all_kana (s) | |
369 Wchar *s; | |
370 { | |
371 static Wchar xa = 0, xke, aa, *p; | |
372 | |
373 if (!xa) | |
374 { | |
375 Mbstowcs (&xa, "\045\041", 1); | |
376 Mbstowcs (&xke, "\045\166", 1); | |
377 Mbstowcs (&aa, "\041\074", 1); | |
378 } | |
379 | |
380 for (p = s; *p; p++) | |
381 { | |
382 if (!(*p == aa || (xa <= *p && *p <= xke))) | |
383 { | |
384 return 0; | |
385 } | |
386 } | |
387 | |
388 return 1; | |
389 } | |
390 | |
391 /* スラッシュを探す */ | |
392 | |
393 static Wchar * | |
394 findslash (s) | |
395 Wchar *s; | |
396 { | |
397 while (*s) | |
398 { | |
399 if (*s == (Wchar) '/') | |
400 { | |
401 return s; | |
402 } | |
403 s++; | |
404 } | |
405 return (Wchar *) 0; | |
406 } | |
407 | |
408 /* トークンを一個取り出す */ | |
409 | |
410 static Wchar * | |
411 extstr (p, pp, key_return) | |
412 Wchar *p, **pp; | |
413 int *key_return; | |
414 { | |
415 Wchar *res; | |
416 int key = 0; | |
417 | |
418 while (*p == (Wchar) ' ' || *p == (Wchar) '\t') | |
419 p++; | |
420 res = p; | |
421 while (*p && *p != (Wchar) ' ' && *p != (Wchar) '\t' && *p != (Wchar) '\n') | |
422 { | |
423 key += (int) *p++; | |
424 } | |
425 *p++ = (Wchar) '\0'; | |
426 if (pp) | |
427 *pp = p; | |
428 if (key_return) | |
429 *key_return = key; | |
430 return res; | |
431 } | |
432 | |
433 static struct hinshipack *partsofspeech[HINSHIBUFSIZE]; | |
434 | |
435 static void | |
436 malloc_failed () | |
437 { | |
438 (void) fprintf (stderr, "%s: malloc failed.\n", program); | |
439 } | |
440 | |
441 /* 品詞名を品詞名テーブルに登録する */ | |
442 | |
443 static struct hinshipack * | |
444 internhinshi (str, flag) | |
445 Wchar *str; | |
446 int flag; | |
447 { | |
448 struct hinshipack *p, **pp; | |
449 Wchar *s; | |
450 int key = 0; | |
451 | |
452 for (s = str; *s; s++) | |
453 key += (int) *s; | |
454 key = ((unsigned) key & HINSHIBUFINDEXMASK); | |
455 for (pp = partsofspeech + key; p = *pp; pp = &(p->next)) | |
456 { | |
457 if (!Wscmp (p->hinshi, str)) | |
458 { | |
459 return p; | |
460 } | |
461 } | |
462 if (flag) | |
463 { | |
464 p = (struct hinshipack *) malloc (sizeof (struct hinshipack)); | |
465 if (p) | |
466 { | |
467 *pp = p; | |
468 (void) bzero (p, sizeof (struct hinshipack)); | |
469 p->hinshi = (Wchar *) malloc ((Wslen (str) + 1) * sizeof (Wchar)); | |
470 if (p->hinshi) | |
471 { | |
472 (void) Wscpy (p->hinshi, str); | |
473 p->nhinshis = 1; | |
474 return p; | |
475 } | |
476 free (p); | |
477 } | |
478 malloc_failed (); | |
479 } | |
480 return (struct hinshipack *) 0; | |
481 } | |
482 | |
483 /* 品詞名を置き換える */ | |
484 | |
485 static void | |
486 replace_hinshi () | |
487 { | |
488 FILE *f; | |
489 Wchar readbuf[READBUFSIZE], *to, *from, *s; | |
490 struct hinshipack *hinshientry, *p; | |
491 int i, err = 0; | |
492 | |
493 f = fopen (hinshi_table, "r"); | |
494 if (!f) | |
495 { | |
496 (void) fprintf (stderr, "%s: can not open the table file of parts of speech \"%s\".\n", program, hinshi_table); | |
497 exit (1); | |
498 } | |
499 while (s = Fgetws (readbuf, READBUFSIZE, f)) | |
500 { | |
501 from = extstr (s, &s, 0); | |
502 to = extstr (s, &s, 0); | |
503 if (hinshi_direction == REVERSE) | |
504 { | |
505 Wchar *xx = from; | |
506 from = to; | |
507 to = xx; | |
508 } | |
509 | |
510 hinshientry = internhinshi (from, 0); | |
511 if (hinshientry) | |
512 { | |
513 Wchar *xx; | |
514 | |
515 xx = (Wchar *) malloc ((Wslen (to) + 1) * sizeof (Wchar)); | |
516 if (xx) | |
517 { | |
518 Wchar *cp; | |
519 int n = 1; | |
520 | |
521 (void) Wscpy (xx, to); | |
522 free (hinshientry->hinshi); | |
523 hinshientry->hinshi = xx; | |
524 for (cp = xx; *cp; cp++) | |
525 { | |
526 if (*cp == (Wchar) '/') | |
527 { | |
528 *cp = (Wchar) 0; | |
529 n++; | |
530 } | |
531 } | |
532 hinshientry->nhinshis = n; | |
533 hinshientry->flags |= REPLACED; | |
534 } | |
535 else | |
536 { | |
537 malloc_failed (); | |
538 } | |
539 } | |
540 } | |
541 (void) fclose (f); | |
542 | |
543 for (i = 0; i < HINSHIBUFSIZE; i++) | |
544 { | |
545 for (p = partsofspeech[i]; p; p = p->next) | |
546 { | |
547 if (!(p->flags & REPLACED)) | |
548 { | |
549 (void) fprintf (stderr, "%s: The replacement for \"", program); | |
550 Fputws (p->hinshi, stderr); | |
551 (void) fprintf (stderr, "\" is not mentioned in the table.\n"); | |
552 err = 1; | |
553 } | |
554 } | |
555 } | |
556 if (err) | |
557 { | |
558 exit (1); | |
559 } | |
560 } | |
561 | |
562 static void | |
563 select_hinshi (n) | |
564 int n; | |
565 { | |
566 Wchar *s, *t, *xx; | |
567 struct hinshipack *p; | |
568 int i; | |
569 | |
570 if (!n) | |
571 return; | |
572 | |
573 for (i = 0; i < HINSHIBUFSIZE; i++) | |
574 { | |
575 for (p = partsofspeech[i]; p; p = p->next) | |
576 { | |
577 switch (n) | |
578 { | |
579 case 1: | |
580 s = findslash (p->hinshi); | |
581 if (s) | |
582 { | |
583 *s = (Wchar) 0; | |
584 } | |
585 break; | |
586 | |
587 case 2: | |
588 s = findslash (p->hinshi); | |
589 if (s) | |
590 { | |
591 s++; | |
592 t = findslash (s); | |
593 if (t) | |
594 { | |
595 xx = (Wchar *) malloc ((t - s + 1) * sizeof (Wchar)); | |
596 if (xx) | |
597 { | |
598 *t = (Wchar) 0; | |
599 Wscpy (xx, s); | |
600 t = p->hinshi; | |
601 p->hinshi = xx; | |
602 (void) free ((char *) t); | |
603 } | |
604 } | |
605 } | |
606 break; | |
607 | |
608 case 3: | |
609 s = findslash (p->hinshi); | |
610 if (s) | |
611 { | |
612 t = findslash (s + 1); | |
613 if (t) | |
614 { | |
615 t++; | |
616 xx = (Wchar *) malloc ((Wslen (t) + 1) * sizeof (Wchar)); | |
617 if (xx) | |
618 { | |
619 Wscpy (xx, t); | |
620 t = p->hinshi; | |
621 p->hinshi = xx; | |
622 (void) free ((char *) t); | |
623 } | |
624 } | |
625 } | |
626 break; | |
627 | |
628 default: | |
629 break; | |
630 } | |
631 } | |
632 } | |
633 } | |
634 | |
635 static void | |
636 freedesc (p) | |
637 struct descpack *p; | |
638 { | |
639 free (p->hinshi); | |
640 free (p->tandesc); | |
641 free (p->yomdesc); | |
642 free (p); | |
643 } | |
644 | |
645 static struct descpack *description[HINSHIBUFSIZE]; | |
646 | |
647 /* ルールの登録 */ | |
648 | |
649 static struct descpack * | |
650 interndesc (hin, tan, yom) | |
651 Wchar *hin, *tan, *yom; | |
652 { | |
653 struct descpack *p, **pp, *next = (struct descpack *) 0; | |
654 Wchar *s; | |
655 int key = 0; | |
656 | |
657 for (s = hin; *s; s++) | |
658 key += (int) *s; | |
659 key = ((unsigned) key & HINSHIBUFINDEXMASK); | |
660 for (pp = description + key; p = *pp; pp = &(p->next)) | |
661 { | |
662 if (!Wscmp (p->hinshi, hin)) | |
663 { | |
664 if (!Wscmp (p->tandesc, tan) && !Wscmp (p->yomdesc, yom)) | |
665 { | |
666 return p; | |
667 } | |
668 else | |
669 { | |
670 *pp = next = p->next; | |
671 freedesc (p); | |
672 break; | |
673 } | |
674 } | |
675 } | |
676 p = (struct descpack *) malloc (sizeof (struct descpack)); | |
677 if (p) | |
678 { | |
679 *pp = p; | |
680 (void) bzero (p, sizeof (struct descpack)); | |
681 p->next = next; | |
682 p->hinshi = (Wchar *) malloc ((Wslen (hin) + 1) * sizeof (Wchar)); | |
683 if (p->hinshi) | |
684 { | |
685 (void) Wscpy (p->hinshi, hin); | |
686 p->tandesc = (Wchar *) malloc ((Wslen (tan) + 1) * sizeof (Wchar)); | |
687 if (p->tandesc) | |
688 { | |
689 (void) Wscpy (p->tandesc, tan); | |
690 p->yomdesc = (Wchar *) malloc ((Wslen (yom) + 1) * sizeof (Wchar)); | |
691 if (p->yomdesc) | |
692 { | |
693 (void) Wscpy (p->yomdesc, yom); | |
694 return p; | |
695 } | |
696 free (p->tandesc); | |
697 } | |
698 free (p->hinshi); | |
699 } | |
700 free (p); | |
701 } | |
702 malloc_failed (); | |
703 return (struct descpack *) 0; | |
704 } | |
705 | |
706 /* ルールの探索 */ | |
707 | |
708 static struct descpack * | |
709 searchdesc (hin) | |
710 Wchar *hin; | |
711 { | |
712 struct descpack *p, **pp; | |
713 Wchar *s; | |
714 int key = 0; | |
715 | |
716 for (s = hin; *s; s++) | |
717 key += (int) *s; | |
718 key = ((unsigned) key & HINSHIBUFINDEXMASK); | |
719 for (pp = description + key; p = *pp; pp = &(p->next)) | |
720 { | |
721 if (!Wscmp (p->hinshi, hin)) | |
722 { | |
723 return p; | |
724 } | |
725 } | |
726 return (struct descpack *) 0; | |
727 } | |
728 | |
729 static void | |
730 store_description () | |
731 { | |
732 FILE *f; | |
733 Wchar readbuf[READBUFSIZE], *hin, *tan, *yom, *s; | |
734 | |
735 if (!description_table) | |
736 { | |
737 return; | |
738 } | |
739 | |
740 f = fopen (description_table, "r"); | |
741 if (!f) | |
742 { | |
743 (void) fprintf (stderr, "%s: can not open the table file of parts of speech \"%s\".\n", program, description_table); | |
744 exit (1); | |
745 } | |
746 while (s = Fgetws (readbuf, READBUFSIZE, f)) | |
747 { | |
748 Wchar nl[1]; | |
749 | |
750 nl[0] = (Wchar) 0; | |
751 hin = tan = yom = nl; | |
752 hin = extstr (s, &s, 0); | |
753 if (*hin) | |
754 { | |
755 tan = extstr (s, &s, 0); | |
756 if (*tan) | |
757 { | |
758 yom = extstr (s, &s, 0); | |
759 } | |
760 } | |
761 | |
762 interndesc (hin, tan, yom); | |
763 } | |
764 (void) fclose (f); | |
765 } | |
766 | |
767 struct kindpack kinds[sizeof (long) * 8]; | |
768 static int nkinds; | |
769 | |
770 #define KIHONBIT 1L | |
771 | |
772 /* 種別の登録 */ | |
773 | |
774 static long | |
775 internkind (s) | |
776 Wchar *s; | |
777 { | |
778 int i; | |
779 Wchar *p; | |
780 | |
781 p = findslash (s); | |
782 if (p) | |
783 { | |
784 long res; | |
785 | |
786 *p = (Wchar) '\0'; | |
787 res = internkind (s); | |
788 res |= internkind (p + 1); | |
789 return res; | |
790 } | |
791 else | |
792 { | |
793 for (i = 0; i < nkinds; i++) | |
794 { | |
795 if (!Wscmp (s, kinds[i].kind)) | |
796 { | |
797 return kinds[i].kindbit; | |
798 } | |
799 } | |
800 if (nkinds < (sizeof (long) * 8) && (kinds[nkinds].kind = (Wchar *) malloc ((Wslen (s) + 1) * sizeof (Wchar)))) | |
801 { | |
802 (void) Wscpy (kinds[nkinds].kind, s); | |
803 kinds[nkinds].kindbit = 1 << nkinds; | |
804 return kinds[nkinds++].kindbit; | |
805 } | |
806 return 0; | |
807 } | |
808 } | |
809 | |
810 /* 種別の一覧の出力 */ | |
811 | |
812 static void | |
813 listkinds () | |
814 { | |
815 int i; | |
816 | |
817 for (i = 0; i < nkinds; i++) | |
818 { | |
819 Fputws (kinds[i].kind, stdout); | |
820 putchar ('\n'); | |
821 } | |
822 } | |
823 | |
824 static int | |
25
466fe6732d8d
- fixed more NULL pointer related errata
Yoshiki Yazawa <yaz@honeyplanet.jp>
parents:
0
diff
changeset
|
825 kindcompar (const void *p1, const void *p2) |
0 | 826 { |
25
466fe6732d8d
- fixed more NULL pointer related errata
Yoshiki Yazawa <yaz@honeyplanet.jp>
parents:
0
diff
changeset
|
827 struct kindpack *k1, *k2; |
466fe6732d8d
- fixed more NULL pointer related errata
Yoshiki Yazawa <yaz@honeyplanet.jp>
parents:
0
diff
changeset
|
828 k1 = (struct kindpack *)p1; |
466fe6732d8d
- fixed more NULL pointer related errata
Yoshiki Yazawa <yaz@honeyplanet.jp>
parents:
0
diff
changeset
|
829 k2 = (struct kindpack *)p2; |
466fe6732d8d
- fixed more NULL pointer related errata
Yoshiki Yazawa <yaz@honeyplanet.jp>
parents:
0
diff
changeset
|
830 |
0 | 831 return Wscmp (k1->kind, k2->kind); |
832 } | |
833 | |
834 static void | |
835 sortkind () | |
836 { | |
837 qsort (kinds, nkinds, sizeof (struct kindpack), kindcompar); | |
838 } | |
839 | |
840 static struct dicpack *dic[DICBUFSIZE], **pdic; | |
841 static int ndicentries = 0; | |
842 | |
843 /* | |
844 | |
845 intern -- 辞書エントリの検索/登録 | |
846 | |
847 第6引数の stat としてヌルでないアドレスが指定された場合には、同じエントリ | |
848 が登録されていない場合には登録を行う。アドレスがヌルの場合には登録しない。 | |
849 | |
850 flags によっていろいろと指定をする。(以下を見てね)。 | |
851 | |
852 hinshi に 0 を渡してはいけない。kind は 0 を渡しても可だが、-m の時じゃない | |
853 マッチはしないので注意。 | |
854 | |
855 */ | |
856 | |
857 /* flags */ | |
858 #define IGNORE_HINSHI 1L | |
859 #define IGNORE_KIND 2L | |
860 | |
861 static struct dicpack * | |
862 intern (key, yomi, kouho, hinshi, hindo, kind, stat, flags) | |
863 int key, hindo, *stat; | |
864 Wchar *yomi, *kouho, *hinshi; | |
865 long kind, flags; | |
866 { | |
867 struct dicpack *p, **pp; | |
868 struct descpack *dp; | |
869 Wchar nl[1], *yomdesc = nl, *tandesc = nl; | |
870 Wchar *yom = (Wchar *) 0, *tan = (Wchar *) 0, *dhinshi, *dh; | |
871 | |
872 nl[0] = (Wchar) '\0'; | |
873 | |
874 if (description_table) | |
875 { | |
876 dhinshi = dh = hinshi; /* かんなの品詞を探す */ | |
877 while (*dh) | |
878 { | |
879 if (*dh++ == (Wchar) '/') | |
880 { | |
881 dhinshi = dh; | |
882 } | |
883 } | |
884 dp = searchdesc (dhinshi); | |
885 if (dp) | |
886 { | |
887 yomdesc = dp->yomdesc; | |
888 tandesc = dp->tandesc; | |
889 if (Wslen (yomdesc)) | |
890 { | |
891 Wchar *t; | |
892 t = (Wchar *) malloc ((Wslen (yomi) + Wslen (yomdesc) + 1) * sizeof (Wchar)); | |
893 if (t) | |
894 { | |
895 Wscpy (t, yomi); | |
896 yom = yomi = t; | |
897 Wscpy (yomi + Wslen (yomi), yomdesc); | |
898 } | |
899 } | |
900 if (Wslen (tandesc)) | |
901 { | |
902 Wchar *t; | |
903 t = (Wchar *) malloc ((Wslen (kouho) + Wslen (tandesc) + 1) * sizeof (Wchar)); | |
904 if (t) | |
905 { | |
906 Wscpy (t, kouho); | |
907 tan = kouho = t; | |
908 Wscpy (kouho + Wslen (kouho), tandesc); | |
909 } | |
910 } | |
911 } | |
912 else | |
913 { | |
914 char foo[64]; | |
915 | |
916 fprintf (stderr, "no description rule for "); | |
917 Wcstombs (foo, dhinshi, 64); | |
918 fprintf (stderr, "%s.\n", foo); | |
919 } | |
920 } | |
921 | |
922 key = ((unsigned) key & DICBUFINDEXMASK); | |
923 for (pp = dic + key; p = *pp; pp = &(p->next)) | |
924 { | |
925 if (!Wscmp (p->yomi, yomi) && !Wscmp (p->tango, kouho) && ((flags & IGNORE_HINSHI) || !Wscmp (p->hinshi->hinshi, hinshi)) && ((flags & IGNORE_KIND) || ((p->kind & kind) == kind))) | |
926 { | |
927 /* match */ | |
928 if (stat) | |
929 *stat = FOUND; | |
930 if (yom) | |
931 free (yom); | |
932 if (tan) | |
933 free (tan); | |
934 return p; | |
935 } | |
936 } | |
937 if (stat) | |
938 { | |
939 p = (struct dicpack *) malloc (sizeof (struct dicpack)); | |
940 if (p) | |
941 { | |
942 *pp = p; | |
943 (void) bzero (p, sizeof (struct dicpack)); | |
944 p->yomi = (Wchar *) malloc ((Wslen (yomi) + 1) * sizeof (Wchar)); | |
945 if (p->yomi) | |
946 { | |
947 (void) Wscpy (p->yomi, yomi); | |
948 p->tango = (Wchar *) malloc ((Wslen (kouho) + 1) * sizeof (Wchar)); | |
949 if (p->tango) | |
950 { | |
951 (void) Wscpy (p->tango, kouho); | |
952 p->hinshi = internhinshi (hinshi, 1); | |
953 if (p->hinshi) | |
954 { | |
955 p->hindo = hindo; | |
956 *stat = CREATE; | |
957 ndicentries++; | |
958 p->kind = kind; | |
959 p->extdata = (Wchar *) 0; | |
960 if (yom) | |
961 free (yom); | |
962 if (tan) | |
963 free (tan); | |
964 return p; | |
965 } | |
966 free (p->tango); | |
967 } | |
968 free (p->yomi); | |
969 } | |
970 free (p); | |
971 } | |
972 malloc_failed (); | |
973 } | |
974 if (yom) | |
975 free (yom); | |
976 if (tan) | |
977 free (tan); | |
978 return (struct dicpack *) 0; | |
979 } | |
980 | |
981 /* 登録されているエントリに対して fn を実行する */ | |
982 | |
983 static void | |
984 for_all_interned (fn) | |
985 void (*fn) (); | |
986 { | |
987 int i; | |
988 struct dicpack *p; | |
989 | |
990 for (i = 0; i < DICBUFSIZE; i++) | |
991 { | |
992 for (p = dic[i]; p; p = p->next) | |
993 { | |
994 (*fn) (p); | |
995 } | |
996 } | |
997 } | |
998 | |
999 static void | |
1000 storepd (file) | |
1001 FILE *file; | |
1002 { | |
1003 Wchar readbuf[READBUFSIZE], *p, *yomi, *hinshi, *kouho, *hindo, *kind; | |
1004 int nhindo, key, tkey, stat; | |
1005 long kindbit; | |
1006 struct dicpack *dicentry; | |
1007 | |
1008 while (p = Fgetws (readbuf, READBUFSIZE, file)) | |
1009 { | |
1010 key = 0; | |
1011 yomi = extstr (p, &p, &tkey); | |
1012 key += tkey; | |
1013 kouho = extstr (p, &p, &tkey); | |
1014 key += tkey; | |
1015 hinshi = extstr (p, &p, 0); | |
1016 hindo = extstr (p, &p, 0); | |
1017 nhindo = Watoi (hindo); | |
1018 | |
1019 kind = extstr (p, 0, 0); | |
1020 if (*kind) | |
1021 { | |
1022 kindbit = internkind (kind); | |
1023 } | |
1024 else | |
1025 { | |
1026 kindbit = KIHONBIT; | |
1027 } | |
1028 | |
1029 dicentry = intern (key, yomi, kouho, hinshi, nhindo, kindbit, &stat, IGNORE_KIND); | |
1030 if (dicentry) | |
1031 { | |
1032 dicentry->kind |= kindbit; | |
1033 } | |
1034 } | |
1035 } | |
1036 | |
1037 static void | |
1038 comparepd (file) | |
1039 FILE *file; | |
1040 { | |
1041 Wchar readbuf[READBUFSIZE], *p, *yomi, *hinshi, *kouho, *hindo, *kind; | |
1042 int nhindo, key, tkey, stat, *statp = &stat; | |
1043 struct dicpack *dicentry; | |
1044 long kindbit, flags = 0L; | |
1045 | |
1046 while (p = Fgetws (readbuf, READBUFSIZE, file)) | |
1047 { | |
1048 key = 0; | |
1049 yomi = extstr (p, &p, &tkey); | |
1050 key += tkey; | |
1051 kouho = extstr (p, &p, &tkey); | |
1052 key += tkey; | |
1053 hinshi = extstr (p, &p, 0); | |
1054 if (ignore_hinshi_to_compare) | |
1055 { | |
1056 flags |= IGNORE_HINSHI; | |
1057 } | |
1058 hindo = extstr (p, &p, 0); | |
1059 nhindo = Watoi (hindo); | |
1060 | |
1061 kind = extstr (p, 0, 0); | |
1062 if (*kind) | |
1063 { | |
1064 kindbit = internkind (kind); | |
1065 } | |
1066 else | |
1067 { | |
1068 kindbit = KIHONBIT; | |
1069 } | |
1070 if (merge_kind || merge_sj3) | |
1071 { | |
1072 flags |= IGNORE_KIND; | |
1073 } | |
1074 if (copy_frequency) | |
1075 { | |
1076 statp = (int *) 0; | |
1077 } | |
1078 | |
1079 dicentry = intern (key, yomi, kouho, hinshi, nhindo, kindbit, statp, flags); | |
1080 | |
1081 if (dicentry) | |
1082 { | |
1083 if (copy_frequency) | |
1084 { | |
1085 dicentry->hindo = nhindo; | |
1086 dicentry->flags &= ~COMMON; | |
1087 } | |
1088 else if (ignore_hinshi_to_compare && stat == FOUND) | |
1089 { | |
1090 /* この場合、同じキーのチェーンが返る */ | |
1091 struct dicpack *pd; | |
1092 | |
1093 for (pd = dicentry; pd; pd = pd->next) | |
1094 { | |
1095 if (!Wscmp (pd->yomi, yomi) && !Wscmp (pd->tango, kouho)) | |
1096 { | |
1097 pd->flags |= COMMON; | |
1098 if (!merge_sj3) | |
1099 { | |
1100 pd->kind |= kindbit; | |
1101 } | |
1102 | |
1103 if (merge_sj3) | |
1104 { | |
1105 int len = 0; | |
1106 Wchar *dat; | |
1107 | |
1108 if (pd->extdata) | |
1109 { | |
1110 len = Wslen (pd->extdata); | |
1111 } | |
1112 dat = (Wchar *) malloc ((Wslen (hinshi) + 1 + len) * sizeof (Wchar)); | |
1113 if (dat) | |
1114 { | |
1115 if (len) | |
1116 { | |
1117 (void) Wscpy (dat, pd->extdata); | |
1118 (void) free ((char *) pd->extdata); | |
1119 } | |
1120 (void) Wscpy (dat + len, hinshi); | |
1121 pd->extdata = dat; | |
1122 } | |
1123 } | |
1124 } | |
1125 } | |
1126 } | |
1127 else | |
1128 { | |
1129 dicentry->kind |= kindbit; | |
1130 if (stat == FOUND) | |
1131 { | |
1132 dicentry->flags |= COMMON; | |
1133 } | |
1134 else | |
1135 { /* CREATE */ | |
1136 dicentry->flags |= NEW; | |
1137 } | |
1138 } | |
1139 } | |
1140 } | |
1141 } | |
1142 | |
1143 static void | |
1144 canna_output (cf, p, h, n) | |
1145 FILE *cf; | |
1146 struct dicpack *p; | |
1147 Wchar *h; | |
1148 int n; | |
1149 { | |
1150 for (; n-- > 0; h += Wslen (h) + 1) | |
1151 { | |
1152 Fputws (p->yomi, cf); | |
1153 (void) putc (' ', cf); | |
1154 Fputws (h, cf); | |
1155 if (p->hindo) | |
1156 { | |
1157 (void) fprintf (cf, "*%d", p->hindo); | |
1158 } | |
1159 (void) putc (' ', cf); | |
1160 Fputws (p->tango, cf); | |
1161 (void) putc ('\n', cf); | |
1162 } | |
1163 } | |
1164 | |
1165 static void | |
1166 entry_out (cf, p, h, n, ex) | |
1167 FILE *cf; | |
1168 struct dicpack *p; | |
1169 Wchar *h; | |
1170 int n; | |
1171 Wchar *ex; | |
1172 { | |
1173 int i, f = 1; | |
1174 long b; | |
1175 | |
1176 for (; n-- > 0; h += Wslen (h) + 1) | |
1177 { | |
1178 Fputws (p->yomi, cf); | |
1179 (void) putc (' ', cf); | |
1180 Fputws (p->tango, cf); | |
1181 (void) putc (' ', cf); | |
1182 if (merge_sj3 && ex) | |
1183 { | |
1184 Fputws (ex, cf); | |
1185 (void) putc ('/', cf); | |
1186 } | |
1187 Fputws (h, cf); | |
1188 if (!sj3_type_output) | |
1189 { | |
1190 (void) fprintf (cf, " %d", p->hindo); | |
1191 } | |
1192 | |
1193 if (!wnn_type_output) | |
1194 { | |
1195 if (bunrui) | |
1196 { | |
1197 (void) printf (" %s", bunrui); | |
1198 } | |
1199 else | |
1200 { | |
1201 if (specific_kind) | |
1202 { | |
1203 b = (specific_kind & p->kind); | |
1204 } | |
1205 else | |
1206 { | |
1207 b = p->kind; | |
1208 } | |
1209 if (b != KIHONBIT) | |
1210 { /* 基本だけだったら何も書かない */ | |
1211 for (i = 0; i < nkinds; i++) | |
1212 { | |
1213 if (b & kinds[i].kindbit) | |
1214 { | |
1215 if (f) | |
1216 { | |
1217 (void) putc (' ', cf); | |
1218 f = 0; | |
1219 } | |
1220 else | |
1221 { | |
1222 (void) putc ('/', cf); | |
1223 } | |
1224 Fputws (kinds[i].kind, cf); | |
1225 } | |
1226 } | |
1227 } | |
1228 } | |
1229 } | |
1230 (void) putc ('\n', cf); | |
1231 } | |
1232 } | |
1233 | |
1234 /* p で表されるエントリをファイル cf に出力する */ | |
1235 | |
1236 static void | |
1237 printentry (cf, p) | |
1238 FILE *cf; | |
1239 struct dicpack *p; | |
1240 { | |
1241 if (specific_kind && !(p->kind & specific_kind)) | |
1242 { | |
1243 return; | |
1244 } | |
1245 | |
1246 if (extract_kana && !all_kana (p->tango)) | |
1247 { | |
1248 return; | |
1249 } | |
1250 | |
1251 if (selhinshi && !p->hinshi->hinshi[0]) | |
1252 { | |
1253 return; | |
1254 } | |
1255 | |
1256 if (canna_type_output) | |
1257 { | |
1258 canna_output (cf, p, p->hinshi->hinshi, p->hinshi->nhinshis); | |
1259 } | |
1260 else | |
1261 { | |
1262 entry_out (cf, p, p->hinshi->hinshi, p->hinshi->nhinshis, p->extdata); | |
1263 } | |
1264 } | |
1265 | |
1266 static void | |
1267 showdeleted (p) | |
1268 struct dicpack *p; | |
1269 { | |
1270 if (!(p->flags & COMMON)) | |
1271 { | |
1272 (void) printf ("- "); | |
1273 printentry (stdout, p); | |
1274 } | |
1275 } | |
1276 | |
1277 static void | |
1278 showentry (pd, n) | |
1279 struct dicpack **pd; | |
1280 int n; | |
1281 { | |
1282 FILE *cf = (FILE *) 0, *of = (FILE *) 0, *nf = (FILE *) 0; | |
1283 struct dicpack *p; | |
1284 int i; | |
1285 | |
1286 if (common_out) | |
1287 { | |
1288 if (common_out[0] != '-' || common_out[1]) | |
1289 { | |
1290 cf = fopen (common_out, "w"); | |
1291 if (!cf) | |
1292 { | |
1293 (void) fprintf (stderr, "%s: can not open file \"%s\".\n", program, common_out); | |
1294 exit (1); | |
1295 } | |
1296 } | |
1297 else | |
1298 { | |
1299 cf = stdout; | |
1300 } | |
1301 } | |
1302 if (old_out) | |
1303 { | |
1304 if (old_out[0] != '-' || old_out[1]) | |
1305 { | |
1306 of = fopen (old_out, "w"); | |
1307 if (!of) | |
1308 { | |
1309 (void) fprintf (stderr, "%s: can not open file \"%s\".\n", program, old_out); | |
1310 exit (1); | |
1311 } | |
1312 } | |
1313 else | |
1314 { | |
1315 of = stdout; | |
1316 } | |
1317 } | |
1318 if (new_out) | |
1319 { | |
1320 if (new_out[0] != '-' || new_out[1]) | |
1321 { | |
1322 nf = fopen (new_out, "w"); | |
1323 if (!nf) | |
1324 { | |
1325 (void) fprintf (stderr, "%s: can not open file \"%s\".\n", program, new_out); | |
1326 exit (1); | |
1327 } | |
1328 } | |
1329 else | |
1330 { | |
1331 nf = stdout; | |
1332 } | |
1333 } | |
1334 | |
1335 for (i = 0; i < n; i++) | |
1336 { | |
1337 p = pd[i]; | |
1338 if (compare) | |
1339 { | |
1340 if (p->flags & COMMON) | |
1341 { | |
1342 if (cf) | |
1343 { | |
1344 printentry (cf, p); | |
1345 } | |
1346 } | |
1347 else if (p->flags & NEW) | |
1348 { | |
1349 if (nf) | |
1350 { | |
1351 printentry (nf, p); | |
1352 } | |
1353 } | |
1354 else | |
1355 { | |
1356 if (of) | |
1357 { | |
1358 printentry (of, p); | |
1359 } | |
1360 } | |
1361 } | |
1362 else | |
1363 { /* just print the normalized dictionary */ | |
1364 printentry (stdout, p); | |
1365 } | |
1366 } | |
1367 } | |
1368 | |
1369 static int | |
25
466fe6732d8d
- fixed more NULL pointer related errata
Yoshiki Yazawa <yaz@honeyplanet.jp>
parents:
0
diff
changeset
|
1370 diccompar (const void *pp1, const void *pp2) |
0 | 1371 { |
25
466fe6732d8d
- fixed more NULL pointer related errata
Yoshiki Yazawa <yaz@honeyplanet.jp>
parents:
0
diff
changeset
|
1372 struct dicpack **p1, **p2; |
466fe6732d8d
- fixed more NULL pointer related errata
Yoshiki Yazawa <yaz@honeyplanet.jp>
parents:
0
diff
changeset
|
1373 p1 = (struct dicpack **)pp1; |
466fe6732d8d
- fixed more NULL pointer related errata
Yoshiki Yazawa <yaz@honeyplanet.jp>
parents:
0
diff
changeset
|
1374 p2 = (struct dicpack **)pp2; |
466fe6732d8d
- fixed more NULL pointer related errata
Yoshiki Yazawa <yaz@honeyplanet.jp>
parents:
0
diff
changeset
|
1375 |
0 | 1376 int n; |
1377 if (n = Wscmp ((*p1)->yomi, (*p2)->yomi)) | |
1378 { | |
1379 return n; | |
1380 } | |
1381 else if (n = Wscmp ((*p1)->tango, (*p2)->tango)) | |
1382 { | |
1383 return n; | |
1384 } | |
1385 else if (n = Wscmp ((*p1)->hinshi->hinshi, (*p2)->hinshi->hinshi)) | |
1386 { | |
1387 return n; | |
1388 } | |
1389 else | |
1390 { /* impossible */ | |
1391 return 0; | |
1392 } | |
1393 } | |
1394 | |
1395 static int | |
25
466fe6732d8d
- fixed more NULL pointer related errata
Yoshiki Yazawa <yaz@honeyplanet.jp>
parents:
0
diff
changeset
|
1396 dichindocompar (const void *pp1, const void *pp2) |
0 | 1397 { |
25
466fe6732d8d
- fixed more NULL pointer related errata
Yoshiki Yazawa <yaz@honeyplanet.jp>
parents:
0
diff
changeset
|
1398 struct dicpack **p1, **p2; |
466fe6732d8d
- fixed more NULL pointer related errata
Yoshiki Yazawa <yaz@honeyplanet.jp>
parents:
0
diff
changeset
|
1399 p1 = (struct dicpack **)pp1; |
466fe6732d8d
- fixed more NULL pointer related errata
Yoshiki Yazawa <yaz@honeyplanet.jp>
parents:
0
diff
changeset
|
1400 p2 = (struct dicpack **)pp2; |
466fe6732d8d
- fixed more NULL pointer related errata
Yoshiki Yazawa <yaz@honeyplanet.jp>
parents:
0
diff
changeset
|
1401 |
0 | 1402 int n; |
1403 if (n = Wscmp ((*p1)->yomi, (*p2)->yomi)) | |
1404 { | |
1405 return n; | |
1406 } | |
1407 else if (n = ((*p2)->hindo - (*p1)->hindo)) | |
1408 { | |
1409 return n; | |
1410 } | |
1411 else if (n = Wscmp ((*p1)->tango, (*p2)->tango)) | |
1412 { | |
1413 return n; | |
1414 } | |
1415 else if (n = Wscmp ((*p1)->hinshi->hinshi, (*p2)->hinshi->hinshi)) | |
1416 { | |
1417 return n; | |
1418 } | |
1419 else | |
1420 { /* impossible */ | |
1421 return 0; | |
1422 } | |
1423 } | |
1424 | |
1425 void | |
1426 shrinkargs (argv, n, count) | |
1427 char **argv; | |
1428 int n, count; | |
1429 { | |
1430 int i; | |
1431 | |
1432 for (i = 0; i + n < count; i++) | |
1433 { | |
1434 argv[i] = argv[i + n]; | |
1435 } | |
1436 } | |
1437 | |
1438 static void | |
1439 parseargs (argc, argv) | |
1440 int argc; | |
1441 char *argv[]; | |
1442 { | |
1443 int i; | |
1444 | |
1445 for (program = argv[0] + strlen (argv[0]); argv[0] < program; program--) | |
1446 { | |
1447 if (program[0] == '/') | |
1448 { | |
1449 program++; | |
1450 break; | |
1451 } | |
1452 } | |
1453 | |
1454 for (i = 1; i < argc;) | |
1455 { | |
1456 if (argv[i][0] == '-' && argv[i][2] == '\0') | |
1457 { | |
1458 switch (argv[i][1]) | |
1459 { | |
1460 case '1': | |
1461 case '2': | |
1462 case '3': | |
1463 selhinshi = argv[i][1] - '0'; | |
1464 shrinkargs (argv + i, 1, argc - i); | |
1465 argc -= 1; | |
1466 break; | |
1467 | |
1468 case 'b': | |
1469 bunrui = argv[i + 1]; | |
1470 shrinkargs (argv + i, 2, argc - i); | |
1471 argc -= 2; | |
1472 break; | |
1473 | |
1474 case 'c': | |
1475 common_out = argv[i + 1]; | |
1476 shrinkargs (argv + i, 2, argc - i); | |
1477 argc -= 2; | |
1478 break; | |
1479 | |
1480 case 'd': | |
1481 description_table = argv[i + 1]; | |
1482 shrinkargs (argv + i, 2, argc - i); | |
1483 argc -= 2; | |
1484 break; | |
1485 | |
1486 case 'f': | |
1487 copy_frequency = 1; | |
1488 shrinkargs (argv + i, 1, argc - i); | |
1489 argc -= 1; | |
1490 break; | |
1491 | |
1492 case 'h': | |
1493 ignore_hinshi_to_compare = 1; | |
1494 shrinkargs (argv + i, 1, argc - i); | |
1495 argc -= 1; | |
1496 break; | |
1497 | |
1498 case 'i': | |
1499 canna_type_output = 1; | |
1500 wnn_type_output = 0; | |
1501 shrinkargs (argv + i, 1, argc - i); | |
1502 argc -= 1; | |
1503 break; | |
1504 | |
1505 case 'j': | |
1506 extract_kana = 1; | |
1507 shrinkargs (argv + i, 1, argc - i); | |
1508 argc -= 1; | |
1509 break; | |
1510 | |
1511 case 'k': | |
1512 { | |
1513 Wchar buf[READBUFSIZE]; | |
1514 | |
1515 (void) Mbstowcs (buf, argv[i + 1], READBUFSIZE); | |
1516 specific_kind |= internkind (buf); | |
1517 } | |
1518 shrinkargs (argv + i, 2, argc - i); | |
1519 argc -= 2; | |
1520 break; | |
1521 | |
1522 case 'l': | |
1523 list_kinds = 1; | |
1524 shrinkargs (argv + i, 1, argc - i); | |
1525 argc -= 1; | |
1526 break; | |
1527 | |
1528 case 'm': | |
1529 merge_kind = 1; | |
1530 shrinkargs (argv + i, 1, argc - 1); | |
1531 argc -= 1; | |
1532 break; | |
1533 | |
1534 case 'n': | |
1535 new_out = argv[i + 1]; | |
1536 shrinkargs (argv + i, 2, argc - i); | |
1537 argc -= 2; | |
1538 break; | |
1539 | |
1540 case 'o': | |
1541 old_out = argv[i + 1]; | |
1542 shrinkargs (argv + i, 2, argc - i); | |
1543 argc -= 2; | |
1544 break; | |
1545 | |
1546 case 'p': | |
1547 sort_by_frequency = 1; | |
1548 shrinkargs (argv + i, 1, argc - i); | |
1549 argc -= 1; | |
1550 break; | |
1551 | |
1552 case 'r': | |
1553 hinshi_table = argv[i + 1]; | |
1554 shrinkargs (argv + i, 2, argc - i); | |
1555 argc -= 2; | |
1556 hinshi_direction = REVERSE; | |
1557 break; | |
1558 | |
1559 case 's': | |
1560 hinshi_table = argv[i + 1]; | |
1561 shrinkargs (argv + i, 2, argc - i); | |
1562 argc -= 2; | |
1563 break; | |
1564 | |
1565 case 'v': | |
1566 sj3_type_output = 1; | |
1567 wnn_type_output = 1; /* Wnn 形式と似ているので立てる */ | |
1568 shrinkargs (argv + i, 1, argc - i); | |
1569 argc -= 1; | |
1570 break; | |
1571 | |
1572 case 'w': | |
1573 canna_type_output = 0; | |
1574 sj3_type_output = 0; | |
1575 wnn_type_output = 1; | |
1576 shrinkargs (argv + i, 1, argc - i); | |
1577 argc -= 1; | |
1578 break; | |
1579 | |
1580 case 'x': | |
1581 merge_sj3 = 1; | |
1582 ignore_hinshi_to_compare = 1; | |
1583 shrinkargs (argv + i, 1, argc - i); | |
1584 argc -= 1; | |
1585 break; | |
1586 | |
1587 default: | |
1588 i++; | |
1589 break; | |
1590 } | |
1591 } | |
1592 else | |
1593 { | |
1594 i++; | |
1595 } | |
1596 } | |
1597 | |
1598 if (argc < 2) | |
1599 { | |
1600 (void) fprintf (stderr, "Usage: %s dic1 [dic2] [-c filecommon] ...\n", program); | |
1601 exit (1); | |
1602 } | |
1603 | |
1604 if (argv[1][0] != '-' || argv[1][1]) | |
1605 { | |
1606 in1 = fopen (argv[1], "r"); | |
1607 if (!in1) | |
1608 { | |
1609 (void) fprintf (stderr, "%s: can not open file \"%s\".\n", program, argv[1]); | |
1610 exit (1); | |
1611 } | |
1612 } | |
1613 if (argc == 3) | |
1614 { | |
1615 if (argv[2][0] != '-' || argv[2][1]) | |
1616 { | |
1617 in2 = fopen (argv[2], "r"); | |
1618 if (!in2) | |
1619 { | |
1620 (void) fprintf (stderr, "%s: can not open file \"%s\".\n", program, argv[2]); | |
1621 exit (1); | |
1622 } | |
1623 } | |
1624 } | |
1625 else | |
1626 { | |
1627 in2 = (FILE *) 0; | |
1628 } | |
1629 if (description_table) | |
1630 { | |
1631 store_description (); | |
1632 } | |
1633 } | |
1634 | |
1635 static Wchar kihonh[] = { | |
1636 (Wchar) 'k', (Wchar) 'i', (Wchar) 'h', (Wchar) 'o', (Wchar) 'n', (Wchar) 0, | |
1637 }; | |
1638 | |
1639 int | |
1640 main (argc, argv) | |
1641 int argc; | |
1642 char *argv[]; | |
1643 { | |
1644 #ifndef POD_WCHAR | |
1645 setlocale (LC_ALL, ""); | |
1646 #endif | |
1647 | |
1648 in1 = in2 = stdin; | |
1649 (void) internkind (kihonh); /* 基本辞書用。1L として登録 */ | |
1650 parseargs (argc, argv); | |
1651 storepd (in1); | |
1652 (void) fclose (in1); | |
1653 | |
1654 if (in2) | |
1655 { | |
1656 compare = 1; | |
1657 comparepd (in2); | |
1658 (void) fclose (in2); | |
1659 } | |
1660 | |
1661 if (list_kinds) | |
1662 { | |
1663 listkinds (); | |
1664 exit (0); | |
1665 } | |
1666 | |
1667 if (selhinshi) | |
1668 { | |
1669 select_hinshi (selhinshi); | |
1670 } | |
1671 else if (hinshi_table) | |
1672 { | |
1673 replace_hinshi (); | |
1674 } | |
1675 | |
1676 pdic = (struct dicpack **) malloc (ndicentries * sizeof (struct dicpack *)); | |
1677 if (pdic) | |
1678 { | |
1679 int i, j; | |
1680 struct dicpack *p; | |
1681 | |
1682 for (i = 0, j = 0; i < DICBUFSIZE; i++) | |
1683 { | |
1684 for (p = dic[i]; p; p = p->next) | |
1685 { | |
1686 pdic[j++] = p; | |
1687 } | |
1688 } | |
1689 if (sort_by_frequency) | |
1690 { | |
1691 qsort (pdic, ndicentries, sizeof (struct dicpack *), dichindocompar); | |
1692 } | |
1693 else | |
1694 { | |
1695 qsort (pdic, ndicentries, sizeof (struct dicpack *), diccompar); | |
1696 } | |
1697 sortkind (); | |
1698 showentry (pdic, ndicentries); | |
1699 } | |
1700 else | |
1701 { | |
1702 malloc_failed (); | |
1703 } | |
1704 exit (0); | |
1705 } |