« back to all changes in this revision
Viewing changes to src/kakasi.c
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: Bazaar Package Importer
- Author(s): Keita Maehara
- Date: 2001-12-25 23:18:48 UTC
- Revision ID: james.westby@ubuntu.com-20011225231848-oiu2kbbhoq80w774
Tags: upstream-2.3.4
Import upstream version 2.3.4
- files added:
- doc
- lib
- src
added
removed
src/kakasi.c
1
/*
2
* KAKASI (Kanji Kana Simple inversion program)
3
* $Id: kakasi.c,v 1.20 2001/09/02 11:43:21 takesako Exp $
4
* Copyright (C) 1992
5
* Hironobu Takahashi (takahasi@tiny.or.jp)
6
*
7
* This program is free software; you can redistribute it and/or modify
8
* it under the terms of the GNU General Public License as published by
9
* the Free Software Foundation; either versions 2, or (at your option)
10
* any later version.
11
*
12
* This program is distributed in the hope that it will be useful
13
* but WITHOUT ANY WARRANTY; without even the implied warranty of
14
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15
* GNU General Public License for more details.
16
*
17
* You should have received a copy of the GNU General Public License
18
* along with KAKASI, see the file COPYING. If not, write to the Free
19
* Software Foundation Inc., 59 Temple Place - Suite 330, Boston, MA
20
* 02111-1307, USA.
21
*/
22
/*
23
Modified by NOKUBI Takatsugu <knok@daionet.gr.jp>
24
1999/05/09
25
Fix kakasi_do returning no values.
26
1999/04/14
27
Add more valuables initialize routine.
28
1999/04/12
29
Add initialize routine for some valuables to funtion kakasi_getopt_argv.
30
1999/03/04
31
Rename PERLMOD macro to LIBRARY
32
1999/01/08
33
Add PERLMOD macro.
34
*/
35
36
#ifdef HAVE_CONFIG_H
37
# include <config.h>
38
#endif
39
40
#include <stdio.h>
41
#ifdef HAVE_MALLOC_H
42
# include <malloc.h>
43
#endif
44
#include <stdlib.h>
45
#include "kakasi.h"
46
#ifdef LIBRARY
47
# include "libkakasi.h"
48
#endif
49
50
#define KAKASIBUF 256
51
52
/* FIXME: this macro should be removed future. */
53
#ifdef LIBRARY
54
#define KAKASI_ATTR
55
#else /* !LIBRARY */
56
#define KAKASI_ATTR static
57
#endif /* !LIBRARY */
58
59
int romaji_type = HEPBURN;
60
int romaji_capitalize = 0;
61
int romaji_upcase = 0;
62
int heiki_mode = 0;
63
int bunkatu_mode = 0;
64
int furigana_mode = 0;
65
int cr_eat_mode = 0;
66
int flush_mode = 0;
67
#ifdef WAKATIGAKI
68
int wakatigaki_mode = 0;
69
int terminate_done = 0;
70
int wo_mode = 0;
71
#endif /* WAKATIGAKI */
72
73
int kanji_digest;
74
int separator_out;
75
char cr_eat_string[KAKASIBUF];
76
Character n[KAKASIBUF];
77
78
#ifdef LIBRARY
79
extern FILE *kanwadict;
80
static int (*proc[8])()={NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
81
/* ASCII, JISROMAN, KATAKANA, GRAPHIC, ZENKAKU-KIGOU, ZENKAKU-KATAKANA, ZENKAKU-HIRAGANA, KANJI, */
82
#endif
83
84
extern int input_term_type;
85
extern int output_term_type;
86
87
/* variables for memory management */
88
extern void ** ary_charalloc;
89
extern void ** ary_cellalloc;
90
extern size_t ary_size_charalloc;
91
extern size_t ary_cur_charalloc;
92
extern size_t ary_size_cellalloc;
93
extern size_t ary_cur_cellalloc;
94
extern int point_charalloc;
95
extern unsigned char *ptr_charalloc;
96
extern int point_cellalloc;
97
extern struct kanji_yomi *ptr_cellalloc;
98
99
/* forward decls */
100
#ifndef LIBRARY
101
static void digest_start_copy PARAMS((Character *c, Character *r));
102
static void put_separator PARAMS((void));
103
static void putchars PARAMS((Character *results));
104
static void digest_out PARAMS((Character *c, int ret));
105
static int digest PARAMS((Character *c, int clen, Character *r, int rlen, int type, int (*proc)(void)));
106
static void digest_shift PARAMS((Character *c, int s));
107
#else /* LIBRARY */
108
static void free_jisyo PARAMS((void));
109
#endif /* LIBRARY */
110
111
KAKASI_ATTR void
112
digest_start_copy(c, r)
113
Character *c;
114
Character *r;
115
{
116
for(;;) {
117
r->type = c->type;
118
r->c1 = c->c1;
119
r->c2 = c->c2;
120
if ((r->type == OTHER) && (r->c1 == 0)) return;
121
++r, ++c;
122
}
123
}
124
125
KAKASI_ATTR void
126
put_separator()
127
{
128
#ifdef WAKATIGAKI
129
if (bunkatu_mode) {
130
if(! terminate_done) {
131
if (separator_out == 1)
132
separator_out = 2;
133
}
134
}
135
#else
136
if (bunkatu_mode)
137
if (separator_out == 1)
138
separator_out = 2;
139
#endif /* WAKATIGAKI */
140
}
141
142
KAKASI_ATTR void
143
putchars(results)
144
Character *results;
145
{
146
while(results->c1 != '\0') {
147
putkanji(results);
148
++ results;
149
}
150
}
151
152
KAKASI_ATTR void
153
digest_out(c, ret)
154
Character *c;
155
int ret;
156
{
157
Character sep, *ptr;
158
int i;
159
160
if (kanji_digest) {
161
put_separator();
162
if (romaji_capitalize) {
163
if ((n[0].type == ASCII) || (n[0].type == JISROMAN))
164
if (('a' <= n[0].c1) && (n[0].c1 <= 'z'))
165
n[0].c1 = n[0].c1 - 0x20;
166
} else if (romaji_upcase) {
167
for (ptr = n; ptr->c1 != '\0'; ++ptr) {
168
if ((ptr->type == ASCII) || (ptr->type == JISROMAN))
169
if (('a' <= ptr->c1) && (ptr->c1 <= 'z'))
170
ptr->c1 = ptr->c1 - 0x20;
171
}
172
}
173
}
174
175
if ((kanji_digest) && (furigana_mode)) {
176
for (i = 0; i < ret; ++ i)
177
putkanji(c+i);
178
sep.type = OTHER;
179
sep.c1 = '[';
180
putkanji(&sep);
181
putchars(n);
182
sep.c1 = ']';
183
putkanji(&sep);
184
#ifdef WAKATIGAKI
185
} else if ((kanji_digest) && (wakatigaki_mode)) {
186
for (i = 0; i < ret; ++ i)
187
putkanji(c+i);
188
#endif /* WAKATIGAKI */
189
} else {
190
putchars(n);
191
}
192
if (flush_mode) fflush(stdout);
193
}
194
195
KAKASI_ATTR int
196
digest(c, clen, r, rlen, type, proc)
197
Character *c;
198
int clen;
199
Character *r;
200
int rlen;
201
int type;
202
int (*proc)();
203
{
204
int ret, i, j, k;
205
Character new;
206
char *p;
207
208
ret = (* proc)(c, n);
209
if (ret == 0) ret = 1;
210
211
if ((ret < 0) && (rlen < KAKASIBUF)) {
212
getkanji(&new);
213
if(new.type == type) {
214
r[rlen].type = c[clen].type = type;
215
r[rlen].c1 = c[clen].c1 = new.c1;
216
r[rlen].c2 = c[clen].c2 = new.c2;
217
r[rlen+1].type = c[clen+1].type = OTHER;
218
r[rlen+1].c1 = c[clen+1].c1 = '\0';
219
return digest(c, clen+1, r, rlen+1, type, proc);
220
} else if (cr_eat_mode) {
221
if ((rlen < KAKASIBUF -1) && /* keep in check a buffer overflow */
222
((new.type == ASCII) || (new.type == JISROMAN) || (new.type == OTHER))) {
223
for (p = cr_eat_string; *p != '\0'; ++ p) {
224
if ((unsigned)(*p) == new.c1) {
225
r[rlen].type = new.type;
226
r[rlen].c1 = new.c1;
227
r[rlen].c2 = new.c2;
228
r[rlen+1].type = OTHER;
229
r[rlen+1].c1 = '\0';
230
return digest(c, clen, r, rlen+1, type, proc);
231
}
232
}
233
}
234
}
235
ungetkanji(&new);
236
ret = -ret;
237
}
238
239
digest_out(c, ret);
240
241
k = ret;
242
j = 0;
243
for (i = 0;; ++ i) {
244
if ((r[i].type == type) && (k > 0)) {
245
-- k;
246
} else {
247
c[j].type = r[i].type;
248
c[j].c1 = r[i].c1;
249
c[j].c2 = r[i].c2;
250
if (c[j].c1 == '\0')
251
break;
252
++ j;
253
}
254
}
255
return rlen - ret;
256
}
257
258
KAKASI_ATTR void
259
digest_shift(c, s)
260
Character *c;
261
int s;
262
{
263
int i;
264
265
for (i = 0;; ++ i) { /* Yes, I know following lines can be written in
266
1 line, but I have doubts of compatibilities.. */
267
c[i].type = c[i+s].type;
268
c[i].c1 = c[i+s].c1;
269
c[i].c2 = c[i+s].c2;
270
if (c[i+s].c1 == '\0')
271
break;
272
}
273
}
274
275
#ifndef LIBRARY
276
int
277
main(argc, argv)
278
int argc;
279
char **argv;
280
#else
281
int
282
kakasi_getopt_argv(argc, argv)
283
int argc;
284
char **argv;
285
#endif
286
{
287
#ifdef LIBRARY
288
int retval = 0;
289
#endif
290
#ifndef LIBRARY
291
Character c[KAKASIBUF], r[KAKASIBUF];
292
int clen, ptype, pctype;
293
static int (*proc[8])()={NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
294
/* ASCII, JISROMAN, KATAKANA, GRAPHIC, ZENKAKU-KIGOU, ZENKAKU-KATAKANA, ZENKAKU-HIRAGANA, KANJI, */
295
#endif
296
297
#ifdef LIBRARY
298
int i;
299
/* Initialize some valuables. */
300
for (i = 0; i < 8; i ++) {
301
proc[i] = NULL;
302
}
303
romaji_type = HEPBURN;
304
heiki_mode = 0;
305
bunkatu_mode = 0;
306
furigana_mode = 0;
307
cr_eat_mode = 0;
308
romaji_capitalize = 0;
309
romaji_upcase = 0;
310
flush_mode = 0;
311
#ifdef WAKATIGAKI
312
wakatigaki_mode = 0;
313
terminate_done = 0;
314
wo_mode = 0;
315
#endif /* WAKATIGAKI*/
316
input_term_type = UNKNOWN;
317
output_term_type = UNKNOWN;
318
#endif
319
320
while(--argc > 0) {
321
++ argv;
322
if ((*argv)[0] != '-') break;
323
switch((*argv)[1]) {
324
case 'a':
325
switch((*argv)[2]) {
326
case 'j': proc[0] = a2j; break;
327
case 'E': proc[0] = a2E; break;
328
default: proc[0] = NULL;
329
}
330
break;
331
case 'j':
332
switch((*argv)[2]) {
333
case 'a': proc[1] = j2a; break;
334
case 'E': proc[1] = j2E; break;
335
default: proc[1] = NULL;
336
}
337
break;
338
case 'g':
339
switch((*argv)[2]) {
340
case 'a': proc[2] = g2a; break;
341
case 'j': proc[2] = g2j; break;
342
case 'E': proc[2] = g2E; break;
343
default: proc[2] = NULL;
344
}
345
break;
346
case 'k':
347
switch((*argv)[2]) {
348
case 'a': proc[3] = k2a; break;
349
case 'j': proc[3] = k2j; break;
350
case 'K': proc[3] = k2K; break;
351
case 'H': proc[3] = k2H; break;
352
default: proc[3] = NULL;
353
}
354
break;
355
case 'E':
356
switch((*argv)[2]) {
357
case 'a': proc[4] = E2a; break;
358
case 'j': proc[4] = E2j; break;
359
default: proc[4] = NULL;
360
}
361
break;
362
case 'K':
363
switch((*argv)[2]) {
364
case 'a': proc[5] = K2a; break;
365
case 'j': proc[5] = K2j; break;
366
case 'k': proc[5] = K2k; break;
367
case 'H': proc[5] = K2H; break;
368
default: proc[5] = NULL;
369
}
370
break;
371
case 'H':
372
switch((*argv)[2]) {
373
case 'a': proc[6] = H2a; break;
374
case 'j': proc[6] = H2j; break;
375
case 'k': proc[6] = H2k; break;
376
case 'K': proc[6] = H2K; break;
377
default: proc[6] = NULL;
378
}
379
break;
380
case 'J':
381
switch((*argv)[2]) {
382
case 'a': proc[7] = J2a; break;
383
case 'j': proc[7] = J2j; break;
384
case 'k': proc[7] = J2k; break;
385
case 'K': proc[7] = J2K; break;
386
case 'H': proc[7] = J2H; break;
387
default: proc[7] = NULL;
388
}
389
break;
390
case 'i':
391
if ((*argv)[2] != '\0')
392
set_input_term(term_type_str((*argv)+2));
393
else
394
if (argc > 1) {
395
-- argc;
396
set_input_term(term_type_str(*(++ argv)));
397
}
398
break;
399
case 'o':
400
if ((*argv)[2] != '\0')
401
set_output_term(term_type_str((*argv)+2));
402
else
403
if (argc > 1) {
404
-- argc;
405
set_output_term(term_type_str(*(++ argv)));
406
}
407
break;
408
case 'r':
409
if ((*argv)[2] == 'k')
410
romaji_type = KUNREI;
411
break;
412
case 'p':
413
heiki_mode = 1;
414
break;
415
case 's':
416
bunkatu_mode = 1;
417
break;
418
case 'f':
419
furigana_mode = 1;
420
break;
421
case 'c':
422
cr_eat_mode = 1;
423
sprintf(cr_eat_string, "\011\012\015 %s", (*argv)+2);
424
break;
425
case 'C':
426
romaji_capitalize = 1;
427
break;
428
case 'U':
429
romaji_upcase = 1;
430
break;
431
case 'u':
432
flush_mode = 1;
433
break;
434
#ifdef WAKATIGAKI
435
case 'w':
436
wakatigaki_mode = 1;
437
bunkatu_mode = 1;
438
cr_eat_mode = 1;
439
sprintf(cr_eat_string, "\011\012\015 %s", (*argv)+2);
440
proc[5] = K2K;
441
proc[6] = H2H;
442
proc[7] = J2H;
443
break;
444
#endif /* WAKATIGAKI */
445
case '?':
446
default:
447
#ifndef LIBRARY
448
fprintf(stderr, "KAKASI - Kanji Kana Simple Inverter Version %s\n", VERSION);
449
fprintf(stderr, "Copyright (C) 1992-1999 Hironobu Takahashi. All rights reserved.\n");
450
fprintf(stderr, "\n");
451
fprintf(stderr, "Usage: kakasi -a[jE] -j[aE] -g[ajE] -k[ajKH] -E[aj] -K[ajkH] -H[ajkK] -J[ajkKH]\n");
452
fprintf(stderr, " -i{oldjis,newjis,dec,euc,sjis} -o{oldjis,newjis,dec,euc,sjis}\n");
453
fprintf(stderr, " -r{hepburn,kunrei} -p -s -f -c\"chars\" [jisyo1, jisyo2,,,]\n");
454
fprintf(stderr, "\n");
455
fprintf(stderr, " Character Sets:\n");
456
fprintf(stderr, " a: ascii j: jisroman g: graphic k: kana (j,k defined in jisx0201)\n");
457
fprintf(stderr, " E: kigou K: katakana H: hiragana J: kanji(E,K,H,J defined in jisx0208)\n");
458
fprintf(stderr, "\n");
459
fprintf(stderr, " Options:\n");
460
fprintf(stderr, " -i: input coding system -o: output coding system\n");
461
fprintf(stderr, " -r: romaji conversion system\n");
462
fprintf(stderr, " -p: list all readings (with -J option)\n");
463
fprintf(stderr, " -s: insert separate characters (with -J option)\n");
464
fprintf(stderr, " -f: furigana mode (with -J option)\n");
465
fprintf(stderr, " -c: skip chars within jukugo (with -J option: default TAB CR LF BLANK)\n");
466
fprintf(stderr, " -C: romaji Capitalize (with -Ja or -Jj option)\n");
467
fprintf(stderr, " -U: romaji Upcase (with -Ja or -Jj option)\n");
468
fprintf(stderr, " -u: call fflush() after 1 character output\n");
469
#ifdef WAKATIGAKI
470
fprintf(stderr, " -w: wakatigaki mode\n");
471
#endif /* WAKATIGAKI */
472
fprintf(stderr, "\n");
473
fprintf(stderr, "Report bugs to <bug-kakasi@namazu.org>.\n");
474
exit(1);
475
#else /* LIBRARY */
476
retval = 1;
477
#endif
478
}
479
}
480
481
if ((input_term_type != UNKNOWN) && (output_term_type == UNKNOWN))
482
set_output_term(input_term_type);
483
484
#ifdef LIBRARY
485
free_jisyo();
486
#endif /* LIBRARY */
487
init_jisyo();
488
init_kanwa();
489
if (proc[7] != NULL) {
490
for (; argc > 0; -- argc)
491
add_jisyo(*(argv ++));
492
}
493
494
#ifdef LIBRARY
495
return retval;
496
}
497
498
char *
499
kakasi_do(str)
500
char *str;
501
{
502
Character c[KAKASIBUF], r[KAKASIBUF];
503
int clen, ptype, pctype;
504
505
setcharbuffer(str);
506
#endif
507
508
pctype = OTHER;
509
separator_out = 0;
510
for(;;) {
511
getkanji(c);
512
if ((c[0].type == OTHER) && (c[0].c1 == 0xff)) break;
513
c[1].type = OTHER;
514
c[1].c1 = '\0';
515
clen = 1;
516
while (clen > 0) {
517
kanji_digest = 0;
518
switch (c[0].type) {
519
case ASCII:
520
case JISROMAN:
521
case GRAPHIC:
522
case KATAKANA:
523
if ((c[0].type != OTHER) && (c[0].type != pctype)) {
524
put_separator();
525
pctype = c[0].type;
526
}
527
if ((*proc[(int)(c[0].type)]) == NULL) {
528
putkanji(c); digest_shift(c, 1); -- clen;
529
if (flush_mode) fflush(stdout);
530
} else {
531
digest_start_copy(c, r);
532
clen = digest(c, clen, r, clen, (int)(c[0].type), *proc[(int)(c[0].type)]);
533
}
534
#ifdef WAKATIGAKI
535
terminate_done = 0;
536
#endif /* WAKATIGAKI */
537
break;
538
case JIS83:
539
if (c[0].c1 >= 0xb0) {
540
ptype = 7;
541
kanji_digest = 1;
542
#ifdef WAKATIGAKI
543
} else if ((c[0].c1 == 0xa1) && /* charcter code(\241\270),charcter code(\241\271),charcter code(\241\272) */
544
(c[0].c2 >= 0xb8 && c[0].c2 <= 0xba)) {
545
ptype = 7;
546
kanji_digest = 1;
547
} else if ((c[0].c1 == 0xa5) && /* charcter code(\245\365),charcter code(\245\366) */
548
(c[0].c2 >= 0xf5 && c[0].c2 <= 0xf6)) {
549
ptype = 7;
550
kanji_digest = 1;
551
#endif /* WAKATIGAKI */
552
} else if (c[0].c1 == 0xa4) {
553
ptype = 6;
554
#ifdef WAKATIGAKI
555
} else if ((c[0].c1 == 0xa1) && /* charcter code(\241\263),charcter code(\241\264),charcter code(\241\265),charcter code(\241\266) */
556
(c[0].c2 >= 0xb3 && c[0].c2 <= 0xb6)) {
557
ptype = 6;
558
#endif /* WAKATIGAKI */
559
} else if (c[0].c1 == 0xa5) {
560
ptype = 5;
561
} else if ((c[0].c1 == 0xa1) && (c[0].c2 == 0xbc)) {
562
ptype = 5;
563
} else {
564
ptype = 4;
565
}
566
if (ptype != pctype) {
567
put_separator();
568
pctype = ptype;
569
#ifdef WAKATIGAKI
570
if( bunkatu_mode )
571
wo_mode = 0;
572
} else {
573
if( bunkatu_mode ) {
574
if( wo_mode != 2 )
575
wo_mode = 1;
576
}
577
#endif /* WAKATIGAKI */
578
}
579
if ((*proc[ptype]) == NULL) {
580
putkanji(c); digest_shift(c, 1); -- clen;
581
if (flush_mode) fflush(stdout);
582
} else {
583
digest_start_copy(c, r);
584
clen = digest(c, clen, r, clen, JIS83, *proc[ptype]);
585
}
586
#ifdef WAKATIGAKI
587
terminate_done = 0;
588
#endif /* WAKATIGAKI */
589
break;
590
default:
591
#ifdef WAKATIGAKI
592
terminate_done = 1;
593
#endif /* WAKATIGAKI */
594
putkanji(c); digest_shift(c, 1); -- clen;
595
#ifndef LIBRARY
596
if (flush_mode) fflush(stdout);
597
#endif
598
}
599
}
600
}
601
#ifndef LIBRARY
602
return 0;
603
#else /* LIBRARY */
604
{
605
char *ret = getpbstr();
606
if (ret == NULL)
607
return "";
608
return ret;
609
}
610
#endif
611
}
612
613
#ifdef LIBRARY
614
int
615
kakasi_close_kanwadict()
616
{
617
if (kanwadict != NULL) {
618
fclose(kanwadict);
619
kanwadict = NULL;
620
return 0;
621
}
622
return 1;
623
}
624
625
static void
626
free_jisyo()
627
{
628
size_t x;
629
630
if (ary_charalloc) {
631
for (x = 0; x <= ary_cur_charalloc; x ++) {
632
free(ary_charalloc[x]);
633
}
634
}
635
636
if (ary_cellalloc) {
637
for (x = 0; x <= ary_cur_cellalloc; x ++) {
638
free(ary_cellalloc[x]);
639
}
640
}
641
642
free(ary_charalloc);
643
free(ary_cellalloc);
644
645
ary_charalloc = NULL;
646
ary_cellalloc = NULL;
647
ary_size_charalloc = -1;
648
ary_cur_charalloc = -1;
649
ary_size_cellalloc = -1;
650
ary_cur_cellalloc = -1;
651
point_charalloc = 0;
652
ptr_charalloc = NULL;
653
point_cellalloc = 0;
654
ptr_cellalloc = NULL;
655
}
656
657
int
658
kakasi_free(char *p)
659
{
660
if (p) {
661
free(p);
662
return 1;
663
}
664
return 0;
665
}
666
#endif /* LIBRARY */
Loggerhead is a web-based interface for Breezy
Version: 2.0.1