Mercurial > kinput2.yaz

comparison lib/Xsj3clib/mode.c @ 0:92745d501b9a

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
initial import from kinput2-v3.1
author Yoshiki Yazawa <yaz@honeyplanet.jp>
date Mon, 08 Mar 2010 04:44:30 +0900
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:92745d501b9a
1 #ifndef lint
2 static char *rcsid = "$Id: mode.c,v 2.6 1993/01/06 10:58:18 nao Exp $";
3 #endif
4 /*
5 * Copyright 1991 Sony Corporation
6 *
7 * Permission to use, copy, modify, distribute, and sell this software and its
8 * documentation for any purpose is hereby granted without fee, provided that
9 * the above copyright notice appear in all copies and that both that
10 * copyright notice and this permission notice appear in supporting
11 * documentation, and that the name of Sony not be used in advertising or
12 * publicity pertaining to distribution of the software without specific,
13 * written prior permission. Sony makes no representations about the
14 * suitability of this software for any purpose. It is provided "as is"
15 * without express or implied warranty.
16 *
17 * SONY DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL SONY
19 * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
20 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
21 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
22 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
23 */
24 /*
25 * Author: Naoshi Suzuki, SONY Corporation. (nao@sm.sony.co.jp)
26 */
27
28 #include <ctype.h>
29 #include "common.h"
30 #include "sj3ctype.h"
31 #include "util.h"
32
33 extern Xsj3cCVServerIF serverIF[SERVER_NUM];
34
35 Xsj3cEvent _Xsj3cModeChange();
36 Xsj3cEvent _Xsj3cModeClear();
37 Xsj3cEvent Xsj3cModeConv();
38
39 void _Xsj3cHiraToZKata();
40 void _Xsj3cHankakuToHira();
41 void _Xsj3cHankakuToZKata();
42 void _Xsj3cHKataToHira();
43 void _Xsj3cHKataToZKata();
44 void _Xsj3cZKanaToHKata();
45 void _Xsj3cZKataToHira();
46 void _Xsj3cHAlphaToZAlpha();
47 void _Xsj3cHAlphaToZKana();
48 void _Xsj3cHAlphaToHKata();
49 void _Xsj3cZAlphaToHAlpha();
50
51 static void _Xsj3cLowerToUpper();
52 static void _Xsj3cUpperToLower();
53 static void _Xsj3cRKConvs();
54 static void _Xsj3cKRConvs();
55
56 /*
57 * _Xsj3cModeChange()
58 *
59 * Change current character mode to apointed mode(secound argument)
60 */
61 Xsj3cEvent
62 _Xsj3cModeChange(buf, mode, conv)
63 Xsj3cBuf buf;
64 Xsj3csMode mode;
65 Xsj3cFlag conv;
66 {
67 Xsj3cEvent ret;
68 unsigned char *mbs;
69
70 if (buf->convmode != SelectModeMask) {
71 if (conv) {
72 Xsj3cSeg seg = buf->input[buf->curseg];
73
74 if ((mbs = (unsigned char *)
75 malloc(seg->size * 2 * sizeof(wchar))) == NULL)
76 Xsj3cError("Cannot allocate for mode conversion buffer");
77 _Xsj3cwPStomPS(buf, mbs, seg->yomi);
78 if ((ret = Xsj3cModeConv(buf, mbs, mode, seg->size))
79 & KEY_TEXT_CHANGE) {
80 seg->num = _Xsj3cmPStowPSn(buf, seg->yomi, mbs, seg->size);
81 if (seg->num > seg->size - YBUFSIZ) {
82 Xsj3cResizeSegment(seg, seg->size * 2);
83 seg->num = _Xsj3cmPStowPS(buf, seg->yomi, mbs);
84 }
85 seg->cur = seg->num;
86 _Xsj3cStoreYomi(buf, seg, 0);
87 seg->change = OFF;
88 seg->cursegmode = mode;
89 }
90 free(mbs);
91 } else {
92 if (buf->inputmode != mode) {
93 buf->dispmode = buf->inputmode = mode;
94 return (_Xsj3cModeClear(buf));
95 } else {
96 #ifdef THROUGH_CONT
97 return (KEY_NULL);
98 #else /* THROUGH_CONT */
99 if (buf->cntrlsame)
100 return (KEY_NULL);
101 else
102 return (KEY_TEXT_CHANGE); /* dummy */
103 #endif /* THROUGH_CONT */
104 }
105 }
106 return ret;
107 } else {
108 return (KEY_BELL);
109 }
110 }
111
112 /*
113 * _Xsj3cModeClear()
114 * Clear romaji/kana buffer after changing mode.
115 */
116 Xsj3cEvent
117 _Xsj3cModeClear(buf)
118 Xsj3cBuf buf;
119 {
120 register Xsj3cSeg seg = buf->input[buf->curseg];
121
122 if (!seg)
123 return (KEY_MODE_CHANGE);
124 *seg->str = '\0';
125 seg->sp = seg->str;
126 seg->n_roma = 0;
127 seg->n_kana = -1;
128 *seg->oldstr = '\0';
129 seg->oldlen = 0;
130 seg->value = 0;
131 seg->change = OFF;
132 seg->cursegmode = MODE_HIRA;
133 if (buf->flushaconv)
134 return (KEY_MODE_CHANGE|KEY_TEXT_CLEAR);
135 else
136 return (KEY_MODE_CHANGE);
137 }
138
139 /*
140 * Xsj3cModeConv()
141 * Convert current segment to appointed character mode.
142 */
143 Xsj3cEvent
144 Xsj3cModeConv(buf, string, postmode, size)
145 Xsj3cBuf buf;
146 unsigned char *string;
147 Xsj3csMode postmode;
148 int size;
149 {
150 Xsj3cEvent ret = KEY_NULL;
151 unsigned char *tmp1, *tmp2;
152
153 if ((tmp1 = (unsigned char *)malloc(size * 2 * sizeof(wchar))) == NULL)
154 Xsj3cError("Cannot allocate for mode conversion buffer");
155 if ((tmp2 = (unsigned char *)malloc(size * 2 * sizeof(wchar))) == NULL)
156 Xsj3cError("Cannot allocate for mode conversion buffer");
157
158 switch (postmode) {
159 case MODE_HIRA:
160 _Xsj3cZKanaToHKata(buf, tmp2, string);
161 _Xsj3cHKataToHira(buf, tmp1, tmp2);
162 _Xsj3cKRConvs(buf, tmp2, tmp1);
163 _Xsj3cRKConvs(buf, tmp1, tmp2);
164 if (buf->alphaconv)
165 _Xsj3cHankakuToHira(buf, string, tmp1);
166 else
167 _Xsj3cZKataToHira(buf, string, tmp1);
168 ret = KEY_TEXT_CHANGE;
169 break;
170
171 case MODE_ZKATA:
172 _Xsj3cZKanaToHKata(buf, tmp2, string);
173 _Xsj3cHKataToHira(buf, tmp1, tmp2);
174 _Xsj3cKRConvs(buf, tmp2, tmp1);
175 _Xsj3cRKConvs(buf, tmp1, tmp2);
176 if (buf->alphaconv) {
177 _Xsj3cHiraToZKata(buf, tmp2, tmp1);
178 _Xsj3cHAlphaToZAlpha(buf, string, tmp2);
179 } else
180 _Xsj3cHiraToZKata(buf, string, tmp1);
181 ret = KEY_TEXT_CHANGE;
182 break;
183
184 case MODE_HKATA:
185 _Xsj3cHKataToHira(buf, tmp1, string);
186 _Xsj3cKRConvs(buf, tmp2, tmp1);
187 _Xsj3cRKConvs(buf, tmp1, tmp2);
188 _Xsj3cZKanaToHKata(buf, string, tmp1);
189 ret = KEY_TEXT_CHANGE;
190 break;
191
192 case MODE_HALPHA:
193 _Xsj3cZAlphaToHAlpha(buf, tmp2, string);
194 _Xsj3cRKConvs(buf, tmp1, tmp2);
195 _Xsj3cZKanaToHKata(buf, tmp2, tmp1);
196 _Xsj3cHKataToHira(buf, tmp1, tmp2);
197 _Xsj3cKRConvs(buf, string, tmp1);
198 ret = KEY_TEXT_CHANGE;
199 break;
200
201 case MODE_ZALPHA:
202 _Xsj3cZAlphaToHAlpha(buf, tmp2, string);
203 _Xsj3cRKConvs(buf, tmp1, tmp2);
204 _Xsj3cZKanaToHKata(buf, tmp2, tmp1);
205 _Xsj3cHKataToHira(buf, tmp1, tmp2);
206 _Xsj3cKRConvs(buf, tmp2, tmp1);
207 _Xsj3cHAlphaToZAlpha(buf, string, tmp2);
208 ret = KEY_TEXT_CHANGE;
209 break;
210
211 case MODE_HANKAKU:
212 _Xsj3cZKanaToHKata(buf, tmp1, string);
213 strcpy(string, tmp1);
214 ret = KEY_TEXT_CHANGE;
215 break;
216
217 case MODE_ZENKAKU:
218 _Xsj3cHankakuToZKata(buf, tmp1, string);
219 strcpy(string, tmp1);
220 ret = KEY_TEXT_CHANGE;
221 break;
222
223 case MODE_UPPER:
224 _Xsj3cLowerToUpper(buf, string);
225 ret = KEY_TEXT_CHANGE;
226 break;
227
228 case MODE_LOWER:
229 _Xsj3cUpperToLower(buf, string);
230 ret = KEY_TEXT_CHANGE;
231 break;
232
233 default:
234 ret = KEY_BELL;
235 break;
236 }
237 free(tmp1);
238 free(tmp2);
239 return (ret);
240 }
241
242 /*
243 * _Xsj3cRKConvs()
244 * Convert romaji to kana in 3rd argument and set to 2nd argument.
245 */
246 static void
247 _Xsj3cRKConvs(buf, yomi, alpha)
248 Xsj3cBuf buf;
249 unsigned char *yomi;
250 unsigned char *alpha;
251 {
252 unsigned char *p;
253 register unsigned char *q, *yp, *t;
254 register int i = 0, rlen = 0, tflg = 0, value;
255 unsigned char rbuf[RBUFSIZ];
256 unsigned char ybuf[YBUFSIZ];
257
258 yp = yomi;
259 p = rbuf;
260 rlen = 0;
261
262 while (*alpha != '\0') {
263 if (iskan1(*alpha, serverIF[buf->server].lang)
264 && iskan2(*(alpha + 1), serverIF[buf->server].lang)) {
265 *yp++ = *alpha++;
266 *yp++ = *alpha++;
267 i++;
268 continue;
269 } else if (!isascii(*alpha)) {
270 *yp++ = *alpha++;
271 i++;
272 continue;
273 }
274 if (i) {
275 rlen = 0;
276 p = rbuf;
277 i = 0;
278 }
279
280 *p = *alpha++;
281 *(p + 1) = '\0';
282 if (*alpha == '\0') {
283 t = buf->rkdouble;
284 while (*t != '\0') {
285 if (p > rbuf && *(p - 1) == *t) {
286 break;
287 } else if (*t == *p) {
288 *(p + 1) = *p;
289 *(p + 2) = '\0';
290 tflg++;
291 break;
292 }
293 t++;
294 }
295 }
296 if ((value = _Xsj3cRomaConv(buf->rktable, rbuf, ybuf)) > 0) {
297 q = ybuf;
298 yp -= rlen;
299 while (*q != '\0') {
300 *yp++ = *q++;
301 }
302 p = rbuf;
303 rlen = 0;
304 while (*p != '\0' && !tflg) {
305 *yp++ = *p++;
306 rlen++;
307 }
308 } else if (value < 0) {
309 if ((value = _Xsj3cRomaConv(buf->rktable, p, ybuf)) > 0) {
310 q = ybuf;
311 while (*q != '\0') {
312 *yp++ = *q++;
313 }
314 rlen = 0;
315 while (*p != '\0' && !tflg) {
316 *yp++ = *p++;
317 rlen++;
318 }
319 } else if (value < 0) {
320 *yp++ = *p;
321 rlen = 0;
322 p = rbuf;
323 } else {
324 *yp++ = *p;
325 q = rbuf;
326 *q++ = *p++;
327 *q = '\0';
328 rlen = 1;
329 }
330 } else {
331 *yp++ = *p++;
332 if (rlen++ > 3) { /* non-convert limit = 4: you can change this */
333 rlen = 0;
334 p = rbuf;
335 }
336 }
337 }
338 *yp = '\0';
339 }
340
341 static void
342 _Xsj3cKRConvs(buf, roma, kana)
343 Xsj3cBuf buf;
344 register unsigned char *roma;
345 register unsigned char *kana;
346 {
347 register unsigned char c, *p, *q, *r, *sp, *t, *d;
348 register wchar s;
349 register Xsj3cRKTable *rktp;
350 register Xsj3cHKTable *hktp;
351 register Xsj3cZHTable *zhtp;
352 register int ylen, plen, rlen, i, cont = 0;
353 register int zenflg = 0, plosflg = 0;
354 unsigned char tyomi[KANABUFSIZ];
355 unsigned char tmp[RBUFSIZ];
356
357 p = tyomi;
358 while ((c = *kana++) != '\0') {
359 if (iskan1(c, serverIF[buf->server].lang)
360 && iskan2(*kana, serverIF[buf->server].lang)) {
361 s = (c << 8) + *kana;
362 if (iskata(s, serverIF[buf->server].lang)) {
363 for (hktp = buf->hktable; hktp != NULL; hktp = hktp->next) {
364 if (c == *hktp->zkata)
365 if (*kana == *(hktp->zkata + 1))
366 break;
367 }
368 if (hktp != NULL) {
369 *p++ = *hktp->hira;
370 *p++ = *(hktp->hira + 1);
371 } else {
372 *p++ = c;
373 *p++ = *kana;
374 Xsj3cWarning("wrong sjhk table");
375 }
376
377 } else if (!ishira(s, serverIF[buf->server].lang)) {
378 for (zhtp = buf->zhtable; zhtp != NULL; zhtp = zhtp->next) {
379 if (c == *zhtp->zkana)
380 if (*kana == *(zhtp->zkana + 1))
381 break;
382 }
383 if (zhtp != NULL) {
384 *p++ = *zhtp->halpha;
385 } else {
386 for (zhtp = buf->zhtable; zhtp != NULL; zhtp = zhtp->next) {
387 if (c == *zhtp->zalpha) {
388 if (*kana == *(zhtp->zalpha + 1))
389 break;
390 }
391 }
392 if (zhtp != NULL) {
393 *p++ = *zhtp->halpha;
394 } else {
395 Xsj3cWarning("can't convert to halpha %#x",s);
396 *p++ = c;
397 *p++ = *kana;
398 }
399 }
400 } else {
401 *p++ = c;
402 *p++ = *kana;
403 }
404 kana++;
405 } else {
406 *p++ = c;
407 }
408 }
409 *p = '\0';
410 p = tyomi;
411 plen = strlen(tyomi);
412
413 while ((c = *p) != '\0') {
414 if (iskan1(c, serverIF[buf->server].lang)
415 && iskan2(*(p + 1), serverIF[buf->server].lang)) {
416 /* Multi-byte character */
417 q = tmp;
418 *q = '\0';
419 ylen = 0;
420 for (rktp = buf->rktable; rktp->next != NULL; rktp = rktp->next) {
421 if (ylen < rktp->ylen) {
422 if (plen >= rktp->ylen
423 && !strncmp(rktp->yomi, p, rktp->ylen)) {
424 ylen = rktp->ylen;
425 plosflg = 0;
426 if (*(sp = rktp->str) != '\0') {
427 /* Leaving any character case */
428 if (t = buf->plosive) {
429 while (*t != '\0') {
430 if (*t++ == *sp) {
431 plosflg = 1;
432 break;
433 }
434 }
435 if (plosflg) {
436 if (*(p + 2) == '\0') {
437 /* Last of the segment: */
438 /* continue to search */
439 plosflg = 0;
440 ylen = 0;
441 continue;
442 } else if (iskan1(*(p + 2),
443 serverIF[buf->server].lang)
444 && iskan2(*(p + 3),
445 serverIF[buf->server].lang)) {
446 /* Next character is zvowel: */
447 /* continue to search */
448 if (iszvowel((*(p + 2) << 8) | *(p + 3),
449 serverIF[buf->server].lang)){
450 plosflg = 0;
451 ylen = 0;
452 continue;
453 }
454 } else if (isvowel(*(p + 2))) {
455 /* Next character is vowel: */
456 /* continue to search */
457 plosflg = 0;
458 ylen = 0;
459 continue;
460 }
461 }
462 }
463 strcpy(tmp, rktp->roma);
464 /* Reduce leaved character */
465 i = 1;
466 while (*(++sp) != '\0')
467 i++;
468 r = (q + rktp->rlen);
469 while (*(--sp) == *(--r) && (--i));
470 *r = '\0';
471 } else if (d = buf->rkdouble) {
472 /* Double defined by a same character case */
473 strcpy(tmp, rktp->roma);
474 while (*d != '\0') {
475 if (*d++ == *q) {
476 if (*q == *(q + 1)) {
477 /* Last of the segment */
478 if (*(p + 2) == '\0')
479 *(q + 1) = '\0';
480 } else if (*(q + 1) == '\0') {
481 /* Single case: continue to search */
482 ylen = 0;
483 }
484 break;
485 }
486 }
487 } else {
488 strcpy(tmp, rktp->roma);
489 }
490 }
491 }
492 }
493 if (ylen > 0) {
494 /* Succeeded in converting. */
495 if (!zenflg && !plosflg && !isvowel(*q)
496 && p > tyomi && (t = buf->plosive)) {
497 /* Same as plosive table first character */
498 if (*t == *(p - 1))
499 cont++;
500 }
501 if (plosflg) {
502 cont++;
503 } else if (cont && !isvowel(*q)) {
504 /* Correct consonant character of previous plosive */
505 sp = roma;
506 while (cont--)
507 *(--sp) = *q;
508 cont = 0;
509 } else if (cont) {
510 cont = 0;
511 }
512 /* Copy characters to output string */
513 plen -= ylen;
514 p += ylen;
515 while (*q != '\0')
516 *roma++ = *q++;
517 } else {
518 /* Failed to convert. */
519 cont = 0;
520 /* Normal japanese character(except gaiji) is 2byte. */
521 *roma++ = *p++;
522 *roma++ = *p++;
523 plen -= 2;
524 }
525 zenflg++;
526 } else {
527 /* Non multi-byte character */
528 sp = p;
529 while (*sp != '\0' && !(iskan1(*sp, serverIF[buf->server].lang)
530 && iskan2(*(sp + 1), serverIF[buf->server].lang))) {
531 sp++;
532 }
533 ylen = sp - p;
534 i = 0;
535 for (rktp = buf->rktable; rktp->next != NULL; rktp = rktp->next) {
536 if (rktp->rlen > i) {
537 r = p;
538 t = rktp->roma;
539 while (r < sp && *r++ == *t++)
540 ;
541 if ((rlen = r - p) > i)
542 i = rlen;
543 }
544 }
545 if (i > 0) {
546 if (!zenflg && !plosflg && !isvowel(*p) && p > tyomi
547 && (t = buf->plosive)) {
548 /* Same as plosive table first character */
549 if (*t == *(p - 1))
550 cont++;
551 }
552 if (cont && !isvowel(*p)) {
553 /* Correct consonant character of previous plosive */
554 sp = roma;
555 while (cont--)
556 *(--sp) = *p;
557 cont = 0;
558 } else if (cont) {
559 cont = 0;
560 }
561 }
562 /* Copy characters to output string */
563 plen -= ylen;
564 while (ylen--)
565 *roma++ = *p++;
566 zenflg = 0;
567 plosflg = 0;
568 }
569 }
570 *roma = '\0';
571
572 if (!zenflg && (r = buf->plosive)) {
573 p--;
574 while (*r != '\0') {
575 if (*r == *p) {
576 t = buf->plosive;
577 while (*t != '\0') {
578 if (p > tyomi && *t == *p && *t == *(p - 1)) {
579 cont++;
580 break;
581 }
582 t++;
583 }
584 break;
585 }
586 r++;
587 }
588 if (*r != '\0') {
589 /* Correct consonant character of previous plosive */
590 sp = (--roma);
591 while (cont--)
592 *(--sp) = *p;
593 }
594 } else if (zenflg && cont && plosflg) {
595 q = tmp;
596 if (*q != '\0') {
597 /* Correct consonant character of previous plosive */
598 sp = (--roma);
599 while (cont--) {
600 if (!isvowel(*(--sp)))
601 *sp = *q;
602 }
603 }
604 }
605 }
606
607 void
608 _Xsj3cHiraToZKata(buf, dest, src)
609 Xsj3cBuf buf;
610 register unsigned char *dest, *src;
611 {
612 register wchar s;
613 register unsigned char c;
614 register Xsj3cHKTable *hktp;
615 register Xsj3cZHTable *zhtp;
616
617 while ((c = *src++) != '\0') {
618 if (iskan1(c, serverIF[buf->server].lang)
619 && iskan2(*src, serverIF[buf->server].lang)) {
620 s = (c << 8) + *src;
621 if (ishira(s, serverIF[buf->server].lang)) {
622 for (hktp = buf->hktable; hktp != NULL; hktp = hktp->next) {
623 if (c == *hktp->hira)
624 if (*src == *(hktp->hira + 1))
625 break;
626 }
627 if (hktp != NULL) {
628 *dest++ = *hktp->zkata;
629 *dest++ = *(hktp->zkata + 1);
630 } else {
631 *dest++ = c;
632 *dest++ = *src;
633 Xsj3cWarning("wrong sjhk table");
634 }
635 } else {
636 *dest++ = c;
637 *dest++ = *src;
638 }
639 src++;
640 } else if (isdakuten(c)) {
641 for (zhtp = buf->zhtable; zhtp != NULL; zhtp = zhtp->next) {
642 if (c == *zhtp->hkata)
643 break;
644 }
645 if (zhtp != NULL) {
646 *dest++ = *zhtp->zkana;
647 *dest++ = *(zhtp->zkana + 1);
648 } else {
649 *dest++ = c;
650 }
651 } else {
652 *dest++ = c;
653 }
654 }
655 *dest = '\0';
656 }
657
658 void
659 _Xsj3cHankakuToHira(buf, dest, src)
660 Xsj3cBuf buf;
661 register unsigned char *dest, *src;
662 {
663 register unsigned char c;
664 register Xsj3cHKTable *hktp;
665 register Xsj3cZHTable *zhtp;
666 register int len;
667 unsigned char tmp[RBUFSIZ];
668
669 while ((c = *src++) != '\0') {
670 if (iskan1(c, serverIF[buf->server].lang)
671 && iskan2(*src, serverIF[buf->server].lang)) {
672 *dest++ = c;
673 *dest++ = *src++;
674 continue;
675 }
676 if (iskana(c)) {
677 len = 0;
678 for (hktp = buf->hktable; hktp != NULL; hktp = hktp->next) {
679 if (len < hktp->hlen && c == *hktp->hkata) {
680 if (hktp->hlen > 1) {
681 if (iskana(*src) && *src == *(hktp->hkata + 1)) {
682 src++;
683 len = hktp->hlen;
684 strcpy(tmp, hktp->hira);
685 }
686 } else {
687 len = 1;
688 strcpy(tmp, hktp->hira);
689 }
690 }
691 }
692 if (len) {
693 strcpy(dest, tmp);
694 dest += strlen(tmp);
695 } else {
696 for (zhtp = buf->zhtable; zhtp != NULL; zhtp = zhtp->next) {
697 if (c == *zhtp->hkata)
698 break;
699 }
700 if (zhtp != NULL) {
701 *dest++ = *zhtp->zkana;
702 *dest++ = *(zhtp->zkana + 1);
703 } else {
704 *dest++ = c;
705 }
706 }
707 } else {
708 for (zhtp = buf->zhtable; zhtp != NULL; zhtp = zhtp->next) {
709 if (c == *zhtp->hkata)
710 break;
711 }
712 if (zhtp != NULL) {
713 *dest++ = *zhtp->zkana;
714 *dest++ = *(zhtp->zkana + 1);
715 } else {
716 *dest++ = c;
717 }
718 }
719 }
720 *dest = '\0';
721 }
722
723 void
724 _Xsj3cHankakuToZKata(buf, dest, src)
725 Xsj3cBuf buf;
726 register unsigned char *dest, *src;
727 {
728 register unsigned char c;
729 register Xsj3cHKTable *hktp;
730 register Xsj3cZHTable *zhtp;
731 register int len;
732 unsigned char tmp[RBUFSIZ];
733
734 while ((c = *src++) != '\0') {
735 if (iskan1(c, serverIF[buf->server].lang)
736 && iskan2(*src, serverIF[buf->server].lang)) {
737 *dest++ = c;
738 *dest++ = *src++;
739 continue;
740 }
741 if (iskana(c)) {
742 len = 0;
743 for (hktp = buf->hktable; hktp != NULL; hktp = hktp->next) {
744 if (len < hktp->hlen && c == *hktp->hkata) {
745 if (hktp->hlen > 1) {
746 if (iskana(*src) && *src == *(hktp->hkata + 1)) {
747 src++;
748 strcpy(tmp, hktp->zkata);
749 len = hktp->hlen;
750 }
751 } else {
752 strcpy(tmp, hktp->zkata);
753 len = hktp->hlen;
754 }
755 }
756 }
757 if (len) {
758 strcpy(dest, tmp);
759 dest += strlen(tmp);
760 } else {
761 for (zhtp = buf->zhtable; zhtp != NULL; zhtp = zhtp->next) {
762 if (c == *zhtp->hkata)
763 break;
764 }
765 if (zhtp != NULL) {
766 *dest++ = *zhtp->zkana;
767 *dest++ = *(zhtp->zkana + 1);
768 } else {
769 *dest++ = c;
770 }
771 }
772 } else {
773 for (zhtp = buf->zhtable; zhtp != NULL; zhtp = zhtp->next) {
774 if (c == *zhtp->hkata)
775 break;
776 }
777 if (zhtp != NULL) {
778 *dest++ = *zhtp->zkana;
779 *dest++ = *(zhtp->zkana + 1);
780 } else {
781 *dest++ = c;
782 }
783 }
784 }
785 *dest = '\0';
786 }
787
788 void
789 _Xsj3cHKataToHira(buf, dest, src)
790 Xsj3cBuf buf;
791 register unsigned char *dest, *src;
792 {
793 register unsigned char c;
794 register Xsj3cHKTable *hktp;
795 register Xsj3cZHTable *zhtp;
796 register int len;
797 unsigned char tmp[RBUFSIZ];
798
799 while ((c = *src++) != '\0') {
800 if (iskan1(c, serverIF[buf->server].lang)
801 && iskan2(*src, serverIF[buf->server].lang)) {
802 *dest++ = c;
803 *dest++ = *src++;
804 continue;
805 }
806 if (iskana(c)) {
807 len = 0;
808 for (hktp = buf->hktable; hktp != NULL; hktp = hktp->next) {
809 if (len < hktp->hlen && c == *hktp->hkata) {
810 if (hktp->hlen > 1) {
811 if (iskana(*src) && *src == *(hktp->hkata + 1)) {
812 src++;
813 len = hktp->hlen;
814 strcpy(tmp, hktp->hira);
815 }
816 } else {
817 len = 1;
818 strcpy(tmp, hktp->hira);
819 }
820 }
821 }
822 if (len) {
823 strcpy(dest, tmp);
824 dest += strlen(tmp);
825 } else {
826 for (zhtp = buf->zhtable; zhtp != NULL; zhtp = zhtp->next) {
827 if (c == *zhtp->hkata)
828 break;
829 }
830 if (zhtp != NULL) {
831 *dest++ = *zhtp->zkana;
832 *dest++ = *(zhtp->zkana + 1);
833 } else {
834 *dest++ = c;
835 }
836 }
837 } else {
838 *dest++ = c;
839 }
840 }
841 *dest = '\0';
842 }
843
844 void
845 _Xsj3cHKataToZKata(buf, dest, src)
846 Xsj3cBuf buf;
847 register unsigned char *dest, *src;
848 {
849 register unsigned char c;
850 register Xsj3cHKTable *hktp;
851 register Xsj3cZHTable *zhtp;
852 register int len;
853 unsigned char tmp[RBUFSIZ];
854
855 while ((c = *src++) != '\0') {
856 if (iskan1(c, serverIF[buf->server].lang)
857 && iskan2(*src, serverIF[buf->server].lang)) {
858 *dest++ = c;
859 *dest++ = *src++;
860 continue;
861 }
862 if (iskana(c)) {
863 len = 0;
864 for (hktp = buf->hktable; hktp != NULL; hktp = hktp->next) {
865 if (len < hktp->hlen && c == *hktp->hkata) {
866 if (hktp->hlen > 1) {
867 if (iskana(*src) && *src == *(hktp->hkata + 1)) {
868 src++;
869 strcpy(tmp, hktp->zkata);
870 len = hktp->hlen;
871 }
872 } else {
873 strcpy(tmp, hktp->zkata);
874 len = hktp->hlen;
875 }
876 }
877 }
878 if (len) {
879 strcpy(dest, tmp);
880 dest += strlen(tmp);
881 } else {
882 for (zhtp = buf->zhtable; zhtp != NULL; zhtp = zhtp->next) {
883 if (c == *zhtp->hkata)
884 break;
885 }
886 if (zhtp != NULL) {
887 *dest++ = *zhtp->zkana;
888 *dest++ = *(zhtp->zkana + 1);
889 } else {
890 *dest++ = c;
891 }
892 }
893 } else {
894 *dest++ = c;
895 }
896 }
897 *dest = '\0';
898 }
899
900
901 void
902 _Xsj3cZKanaToHKata(buf, dest, src)
903 Xsj3cBuf buf;
904 register unsigned char *dest, *src;
905 {
906 register unsigned char c;
907 register wchar s;
908 register Xsj3cHKTable *hktp;
909 register Xsj3cZHTable *zhtp;
910
911 while ((c = *src++) != '\0') {
912 if (iskan1(c, serverIF[buf->server].lang)
913 && iskan2(*src, serverIF[buf->server].lang)) {
914 s = (c << 8) + *src;
915 if (ishira(s, serverIF[buf->server].lang)) {
916 for (hktp = buf->hktable; hktp != NULL; hktp = hktp->next) {
917 if (c == *hktp->hira)
918 if (*src == *(hktp->hira + 1))
919 break;
920 }
921 if (hktp != NULL) {
922 *dest++ = *hktp->hkata;
923 if (hktp->hlen > 1)
924 *dest++ = *(hktp->hkata + 1);
925 } else {
926 *dest++ = c;
927 *dest++ = *src;
928 Xsj3cWarning("wrong sjhk table");
929 }
930 } else if (iskata(s, serverIF[buf->server].lang)) {
931 for (hktp = buf->hktable; hktp != NULL; hktp = hktp->next) {
932 if (c == *hktp->zkata)
933 if (*src == *(hktp->zkata + 1))
934 break;
935 }
936 if (hktp != NULL) {
937 *dest++ = *hktp->hkata;
938 if (hktp->hlen > 1)
939 *dest++ = *(hktp->hkata + 1);
940 } else {
941 *dest++ = c;
942 *dest++ = *src;
943 Xsj3cWarning("wrong sjhk table");
944 }
945 } else {
946 for (zhtp = buf->zhtable; zhtp != NULL; zhtp = zhtp->next) {
947 if (c == *zhtp->zkana)
948 if (*src == *(zhtp->zkana + 1))
949 break;
950 }
951 if (zhtp != NULL) {
952 *dest++ = *zhtp->hkata;
953 } else {
954 for (zhtp = buf->zhtable; zhtp != NULL; zhtp = zhtp->next) {
955 if (c == *zhtp->zalpha)
956 if (*src == *(zhtp->zalpha + 1))
957 break;
958 }
959 if (zhtp != NULL) {
960 *dest++ = *zhtp->hkata;
961 } else {
962 *dest++ = c;
963 *dest++ = *src;
964 }
965 }
966 }
967 src++;
968 } else {
969 *dest++ = c;
970 }
971 }
972 *dest = '\0';
973 }
974
975 void
976 _Xsj3cZKataToHira(buf, dest, src)
977 Xsj3cBuf buf;
978 register unsigned char *dest, *src;
979 {
980 register wchar s;
981 register unsigned char c;
982 register Xsj3cHKTable *hktp;
983 register Xsj3cZHTable *zhtp;
984
985 while ((c = *src++) != '\0') {
986 if (iskan1(c, serverIF[buf->server].lang)
987 && iskan2(*src, serverIF[buf->server].lang)) {
988 s = (c << 8) + *src;
989 if (iskata(s, serverIF[buf->server].lang)) {
990 for (hktp = buf->hktable; hktp != NULL; hktp = hktp->next) {
991 if (c == *hktp->zkata)
992 if (*src == *(hktp->zkata + 1))
993 break;
994 }
995 if (hktp != NULL) {
996 *dest++ = *hktp->hira;
997 *dest++ = *(hktp->hira + 1);
998 } else {
999 *dest++ = c;
1000 *dest++ = *src;
1001 Xsj3cWarning("wrong sjhk table");
1002 }
1003 } else {
1004 *dest++ = c;
1005 *dest++ = *src;
1006 }
1007 src++;
1008 } else if (isdakuten(c)) {
1009 for (zhtp = buf->zhtable; zhtp != NULL; zhtp = zhtp->next) {
1010 if (c == *zhtp->hkata)
1011 break;
1012 }
1013 if (zhtp != NULL) {
1014 *dest++ = *zhtp->zkana;
1015 *dest++ = *(zhtp->zkana + 1);
1016 } else {
1017 *dest++ = c;
1018 }
1019 } else {
1020 *dest++ = c;
1021 }
1022 }
1023 *dest = '\0';
1024 }
1025
1026 void
1027 _Xsj3cHAlphaToZAlpha(buf, dest, src)
1028 Xsj3cBuf buf;
1029 register unsigned char *dest, *src;
1030 {
1031 register unsigned char c;
1032 register Xsj3cZHTable *zhtp;
1033
1034 while ((c = *src++) != '\0') {
1035 if (iskan1(c, serverIF[buf->server].lang)
1036 && iskan2(*src, serverIF[buf->server].lang)) {
1037 *dest++ = c;
1038 *dest++ = *src++;
1039 continue;
1040 }
1041 for (zhtp = buf->zhtable; zhtp != NULL; zhtp = zhtp->next) {
1042 if (c == *zhtp->halpha)
1043 break;
1044 }
1045 if (zhtp != NULL) {
1046 *dest++ = *zhtp->zalpha;
1047 *dest++ = *(zhtp->zalpha + 1);
1048 } else {
1049 *dest++ = c;
1050 }
1051 }
1052 *dest = '\0';
1053 }
1054
1055 void
1056 _Xsj3cHAlphaToZKana(buf, dest, src)
1057 Xsj3cBuf buf;
1058 register unsigned char *dest, *src;
1059 {
1060 register unsigned char c;
1061 register Xsj3cZHTable *zhtp;
1062
1063 while ((c = *src++) != '\0') {
1064 if (iskan1(c, serverIF[buf->server].lang)
1065 && iskan2(*src, serverIF[buf->server].lang)) {
1066 *dest++ = c;
1067 *dest++ = *src++;
1068 continue;
1069 }
1070 for (zhtp = buf->zhtable; zhtp != NULL; zhtp = zhtp->next) {
1071 if (c == *zhtp->halpha)
1072 break;
1073 }
1074 if (zhtp != NULL) {
1075 *dest++ = *zhtp->zkana;
1076 *dest++ = *(zhtp->zkana + 1);
1077 } else {
1078 *dest++ = c;
1079 }
1080 }
1081 *dest = '\0';
1082 }
1083
1084 void
1085 _Xsj3cHAlphaToHKata(buf, dest, src)
1086 Xsj3cBuf buf;
1087 register unsigned char *dest, *src;
1088 {
1089 register unsigned char c;
1090 register Xsj3cHKTable *hktp;
1091
1092 while ((c = *src++) != '\0') {
1093 if (iskan1(c, serverIF[buf->server].lang)
1094 && iskan2(*src, serverIF[buf->server].lang)) {
1095 *dest++ = c;
1096 *dest++ = *src++;
1097 continue;
1098 }
1099 for (hktp = buf->hktable; hktp != NULL; hktp = hktp->next) {
1100 if (c == *hktp->halpha)
1101 break;
1102 }
1103 if (hktp != NULL) {
1104 *dest++ = *hktp->hkata;
1105 } else {
1106 *dest++ = c;
1107 }
1108 }
1109 *dest = '\0';
1110 }
1111
1112 void
1113 _Xsj3cZAlphaToHAlpha(buf, dest, src)
1114 Xsj3cBuf buf;
1115 register unsigned char *dest, *src;
1116 {
1117 register unsigned char c;
1118 register Xsj3cZHTable *zhtp;
1119
1120 while ((c = *src++) != '\0') {
1121 if (iskan1(c, serverIF[buf->server].lang)
1122 && iskan2(*src, serverIF[buf->server].lang)) {
1123 for (zhtp = buf->zhtable; zhtp != NULL; zhtp = zhtp->next) {
1124 if (c == *zhtp->zalpha)
1125 if (*src == *(zhtp->zalpha + 1))
1126 break;
1127 }
1128 if (zhtp != NULL) {
1129 *dest++ = *zhtp->halpha;
1130 } else {
1131 *dest++ = c;
1132 *dest++ = *src;
1133 }
1134 src++;
1135 } else {
1136 *dest++ = c;
1137 }
1138 }
1139 *dest = '\0';
1140 }
1141
1142 static void
1143 _Xsj3cLowerToUpper(buf, str)
1144 Xsj3cBuf buf;
1145 register unsigned char *str;
1146 {
1147 register unsigned char c;
1148 register wchar s;
1149
1150 while ((c = *str++) != '\0') {
1151 if (iskan1(c, serverIF[buf->server].lang)
1152 && iskan2(*str, serverIF[buf->server].lang)) {
1153 s = (c << 8) + *str;
1154 if (iszlower(s, serverIF[buf->server].lang)) {
1155 s -= 0x21;
1156 *(str - 1) = (s >> 8);
1157 *str++ = (s & 0xff);
1158 } else {
1159 str++;
1160 }
1161 continue;
1162 }
1163 if (islower(c)) {
1164 *(str - 1) = toupper(c);
1165 }
1166 }
1167 }
1168
1169 static void
1170 _Xsj3cUpperToLower(buf, str)
1171 Xsj3cBuf buf;
1172 register unsigned char *str;
1173 {
1174 register unsigned char c;
1175 register wchar s;
1176
1177 while ((c = *str++) != '\0') {
1178 if (iskan1(c, serverIF[buf->server].lang)
1179 && iskan2(*str, serverIF[buf->server].lang)) {
1180 s = (c << 8) + *str;
1181 if (iszupper(s, serverIF[buf->server].lang)) {
1182 s += 0x21;
1183 *(str - 1) = (s >> 8);
1184 *str++ = (s & 0xff);
1185 } else {
1186 str++;
1187 }
1188 continue;
1189 }
1190 if (isupper(c)) {
1191 *(str - 1) = tolower(c);
1192 }
1193 }
1194 }