Mercurial > kinput2.yaz

comparison lib/Xsj3clib/conv.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: conv.c,v 2.12 1993/09/21 09:43:15 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 #include "segment.h"
33 #include "mode.h"
34 #include "func.h"
35
36 extern Xsj3cCVServerIF serverIF[SERVER_NUM];
37
38 unsigned char *Xsj3cGetPreeditArea();
39 Xsj3cEvent Xsj3cKeyConv();
40
41 int _Xsj3cRomaConv();
42 int _Xsj3cKanaConv();
43
44 static Xsj3cEvent _Xsj3cStrConv();
45 static Xsj3cEvent _Xsj3cCtrlConv();
46 static Xsj3cEvent _Xsj3cThrough();
47 static Xsj3cEvent _Xsj3cDirect();
48 static int _Xsj3cCodeConv();
49
50 /*
51 * Xsj3cGetPreeditArea()
52 * Get area for pre-edit string.
53 */
54 unsigned char *
55 Xsj3cGetPreeditArea(buf, len)
56 register Xsj3cBuf buf;
57 register int *len;
58 {
59 register Xsj3cSeg seg;
60
61 if (buf->convmode == DictModeMask) {
62 /* $B<-=q%b!<%I$N>l9g$O<-=qFI$_MQ$NF~NO$r9T$&(B */
63 seg = buf->dict->seg;
64 } else if (buf->convmode != SelectModeMask) {
65 if (buf->input[buf->curseg]
66 && buf->input[buf->curseg]->status == SEG_CONVED) {
67 /* $B8=J8@a$,JQ49:Q$_$N>l9g(B */
68
69 buf->convmode = ConvedModeMask;
70 switch (buf->flushiconv) {
71 case ON:
72 /* FlushInConversion on $B$N;~$O8=:_JQ49Cf$N(B */
73 /* $BJ8$r3NDj$7$F?75,$NJ8$NF~NO$r9T$&(B */
74
75 if (!buf->backup) {
76 if ((buf->backup = (Xsj3cSeg *)calloc(BUNBUFSIZ,
77 sizeof(Xsj3cSeg))) == NULL) {
78 Xsj3cError("Cannot allocate for backup buffers");
79 }
80 }
81 if (seg = buf->backup[0]) {
82 *seg->str = '\0';
83 seg->sp = seg->str;
84 *seg->oldstr = '\0';
85 seg->oldlen = 0;
86 seg->n_roma = 0;
87 seg->n_kana = -1;
88 } else
89 seg = buf->backup[0] = (Xsj3cSeg)Xsj3cCreateSegment(buf);
90 break;
91 case EDIT:
92 /* FlushInConversion edit $B$N;~$O%+%l%s%H(B */
93 /* $BJ8@a$X$NF~NO$r9T$&(B */
94
95 if (!(seg = buf->input[buf->curseg])) {
96 seg = buf->input[buf->curseg]
97 = (Xsj3cSeg)Xsj3cCreateSegment(buf);
98 } else {
99 *seg->str = '\0';
100 seg->sp = seg->str;
101 *seg->oldstr = '\0';
102 seg->oldlen = 0;
103 seg->n_roma = 0;
104 seg->n_kana = -1;
105 }
106 break;
107 case OFF:
108 case NONE:
109 default:
110 /* FlushInConversion none/off $B$N>l9g!"?7$?$J(B*/
111 /* $BJ8@a$NFI$_J8;zNs$NF~NO$r9T$&(B */
112
113 if (seg = buf->input[buf->segnum]) {
114 Xsj3cClearSegment(buf, buf->input[buf->segnum]);
115 } else {
116 seg = buf->input[buf->segnum]
117 = (Xsj3cSeg)Xsj3cCreateSegment(buf);
118 }
119 break;
120 }
121 } else if (buf->segnum > 0) {
122 /* $B8=J8@a$,L$JQ49$GF~NOJ8;z$,$"$k>l9g(B */
123
124 buf->convmode = InputModeMask;
125 if (buf->input[buf->curseg]
126 && (buf->input[buf->curseg]->edit & SEG_NOEDIT)) {
127 /* $BJ8;zF~NO$r5v$5$l$F$$$J$$J8@a$N>l9g(B */
128 switch (buf->flushiconv) {
129 case ON:
130 /* FlushInConversion on $B$N;~$O8=:_JQ49Cf$N(B */
131 /* $BJ8$r3NDj$7$F?75,$NJ8$NF~NO$r9T$&(B */
132
133 if (!buf->backup) {
134 if ((buf->backup = (Xsj3cSeg *)calloc(BUNBUFSIZ,
135 sizeof(Xsj3cSeg))) == NULL) {
136 Xsj3cError("Cannot allocate for backup buffers");
137 }
138 }
139 if (seg = buf->backup[0]) {
140 *seg->str = '\0';
141 seg->sp = seg->str;
142 *seg->oldstr = '\0';
143 seg->oldlen = 0;
144 seg->n_roma = 0;
145 seg->n_kana = -1;
146 } else
147 seg = buf->backup[0]
148 = (Xsj3cSeg)Xsj3cCreateSegment(buf);
149 break;
150 case EDIT:
151 if (!(seg = buf->input[buf->curseg]))
152 seg = buf->input[buf->curseg]
153 = (Xsj3cSeg)Xsj3cCreateSegment(buf);
154 break;
155 case OFF:
156 case NONE:
157 default:
158 if (seg = buf->input[buf->segnum]) {
159 Xsj3cClearSegment(buf, buf->input[buf->segnum]);
160 } else
161 seg = buf->input[buf->segnum]
162 = (Xsj3cSeg)Xsj3cCreateSegment(buf);
163 }
164 } else {
165 /* $B%+%l%s%HJ8@a$X$NF~NO$r9T$&(B */
166
167 if (!(seg = buf->input[buf->curseg]))
168 seg = buf->input[buf->curseg]
169 = (Xsj3cSeg)Xsj3cCreateSegment(buf);
170 }
171 } else {
172 /* $BF~NOJ8;z$,$J$$>l9g(B */
173
174 buf->convmode = NoInputModeMask;
175 /* New segment(first segment) */
176 if (seg = buf->input[buf->curseg])
177 Xsj3cClearSegment(buf, buf->input[buf->curseg]);
178 else
179 seg = buf->input[buf->curseg]
180 = (Xsj3cSeg)Xsj3cCreateSegment(buf);
181 }
182 } else {
183 /* SelectMode */
184 switch (buf->selectstatus) {
185 case SELECT_CAND:
186 /* $B8uJdA*Br$N>l9g(B */
187
188 switch (buf->flushsconv) {
189 case ON:
190 /* FlushSelectConversion on $B$N;~$O8=:_JQ49(B */
191 /* $BCf$NJ8$r3NDj$7$F?75,$NJ8$NF~NO$r9T$&(B */
192
193 if (!buf->backup) {
194 if ((buf->backup = (Xsj3cSeg *)calloc(BUNBUFSIZ,
195 sizeof(Xsj3cSeg))) == NULL) {
196 Xsj3cError("Cannot allocate for backup buffers");
197 }
198 }
199 if (seg = buf->backup[0]) {
200 *seg->str = '\0';
201 seg->sp = seg->str;
202 *seg->oldstr = '\0';
203 seg->oldlen = 0;
204 seg->n_roma = 0;
205 seg->n_kana = -1;
206 } else {
207 seg = buf->backup[0] = (Xsj3cSeg)Xsj3cCreateSegment(buf);
208 }
209 break;
210 case EDIT:
211 /* FlushSelectConversion edit $B$N>l9g!"L5(B */
212 /* $BJQ49>uBV$K$7$F%+%l%s%HJ8@a$X$NF~NO$r9T$&(B */
213
214 if (!(seg = buf->input[buf->curseg])) {
215 seg = buf->input[buf->curseg]
216 = (Xsj3cSeg)Xsj3cCreateSegment(buf);
217 } else {
218 *seg->str = '\0';
219 seg->sp = seg->str;
220 *seg->oldstr = '\0';
221 seg->oldlen = 0;
222 seg->n_roma = 0;
223 seg->n_kana = -1;
224 }
225 break;
226 case OFF:
227 case NONE:
228 default:
229 /* FlushSelectConversion none/off $B$N>l9g!"(B */
230 /* $B?7$?$JJ8@a$NFI$_J8;zNs$NF~NO$r9T$&(B */
231
232 if (seg = buf->input[buf->segnum]) {
233 Xsj3cClearSegment(buf, buf->input[buf->segnum]);
234 } else {
235 seg = buf->input[buf->segnum]
236 = (Xsj3cSeg)Xsj3cCreateSegment(buf);
237 }
238 break;
239 }
240 break;
241 case SELECT_HINSI:
242 /* $BIJ;lA*Br$N>l9g(B */
243
244 seg = buf->dict->seg;
245 break;
246 case SELECT_SYMBOL:
247 default:
248 /* $B5-9fA*Br$N>l9g(B */
249
250 if (seg = buf->input[buf->segnum]) {
251 Xsj3cClearSegment(buf, buf->input[buf->segnum]);
252 } else {
253 seg = buf->input[buf->segnum]
254 = (Xsj3cSeg)Xsj3cCreateSegment(buf);
255 }
256 break;
257 }
258 }
259 *len = RBUFSIZ - (seg->sp - seg->str);
260 buf->current = seg;
261 return (seg->sp);
262 }
263
264 #define IsKanaKey(ks) ((unsigned)(ks) < 0xff00 && ((unsigned)(ks) & 0x0400))
265 #define IsLatin1Key(ks) ((unsigned)(ks) < 0x0100)
266
267 /*
268 * Xsj3cKeyConv()
269 * Convert string or keysym and do function.
270 */
271 Xsj3cEvent
272 Xsj3cKeyConv(buf, n, mod, ks)
273 Xsj3cBuf buf;
274 int n;
275 unsigned long mod;
276 KeySym ks;
277 {
278 register Xsj3cKeyTable *keytp;
279 Xsj3cSeg seg = buf->current;
280 Xsj3cEvent ret = KEY_NULL;
281 unsigned char *tmpsp;
282 register int i, doflg;
283
284 /* KeySym/Modifier$B!"8=:_$NJQ49%b!<%I$H3F%U%!%s%/%7%g%s(B */
285 /* $B$NBP1~%F!<%V%k$r%5!<%A$7$F9gCW$9$k$b$N$,$"$l$P%U%!%s(B */
286 /* $B%/%7%g%s$r<B9T$9$k!#(B */
287 for (keytp = buf->key, doflg = 0; keytp != NULL; keytp = keytp->next) {
288 /* KeySym */
289 if (ks == keytp->ksym &&
290 /* Modifier Key */
291 (keytp->modmask & ~AllModeMask) == mod &&
292 /* Conversion mode */
293 (keytp->modmask & buf->convmode) == buf->convmode) {
294 /* Do function */
295 doflg++;
296
297 /* .key.func $B$NBh#3%U%#!<%k%I$,(B off $B$N;~$O%U%!%s%/%7%g%s(B */
298 /* $B$N$_<B9T$7!"(Bnone $B$N;~$O(B .InputSameTime $B$N;XDj$K0MB8$9$k(B */
299 /* InputSameTime off $B$N;~$O%U%!%s%/%7%g%s<B9T$9$k(B */
300 if (!buf->inputsame) {
301 if (keytp->inputsame != ON)
302 goto dofunc;
303 } else {
304 if (!keytp->inputsame)
305 goto dofunc;
306 }
307 break;
308 }
309 }
310
311 /* LookupString $B$N7k2L$O(B NULL terminate */
312 /* $B$7$F$$$J$$$N$G(B NULL terminate $B$5$;$k(B */
313 tmpsp = seg->sp;
314 i = n;
315 while(i--) {
316 if (iscntrl(*tmpsp)) {
317 if (buf->throughflg == QUOTE) {
318 ret |= KEY_CONTROL;
319 tmpsp++;
320 continue;
321 }
322 /* ControlSameTime off $B$N>l9g$O(B */
323 /* $B%U%!%s%/%7%g%s$N$_<B9T(B */
324 if (doflg && !buf->cntrlsame)
325 goto dofunc;
326 else {
327 ret = _Xsj3cCtrlConv(buf, *tmpsp);
328 if (buf->cntrlsame)
329 goto dofunc;
330 else
331 return (ret);
332 }
333 }
334 tmpsp++;
335 }
336 *tmpsp = '\0';
337
338 if (!n || !(IsKanaKey(ks)||(IsLatin1Key(ks)))) {
339 /* $B%F%-%9%H$KJQ49$G$-$J$+$C$?>l9g$O(B */
340 /* $B%U%!%s%/%7%g%s$N$_<B9T(B */
341 goto dofunc;
342 }
343
344 switch (buf->convmode) {
345 case SelectModeMask:
346
347 switch (buf->selectstatus) {
348 case SELECT_CAND:
349 /* $B8uJdA*Br$N>l9g(B */
350
351 switch (buf->flushsconv) {
352 case ON:
353 ret |= (KEY_SELECT_END|KEY_TEXT_CHANGE);
354 for (i = 1; i < buf->backsegnum + 1; i++) {
355 Xsj3cFreeSegment(buf->backup[i]);
356 buf->backup[i] = NULL;
357 }
358 seg->yomi[0] = '\0';
359 seg->disp[0] = '\0';
360 seg->num = 0;
361 seg->cur = 0;
362 seg->dnum = 0;
363 seg->status = SEG_NOCONV;
364 seg->cursegmode = buf->inputmode;
365 seg->change = OFF;
366 seg->edit = SEG_NOEDIT;
367 bzero(&seg->dcid, sizeof(seg->dcid));
368 buf->backsegnum = 1;
369 ret |= KEY_TEXT_FLUSH;
370 if (buf->dispmodechange) {
371 buf->dispmode = buf->inputmode;
372 ret |= KEY_MODE_CHANGE;
373 }
374 break;
375 case EDIT:
376 ret |= (KEY_SELECT_END|KEY_TEXT_CHANGE);
377 if (buf->curseg == buf->segnum)
378 buf->segnum++;
379 else {
380 ret |= _Xsj3cUnConvSeg(buf, ONE, buf->editcurlast);
381 _Xsj3cStoreYomi(buf, buf->input[buf->curseg], 0);
382 }
383 break;
384 case OFF:
385 ret |= (KEY_SELECT_END|KEY_TEXT_CHANGE);
386 if (buf->dispmodechange) {
387 buf->dispmode = buf->convedsegnum ? MODE_EDIT :
388 buf->inputmode;
389 ret |= KEY_MODE_CHANGE;
390 }
391 break;
392 case NONE:
393 default:
394 goto dofunc;
395 }
396 break;
397 case SELECT_HINSI:
398 /* $BIJ;lA*Br$N>l9g(B */
399
400 ret |= (KEY_DICT_CHANGE|KEY_SELECT_ABORT);
401 buf->dict->status = DICT_INPUT;
402 if (buf->dispmodechange) {
403 buf->dispmode =
404 (buf->dict->mode == REG_STATE ? MODE_TOROKU : MODE_SYOUKYO);
405 ret |= KEY_MODE_CHANGE;
406 }
407 break;
408 case SELECT_SYMBOL:
409 default:
410 /* $B5-9fA*Br$N>l9g(B */
411 goto dofunc;
412 }
413 break;
414 case DictModeMask:
415 if (buf->dict->status != DICT_INPUT) {
416 /* $B<-=qEPO?!?>C5n%b!<%I$G$h$_F~NO;~$G$J$$(B */
417 /* $B$H$-$O$rJV$7$F$J$K$b$7$J$$!#(B */
418 goto dofunc;
419 }
420 ret |= KEY_DICT_CHANGE;
421 seg->edit = SEG_EDIT;
422 ret = _Xsj3cStrConv(buf, seg, ks, n, ret);
423 _Xsj3cFlushDictMsg(buf);
424 goto dofunc;
425 case ConvedModeMask:
426 ret |= KEY_TEXT_CHANGE;
427 if (buf->candidate)
428 Xsj3cEndCandidate(buf, ON);
429 switch (buf->flushiconv) {
430 case ON:
431 for (i = 1; i < buf->backsegnum + 1; i++) {
432 Xsj3cFreeSegment(buf->backup[i]);
433 buf->backup[i] = NULL;
434 }
435 seg->yomi[0] = '\0';
436 seg->disp[0] = '\0';
437 seg->num = 0;
438 seg->cur = 0;
439 seg->dnum = 0;
440 seg->status = SEG_NOCONV;
441 seg->cursegmode = buf->inputmode;
442 seg->change = OFF;
443 seg->edit = SEG_NOEDIT;
444 bzero(&seg->dcid, sizeof(seg->dcid));
445 buf->backsegnum = 1;
446 ret |= KEY_TEXT_FLUSH;
447 if (buf->dispmodechange) {
448 buf->dispmode = buf->inputmode;
449 ret |= KEY_MODE_CHANGE;
450 }
451 break;
452 case OFF:
453 buf->curseg = buf->segnum;
454 buf->segnum++;
455 if (buf->dispmodechange) {
456 buf->dispmode =
457 (buf->convedsegnum ? MODE_EDIT : buf->inputmode);
458 ret |= KEY_MODE_CHANGE;
459 }
460 break;
461 case EDIT:
462 if (buf->curseg == buf->segnum)
463 buf->segnum++;
464 else {
465 ret |= _Xsj3cUnConvSeg(buf, ONE, buf->editcurlast);
466 _Xsj3cStoreYomi(buf, seg, 0);
467 }
468 break;
469 case NONE:
470 default:
471 goto dofunc;
472 }
473 break;
474 case InputModeMask:
475 ret |= KEY_TEXT_CHANGE;
476 if (buf->input[buf->curseg]->edit & SEG_NOEDIT) {
477 switch (buf->flushiconv) {
478 case ON:
479 for (i = 1; i < buf->backsegnum + 1; i++) {
480 Xsj3cFreeSegment(buf->backup[i]);
481 buf->backup[i] = NULL;
482 }
483 seg->yomi[0] = '\0';
484 seg->disp[0] = '\0';
485 seg->num = 0;
486 seg->cur = 0;
487 seg->dnum = 0;
488 seg->status = SEG_NOCONV;
489 seg->cursegmode = buf->inputmode;
490 seg->change = OFF;
491 seg->edit = SEG_NOEDIT;
492 bzero(&seg->dcid, sizeof(seg->dcid));
493 buf->backsegnum = 1;
494 ret |= KEY_TEXT_FLUSH;
495 break;
496 case OFF:
497 buf->curseg = buf->segnum;
498 buf->segnum++;
499 if (buf->dispmodechange) {
500 buf->dispmode = buf->convedsegnum ? MODE_EDIT :
501 buf->inputmode;
502 ret |= KEY_MODE_CHANGE;
503 }
504 break;
505 case EDIT:
506 if (buf->curseg == buf->segnum)
507 buf->segnum++;
508 break;
509 case NONE:
510 default:
511 goto dofunc;
512 }
513 } else if (buf->curseg == buf->segnum)
514 buf->segnum++;
515 break;
516 case NoInputModeMask:
517 if (buf->curseg == buf->segnum)
518 buf->segnum++;
519 if (buf->throughflg == THROUGH) {
520 ret |= _Xsj3cThrough(buf, seg, n);
521 buf->throughflg = OFF;
522 goto dofunc;
523 }
524 ret |= KEY_TEXT_CHANGE;
525 break;
526 default:
527 Xsj3cWarning ("Unknown conversion mode");
528 goto dofunc;
529 }
530
531 seg->edit = SEG_EDIT;
532 ret = _Xsj3cStrConv(buf, seg, ks, n, ret);
533
534 dofunc:
535 if (doflg && !(ret & KEY_TEXT_FLUSH)) {
536 ret |= ((*(keytp->func))(buf));
537 if (!buf->cntrlsame)
538 ret |= KEY_FUNC;
539 }
540 return (ret);
541 }
542
543 /*
544 * _Xsj3cStrConv()
545 * Convert pre-edit strings and store results to yomi/disp buffer.
546 */
547 static Xsj3cEvent
548 _Xsj3cStrConv(buf, seg, ks, n, ret)
549 Xsj3cBuf buf;
550 Xsj3cSeg seg;
551 KeySym ks;
552 int n;
553 Xsj3cEvent ret;
554 {
555 register unsigned char *tmpsp;
556 unsigned char tmp1[YBUFSIZ];
557 unsigned char tmp2[YBUFSIZ];
558 unsigned char kanabuf[YBUFSIZ];
559 wchar wcs[RBUFSIZ];
560 register int i;
561 int change_pos;
562 int change_roma = 0;
563
564 if (buf->throughflg == QUOTE) {
565 ret |= _Xsj3cDirect(buf, seg, n);
566 buf->throughflg = OFF;
567 return (ret);
568 }
569 if (seg->num > seg->size - YBUFSIZ)
570 Xsj3cResizeSegment(seg, seg->size + KANABUFSIZ);
571
572 switch (buf->inputmode) {
573 case MODE_HIRA:
574 case MODE_ZKATA:
575 case MODE_HKATA:
576 /* $B$R$i$,$J!?A43Q%+%?%+%J!?H>3Q%+%?%+%JF~NO%b!<%I$N>l9g(B */
577 if (IsKanaKey(ks) || (IsLatin1Key(ks) && buf->kanaonly)) {
578
579 /* $B$+$JF~NO$N>l9g(B */
580 int len;
581
582 if (seg->n_roma) {
583
584 /* $B$+$J%P%C%U%!(B(seg->str)$B$K%m!<%^;zF~NO;~$N(B */
585 /* $BJ8;zNs$,;D$C$F$$$k>l9g$O$=$l$r:o=|$9$k(B */
586 i = n;
587 tmpsp = seg->sp;
588 while (i--) {
589 *(tmpsp - seg->n_roma) = *tmpsp;
590 tmpsp++;
591 }
592 *(tmpsp - seg->n_roma) = '\0';
593 seg->sp = seg->sp - seg->n_roma;
594 seg->n_roma = 0;
595 }
596 if (buf->inputmode == MODE_HKATA) {
597
598 /* $BH>3Q%+%?%+%JF~NO%b!<%I$N$H$-$O(B */
599 /* $BJQ49$r9T$o$J$$$GFI$_%P%C%U%!$K%3%T!<(B */
600 if (IsKanaKey(ks))
601 strcpy(tmp1, seg->sp);
602 else
603 _Xsj3cHAlphaToHKata(buf, tmp1, seg->sp);
604 seg->sp = seg->str;
605 *seg->oldstr= '\0';
606 seg->n_kana = -1;
607 change_pos = seg->cur;
608 _Xsj3cInsertChar(buf, seg, tmp1, strlen(tmp1));
609
610 } else {
611 /* $B$R$i$,$J!?A43Q%+%?%+%JF~NO%b!<%I$N;~$OH>3Q(B */
612 /* $B%+%?%+%J"*$R$i$,$J!?A43Q%+%?%+%JJQ49$r9T$&(B */
613 if (IsLatin1Key(ks)) {
614 strcpy(tmp2, seg->sp);
615 _Xsj3cHAlphaToHKata(buf, seg->sp, tmp2);
616 }
617 if ((seg->value = _Xsj3cKanaConv(buf, seg, seg->str,
618 tmp1, buf->inputmode)) > 0) {
619
620 /* $BH>3Q%+%?%+%J"*$R$i$,$JJQ49$,@.8y$7$?>l9g(B */
621 /* $BBy2;!?H>By2;$N>l9g(B */
622 seg->sp = seg->str;
623 if (seg->n_kana > 0) {
624 _Xsj3cExtractChar(buf, seg, tmp2, seg->n_kana);
625 strcpy(seg->oldstr, seg->str);
626 tmpsp = seg->oldstr;
627 while(*tmpsp != '\0')
628 tmpsp++;
629 *(tmpsp - seg->n_kana) = '\0';
630 } else {
631 *seg->oldstr = '\0';
632 }
633 seg->n_kana = 0;
634 } else if (seg->value == 0) {
635
636 /* $BH>3Q%+%?%+%J"*$R$i$,$J!?A43Q%+%?%+%J(B */
637 /* $BJQ49$N7k2L$,ITDj$N>l9g(B */
638 if (seg->n_kana > 0)
639 _Xsj3cExtractChar(buf, seg, tmp2, seg->n_kana);
640 tmpsp = seg->sp + n - 1;
641 seg->sp = seg->str;
642 *seg->sp = *tmpsp;
643 *(++seg->sp) = '\0';
644 seg->n_kana = 1;
645 *seg->oldstr = '\0';
646 } else {
647
648 /* $BH>3Q%+%?%+%J"*$R$i$,$JJQ49$,@.8y$7$?>l9g(B */
649 /* $BBy2;!?H>By2;$G$J$$>l9g(B */
650 if (seg->n_kana > 0)
651 _Xsj3cExtractChar(buf, seg, tmp2, seg->n_kana);
652 seg->sp = seg->str;
653 *seg->oldstr = '\0';
654 seg->n_kana = 0;
655 }
656 change_pos = seg->cur;
657 len = _Xsj3cmPStowPS(buf, wcs, tmp1);
658 _Xsj3cInsertWchar(seg, wcs, len);
659 }
660 seg->n_roma = 0;
661
662 } else if (IsLatin1Key(ks)) {
663
664 /* $B%m!<%^;zF~NO$N>l9g(B */
665
666 if (seg->n_kana > 0) {
667
668 /* $B%m!<%^;z%P%C%U%!(B(seg->str)$B$K$+$JF~NO;~$N(B */
669 /* $BJ8;zNs$,;D$C$F$$$k>l9g$O$=$l$r:o=|$9$k(B */
670 i = n;
671 tmpsp = seg->sp;
672 while (i--) {
673 *(tmpsp - seg->n_kana) = *tmpsp;
674 tmpsp++;
675 }
676 *(tmpsp - seg->n_kana) = '\0';
677 seg->sp = seg->sp - seg->n_kana;
678 seg->n_kana = -1;
679 }
680
681 /* $BF~NO%b!<%I$K4X78$J$/$+$JJQ49$r9T$&(B */
682
683 if ((seg->value = _Xsj3cRomaConv(buf->rktable,
684 seg->str, kanabuf)) > 0) {
685
686 /* ROMA->$B$+$J(B $BJQ49$,@.8y$7$?>l9g(B */
687 if (buf->alphaconv) {
688 /* AlphabetConversion $B%j%=!<%9$,(B on */
689 /* $B$@$C$?$iA43Q$rH>3Q$KJQ49$9$k(B */
690
691 _Xsj3cExtractChar(buf, seg, tmp1, seg->n_roma);
692 _Xsj3cZAlphaToHAlpha(buf, seg->oldstr, tmp1);
693 } else {
694 _Xsj3cExtractChar(buf, seg, seg->oldstr, seg->n_roma);
695 }
696 change_pos = seg->cur;
697 if (buf->inputmode == MODE_HIRA) {
698
699 /* $B$R$i$,$JF~NO%b!<%I$N$H$-$O$=$N$^$^(B */
700 /* $BFI$_%P%C%U%!$K%3%T!<(B */
701 seg->oldlen = _Xsj3cmPStowPS(buf, wcs, kanabuf);
702 } else if (buf->inputmode == MODE_ZKATA) {
703
704 /* $BA43Q%+%?%+%JF~NO%b!<%I$N$H$-$O(B */
705 /* $B$R$i$,$J$rA43Q%+%?%+%J$KJQ49(B */
706 _Xsj3cHiraToZKata(buf, tmp1, kanabuf);
707 seg->oldlen = _Xsj3cmPStowPS(buf, wcs, tmp1);
708 } else {
709
710 /* $BH>3Q%+%?%+%JF~NO%b!<%I$N;~$O$R$i$,$J(B */
711 /* $B!?A43Q%+%?%+%J$rH>3Q%+%?%+%J$KJQ49(B */
712 _Xsj3cZKanaToHKata(buf, tmp1, kanabuf);
713 seg->oldlen = _Xsj3cmPStowPS(buf, wcs, tmp1);
714 }
715 _Xsj3cInsertWchar(seg, wcs, seg->oldlen);
716 seg->n_roma = 0;
717
718 /* $BJQ49$G$-$J$$J8;z$,%m!<%^;z%P%C%U%!$K;D$C$F(B */
719 /* $B$$$?$i!JNc!V$C!W$KJQ49$5$l$k>l9gEy!K(B */
720 /* $B$+$J%P%C%U%!$N:G8e$K$=$NJ8;z$rIUM?$9$k(B */
721 if (*seg->str != '\0') {
722 _Xsj3cInsertChar(buf, seg, seg->str, strlen(seg->str));
723 seg->sp = seg->str;
724 while (*seg->sp != '\0') {
725 seg->sp++;
726 seg->n_roma++;
727 }
728 change_roma = seg->n_roma;
729 } else {
730 seg->sp = seg->str;
731 }
732
733 } else if (seg->value == 0) {
734
735 /* ROMA$B"*$+$JJQ49$N7k2L$,ITDj$N>l9g(B */
736 change_pos = seg->cur;
737 _Xsj3cInsertChar(buf, seg, seg->sp, n);
738 i = n;
739 while (i--) {
740 seg->sp++;
741 seg->n_roma++;
742 }
743 change_roma = n;
744
745 } else {
746 /* ROMA$B"*$+$J(B $BJQ49$N7k2L$,IT@.8y$N>l9g(B */
747 /* $B:G8e$NF~NO$,%m!<%^$+$JJQ49$N8uJd$H(B */
748 /* $B$7$FM-8z$+$I$&$+D4$Y$k(B */
749
750 change_pos = seg->cur;
751 if ((seg->value = _Xsj3cRomaConv(buf->rktable, seg->sp,
752 kanabuf)) > 0) {
753 /* $B:G8e$NF~NO$,%m!<%^$+$JJQ49$N8uJd$H$7$F(B */
754 /* $BM-8z$J>l9g(B */
755
756 if (buf->inputmode == MODE_HIRA) {
757
758 /* $B$R$i$,$JF~NO%b!<%I$N$H$-$O$=$N$^$^(B */
759 /* $BFI$_%P%C%U%!$K%3%T!<(B */
760 seg->oldlen = _Xsj3cmPStowPS(buf, wcs, kanabuf);
761 } else if (buf->inputmode == MODE_ZKATA) {
762
763 /* $BA43Q%+%?%+%JF~NO%b!<%I$N$H$-$O(B */
764 /* $B$R$i$,$J$rA43Q%+%?%+%J$KJQ49(B */
765 _Xsj3cHiraToZKata(buf, tmp1, kanabuf);
766 seg->oldlen = _Xsj3cmPStowPS(buf, wcs, tmp1);
767 } else {
768
769 /* $BH>3Q%+%?%+%JF~NO%b!<%I$N;~$O$R$i$,$J(B */
770 /* $B!?A43Q%+%?%+%J$rH>3Q%+%?%+%J$KJQ49(B */
771 _Xsj3cZKanaToHKata(buf, tmp1, kanabuf);
772 seg->oldlen = _Xsj3cmPStowPS(buf, wcs, tmp1);
773 }
774 _Xsj3cInsertWchar(seg, wcs, seg->oldlen);
775 seg->n_roma = 0;
776
777 /* $BJQ49$G$-$J$$J8;z$,%m!<%^;z%P%C%U%!$K;D$C$F(B */
778 /* $B$$$?$i!JNc!V$C!W$KJQ49$5$l$k>l9gEy!K(B */
779 /* $B$+$J%P%C%U%!$N:G8e$K$=$NJ8;z$rIUM?$9$k(B */
780 if (*seg->str != '\0') {
781 _Xsj3cInsertChar(buf, seg, seg->str, strlen(seg->str));
782 seg->sp = seg->str;
783 while (*seg->sp != '\0') {
784 seg->sp++;
785 seg->n_roma++;
786 }
787 change_roma = seg->n_roma;
788 } else {
789 seg->sp = seg->str;
790 }
791 } else if (seg->value == 0) {
792 /* $B%m!<%^$+$JJQ49$N8uJd$H$7$FL$Dj$N>l9g(B */
793 /* $B:G8e$NF~NOJ8;z$r%m!<%^"*$+$JJQ49MQ$N(B */
794 /* $B%P%C%U%!(B(seg->str)$B$K;D$9(B */
795
796 change_pos = seg->cur;
797 _Xsj3cInsertChar(buf, seg, seg->sp, n);
798 *seg->oldstr = '\0';
799 tmpsp = seg->str;
800 *seg->str = *seg->sp;
801 seg->sp = seg->str;
802 i = n;
803 while (i--)
804 *tmpsp++ = *seg->sp++;
805 *tmpsp = '\0';
806 seg->n_roma = n;
807 change_roma = seg->n_roma;
808 } else {
809 /* $B%m!<%^$+$JJQ49$N8uJd$H$7$FL58z$J>l9g(B */
810
811 _Xsj3cInsertChar(buf, seg, seg->sp, n);
812 *seg->oldstr = '\0';
813 seg->n_roma = 0;
814 *seg->str = '\0';
815 seg->sp = seg->str;
816
817 /* rkbell $B%j%=!<%9$,(B on $B$K@_Dj$5$l$F(B */
818 /* $B$$$k>l9g%Y%k$rLD$i$9(B */
819 if (buf->rkbell)
820 ret |= KEY_BELL;
821 change_roma = n;
822 }
823 }
824
825 /* AlphabetConversion $B%j%=!<%9$,(B on */
826 /* $B$@$C$?$iH>3Q%m!<%^;z$rA43Q%m!<%^;z$KJQ49$9$k(B */
827 if (buf->alphaconv && buf->inputmode != MODE_HKATA
828 && change_roma) {
829 _Xsj3cExtractChar(buf, seg, tmp1, change_roma);
830 _Xsj3cHAlphaToZKana(buf, tmp2, tmp1);
831 _Xsj3cInsertChar(buf, seg, tmp2, change_roma);
832 }
833 /* $B$+$JF~NO%b!<%I$G$J$$$H$-$O(B -1 */
834 seg->n_kana = -1;
835 } else {
836 return (KEY_NULL);
837 }
838 break;
839
840 case MODE_HALPHA:
841
842 /* $BH>3Q%"%k%U%!%Y%C%H(B $BF~NO%b!<%I$N>l9g(B */
843 if (IsKanaKey(ks))
844 return (KEY_BELL);
845 change_pos = seg->cur;
846 _Xsj3cInsertChar(buf, seg, seg->sp, n);
847 seg->sp = seg->str;
848 seg->n_roma = 0;
849 seg->n_kana = -1;
850 break;
851
852 case MODE_ZALPHA:
853
854 /* $BA43Q%"%k%U%!%Y%C%H(B $BF~NO%b!<%I$N>l9g(B */
855 if (IsKanaKey(ks))
856 return (KEY_BELL);
857 _Xsj3cHAlphaToZAlpha(buf, tmp1, seg->sp);
858 seg->sp = seg->str;
859 change_pos = seg->cur;
860 _Xsj3cInsertChar(buf, seg, tmp1, n);
861 seg->n_roma = 0;
862 seg->n_kana = -1;
863 break;
864
865 case MODE_SJIS:
866 case MODE_EUC:
867 case MODE_JIS:
868 case MODE_KUTEN:
869
870 /* $B%3!<%IF~NO%b!<%I$N>l9g(B */
871 tmpsp = seg->str;
872 while (*tmpsp != '\0') {
873 if (!isxdigit(*tmpsp)
874 || (buf->inputmode == MODE_KUTEN && !isdigit(*tmpsp)))
875 return (KEY_BELL);
876 tmpsp++;
877 }
878
879 /* $B%3!<%I"*$R$i$,$J!?A43Q%+%?%+%J!?5-9f!?4A;z$NJQ49$r9T$&(B */
880 if ((seg->value = _Xsj3cCodeConv(buf, seg->str,
881 kanabuf, buf->inputmode)) > 0) {
882
883 /* $B%3!<%IJQ49$K@.8y$7$?>l9g(B */
884 if (buf->alphaconv) {
885 /* AlphabetConversion $B%j%=!<%9$,(B on $B$@$C$?$i(B */
886 /* $BA43Q?t;z$rH>3Q?t;z$KJQ49$9$k(B */
887 _Xsj3cExtractChar(buf, seg, tmp1, seg->n_roma);
888 _Xsj3cZAlphaToHAlpha(buf, seg->oldstr, tmp1);
889 } else {
890 _Xsj3cExtractChar(buf, seg, seg->oldstr, seg->n_roma);
891 }
892 change_pos = seg->cur;
893 seg->oldlen = (strlen(kanabuf) + 1)/ sizeof(wchar);
894 _Xsj3cInsertChar(buf, seg, kanabuf, seg->oldlen);
895 seg->cursegmode = MODE_HIRA;
896 seg->n_roma = 0;
897 seg->sp = seg->str;
898 } else if (seg->value == 0) {
899
900 /* $B%3!<%IJQ49$N7k2L$,ITDj$N>l9g(B */
901 change_pos = seg->cur;
902 if (buf->alphaconv) {
903 /* AlphabetConversion $B%j%=!<%9$,(B on $B$@$C$?$i(B */
904 /* $BH>3Q?t;z$rA43Q?t;z$KJQ49$9$k(B */
905 _Xsj3cHAlphaToZKana(buf, tmp1, seg->sp);
906 _Xsj3cInsertChar(buf, seg, tmp1, n);
907 } else {
908 _Xsj3cInsertChar(buf, seg, seg->sp, n);
909 }
910 i = n;
911 while (i--) {
912 seg->n_roma++;
913 seg->sp++;
914 }
915 } else {
916
917 /* $B%3!<%IJQ49$N7k2L$,<:GT$N>l9g(B */
918 _Xsj3cExtractChar(buf, seg, tmp1, seg->n_roma);
919 change_pos = seg->cur;
920 seg->sp = seg->str;
921 seg->n_roma = 0;
922 if (seg->num == 0 && buf->convmode != DictModeMask) {
923 Xsj3cFreeSegment(seg);
924 seg = NULL;
925 buf->segnum--;
926 for (i = buf->curseg; i < buf->segnum; i++) {
927 buf->input[i] = buf->input[i + 1];
928 }
929 buf->input[buf->segnum] = NULL;
930 return ret;
931 }
932 if (buf->rkbell)
933 ret |= KEY_BELL;
934 }
935 seg->n_kana = -1;
936 break;
937
938 default:
939 Xsj3cWarning("Illegal current mode");
940 return (KEY_BELL);
941 }
942
943 /* $BI=<(MQJ8;zNs$X%3%T!<$9$k(B */
944 _Xsj3cStoreYomi(buf, seg, change_pos);
945 return ret;
946 }
947
948 /*
949 * _Xsj3cKanaConv()
950 * Kana input mode dispatch routine.
951 */
952 int
953 _Xsj3cKanaConv(buf, seg, hkana, zkana, mode)
954 Xsj3cBuf buf;
955 Xsj3cSeg seg;
956 unsigned char *hkana, *zkana;
957 Xsj3csMode mode;
958 {
959 register int len, zlen;
960 register wchar s;
961
962 if (mode == MODE_HIRA) {
963 if (buf->alphaconv)
964 _Xsj3cHankakuToHira(buf, zkana, hkana);
965 else
966 _Xsj3cHKataToHira(buf, zkana, hkana);
967 } else {
968 if (buf->alphaconv)
969 _Xsj3cHankakuToZKata(buf, zkana, hkana);
970 else
971 _Xsj3cHKataToZKata(buf, zkana, hkana);
972 }
973 len = 0;
974 while (*hkana != '\0') {
975 hkana++;
976 len++;
977 }
978 if (isdakuon(*(hkana - 1))) {
979 return 0;
980 } else {
981 zlen = 0;
982 while (*zkana != '\0') {
983 zkana++;
984 zlen++;
985 }
986 if (zlen > 1) {
987 s = (*(zkana - 2) << 8) + (*(zkana - 1) & 0xff);
988 if (seg->n_kana && (iszdakuten(s, serverIF[buf->server].lang)
989 || !isdakuten(*(hkana - 1))))
990 return -1;
991 else
992 return len;
993 } else {
994 return -1;
995 }
996 }
997 }
998
999 /*
1000 * _Xsj3cCodeConv()
1001 * Code input mode dispatch routine.
1002 */
1003 static int
1004 _Xsj3cCodeConv(buf, code, kanji, mode)
1005 Xsj3cBuf buf;
1006 register unsigned char *code;
1007 register unsigned char *kanji;
1008 Xsj3csMode mode;
1009 {
1010 register int i, j, len;
1011 register wchar k, (*conv)();
1012 register unsigned char c1, c2;
1013 unsigned char kbuf[4];
1014
1015 if ((len = strlen(code)) < 4 && (mode == MODE_EUC || mode == MODE_KUTEN))
1016 return CONV_UNFIXED;
1017 else if ((len < 2 || len == 3) && (mode == MODE_SJIS || mode == MODE_JIS))
1018 return CONV_UNFIXED;
1019
1020 k = 0;
1021 for (j = 0; j < 4 && *code != '\0'; code++, j++) {
1022 if (isdigit(*code))
1023 i = *code - '0';
1024 else if (islower(*code))
1025 i = 10 + *code - 'a';
1026 else if (isupper(*code))
1027 i = 10 + *code - 'A';
1028 else
1029 return CONV_FAILED;
1030 kbuf[j] = i;
1031 k += i << ((3 - j) * 4);
1032 }
1033 switch (mode) {
1034 case MODE_SJIS:
1035 if (len == 4 && issjis1(c1 = (k >> 8)) && issjis2(c2 = (k & 0xff))) {
1036 if (conv = CodeConvFunc[JP_SJIS][serverIF[buf->server].lang]) {
1037 k = conv(k);
1038 *kanji++ = k >> 8;
1039 *kanji++ = k & 0xff;
1040 *kanji = '\0';
1041 } else {
1042 *kanji++ = c1;
1043 *kanji++ = c2;
1044 *kanji = '\0';
1045 }
1046 } else if (iskana(k >> 8)) {
1047 *kanji++ = k >> 8;
1048 *kanji = '\0';
1049 } else {
1050 if (len < 4)
1051 return CONV_UNFIXED;
1052 else
1053 return CONV_FAILED;
1054 }
1055 break;
1056 case MODE_EUC:
1057 if (iseuc(k >> 8) && iseuc(k & 0xff)) {
1058 if (conv = CodeConvFunc[JP_EUC][serverIF[buf->server].lang])
1059 k = conv(k);
1060 *kanji++ = k >> 8;
1061 *kanji++ = k & 0xff;
1062 *kanji = '\0';
1063 } else if (iseuckana(k >> 8) && iskana2(k & 0xff)) {
1064 *kanji++ = k & 0xff;
1065 *kanji = '\0';
1066 } else {
1067 return CONV_FAILED;
1068 }
1069 break;
1070 case MODE_JIS:
1071 if (len == 4 && isjis(c1 = (k >> 8)) && isjis(c2 = (k & 0xff))) {
1072 if (conv = CodeConvFunc[JP_JIS8][serverIF[buf->server].lang]) {
1073 k = conv(k);
1074 *kanji++ = k >> 8;
1075 *kanji++ = k & 0xff;
1076 *kanji = '\0';
1077 } else {
1078 *kanji++ = c1;
1079 *kanji++ = c2;
1080 *kanji = '\0';
1081 }
1082 } else if (iskana(k >> 8)) {
1083 *kanji++ = k >> 8;
1084 *kanji = '\0';
1085 } else {
1086 if (len < 4)
1087 return CONV_UNFIXED;
1088 else
1089 return CONV_FAILED;
1090 }
1091 break;
1092 case MODE_KUTEN:
1093 conv = CodeConvFunc[JP_JIS8][serverIF[buf->server].lang];
1094 c1 = kbuf[0] * 10 + kbuf[1];
1095 c2 = kbuf[2] * 10 + kbuf[3];
1096 k = (c1 << 8) + c2;
1097 k = conv(k + 0x2020);
1098 if (iskan1(c1 = (k >> 8), serverIF[buf->server].lang)
1099 && iskan2(c2 = (k & 0xff), serverIF[buf->server].lang)) {
1100 *kanji++ = c1;
1101 *kanji++ = c2;
1102 *kanji = '\0';
1103 } else {
1104 return CONV_FAILED;
1105 }
1106 break;
1107 default:
1108 Xsj3cWarning("Illegal mode");
1109 return CONV_FAILED;
1110 }
1111
1112 return CONV_FIXED;
1113 }
1114
1115 #define MATCH 0
1116 #define NOT 1
1117
1118 /*
1119 * _Xsj3cRomaConv()
1120 * Get roman characters from the second argument and put back hiragana or
1121 * katakana characters to the third argument in conversion table.
1122 * If roman characters (third argument) mach with the "roma" entry in table,
1123 * put back the "str" entry to the third argument and the "yomi" entry
1124 * to the third argument, then it returns number of converted roman
1125 * characters.
1126 * If not but any letters of roman characters is match with the "roma"
1127 * entry in table and the number of roman characters is less than
1128 * the number of the letters of "roma" entry, put back the same to
1129 * the third argument and nothing to the third argument, then it returns
1130 * zero.
1131 * Then last (not converted case) it returns minus 1.
1132 * Any arguments must be null('\0') terminated.
1133 * First argument is pointer to conversion table;
1134 */
1135 int
1136 _Xsj3cRomaConv(rktable, roma, yomi)
1137 Xsj3cRKTable *rktable;
1138 register unsigned char *roma;
1139 register unsigned char *yomi;
1140 {
1141 Xsj3cRKTable *rktp;
1142 register unsigned char *p, *q;
1143 unsigned char tmp[RBUFSIZ];
1144 int match, result = CONV_FAILED;
1145 register int len;
1146
1147 if (!roma || (len = strlen(roma)) == 0)
1148 return (CONV_FAILED);
1149 for (rktp = rktable; rktp != NULL; rktp = rktp->next) {
1150 if (!rktp->roma) {
1151 continue;
1152 }
1153 p = roma;
1154 q = rktp->roma;
1155 if (len > rktp->rlen) {
1156 if (*q++ == *p++) {
1157 match = MATCH;
1158 while (*q != '\0') {
1159 if (*q != *p) {
1160 match = NOT;
1161 break;
1162 }
1163 q++;
1164 p++;
1165 }
1166 if (match == NOT) {
1167 continue;
1168 }
1169 if (result < 0) {
1170 result = rktp->rlen;
1171 strcpy(yomi, rktp->yomi);
1172 strcpy(tmp, p);
1173 } else {
1174 continue;
1175 }
1176 } else {
1177 continue;
1178 }
1179 } else {
1180 if (*p++ == *q++) {
1181 match = MATCH;
1182 while (*p != '\0') {
1183 if (*p++ != *q++) {
1184 match = NOT;
1185 break;
1186 }
1187 }
1188 if (match == NOT) {
1189 continue;
1190 }
1191 if (*q != '\0') {
1192 result = CONV_UNFIXED;
1193 continue;
1194 } else if (result == CONV_UNFIXED) {
1195 continue;
1196 } else {
1197 result = rktp->rlen;
1198 strcpy(yomi, rktp->yomi);
1199 strcpy(tmp, rktp->str);
1200 }
1201 } else {
1202 continue;
1203 }
1204 }
1205 }
1206 if (result > 0)
1207 strcpy(roma, tmp);
1208 return (result);
1209 }
1210
1211 /*
1212 * _Xsj3cCtrlConv()
1213 *
1214 * <NoInputMode> Through all control events.
1215 * <InputMode> Put the control code (now only HT & NL) after current position,
1216 * then fix all segments.
1217 * <ConvedMode> Put the control code (now only HT & NL) after current segment,
1218 * then fix all segments and end convertion.
1219 * <SelectMode/DictMode> Does Nothing.
1220 *
1221 * DisplayModeChange on: Change the display mode string.
1222 * ThroughNext code:
1223 * SetNormal code:
1224 */
1225 static Xsj3cEvent
1226 _Xsj3cCtrlConv(buf, code)
1227 Xsj3cBuf buf;
1228 unsigned char code;
1229 {
1230 unsigned char ch[2];
1231 register unsigned char *c;
1232 int change_pos;
1233 register int i;
1234
1235 if (code == '\t' || code == '\n')
1236 goto compound_text;
1237 if (buf->throughnext) {
1238 c = buf->throughnext;
1239 while (*c != '\0') {
1240 if (*c == code) {
1241 buf->throughflg = THROUGH;
1242 if (buf->dispmodechange) {
1243 buf->dispmode = buf->inputmode;
1244 #ifdef THROUGH_CONT
1245 return (KEY_TEXT_CLEAR|KEY_CONTROL|KEY_MODE_CHANGE);
1246 } else {
1247 return (KEY_TEXT_CLEAR|KEY_CONTROL);
1248 #else /* THROUGH_CONT */
1249 return (KEY_NULL);
1250 } else {
1251 return (KEY_NULL);
1252 #endif /* THROUGH_CONT */
1253 }
1254 }
1255 c++;
1256 }
1257 }
1258 if (buf->setnormal) {
1259 c = buf->setnormal;
1260 while (*c != '\0') {
1261 if (*c == code) {
1262 if (buf->dispmodechange) {
1263 buf->dispmode = buf->inputmode;
1264 #ifdef THROUGH_CONT
1265 return (KEY_TEXT_FIXED|KEY_CONTROL|KEY_HENKAN_END
1266 |KEY_MODE_CHANGE);
1267 } else {
1268 return (KEY_TEXT_FIXED|KEY_CONTROL|KEY_HENKAN_END);
1269 #else /* THROUGH_CONT */
1270 return (KEY_NULL);
1271 } else {
1272 return (KEY_NULL);
1273 #endif /* THROUGH_CONT */
1274 }
1275 }
1276 c++;
1277 }
1278 }
1279 /* Through all control events by XtNunusedEventCallback */
1280 return (KEY_NULL);
1281
1282 /* Push by compound text */
1283 compound_text:
1284 switch (buf->convmode) {
1285 case NoInputModeMask:
1286 buf->convmode = InputModeMask;
1287 case InputModeMask:
1288 if (buf->segnum == buf->curseg)
1289 buf->segnum++;
1290 ch[0] = code;
1291 ch[1] = '\0';
1292 change_pos = buf->input[buf->curseg]->cur;
1293 _Xsj3cInsertChar(buf, buf->input[buf->curseg], ch, 1);
1294 _Xsj3cStoreYomi(buf, buf->input[buf->curseg], change_pos);
1295 if (buf->dispmodechange) {
1296 buf->dispmode = buf->inputmode;
1297 return (KEY_TEXT_FIXED|KEY_TEXT_CHANGE|KEY_MODE_CHANGE);
1298 } else
1299 return (KEY_TEXT_FIXED|KEY_TEXT_CHANGE);
1300 case ConvedModeMask:
1301 i = buf->input[buf->curseg]->dnum;
1302 buf->input[buf->curseg]->disp[i++] = code;
1303 buf->input[buf->curseg]->disp[i] = '\0';
1304 buf->input[buf->curseg]->dnum++;
1305 if (buf->dispmodechange) {
1306 buf->dispmode = buf->inputmode;
1307 return (KEY_TEXT_FIXED|KEY_TEXT_CHANGE|KEY_MODE_CHANGE);
1308 } else
1309 return (KEY_TEXT_FIXED|KEY_TEXT_CHANGE);
1310 case DictModeMask:
1311 case SelectModeMask:
1312 default:
1313 return (KEY_NULL);
1314 }
1315 }
1316
1317 /*
1318 * _Xsj3cThrough()
1319 * Store characters to yomi/disp buffer and fix.
1320 */
1321 static Xsj3cEvent
1322 _Xsj3cThrough(buf, seg, n)
1323 Xsj3cBuf buf;
1324 Xsj3cSeg seg;
1325 int n;
1326 {
1327 int change_pos;
1328
1329 change_pos = seg->cur;
1330 _Xsj3cInsertChar(buf, seg, seg->str, n);
1331 _Xsj3cStoreYomi(buf, seg, change_pos);
1332 return (KEY_TEXT_FIXED);
1333 }
1334
1335 /*
1336 * _Xsj3cDirect()
1337 * Store characters to yomi/disp buffer.
1338 *
1339 * DisplayModeChange on: Change the display mode string.
1340 */
1341 static Xsj3cEvent
1342 _Xsj3cDirect(buf, seg, n)
1343 Xsj3cBuf buf;
1344 Xsj3cSeg seg;
1345 int n;
1346 {
1347 Xsj3cEvent ret = KEY_TEXT_CHANGE;
1348 int change_pos;
1349
1350 change_pos = seg->cur;
1351 _Xsj3cInsertChar(buf, seg, seg->str, n);
1352 _Xsj3cStoreYomi(buf, seg, change_pos);
1353 *seg->str = '\0';
1354 seg->sp = seg->str;
1355 *seg->oldstr = '\0';
1356 seg->oldlen = 0;
1357 seg->n_roma = 0;
1358 seg->n_kana = -1;
1359 if (buf->dispmodechange) {
1360 buf->dispmode = (buf->convedsegnum == buf->segnum ? MODE_KANJI :
1361 (buf->convedsegnum ? MODE_EDIT : buf->inputmode));
1362 ret |= KEY_MODE_CHANGE;
1363 }
1364 return (ret);
1365 }