1 /*
2 * Copyright (c) 1994 Sony Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining
5 * a copy of this software and associated documentation files (the
6 * "Software"), to deal in the Software without restriction, including
7 * without limitation the rights to use, copy, modify, merge, publish,
8 * distribute, sublicense, and/or sell copies of the Software, and to
9 * permit persons to whom the Software is furnished to do so, subject to
10 * the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be
13 * included in all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
18 * IN NO EVENT SHALL SONY CORPORATION BE LIABLE FOR ANY CLAIM,
19 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
20 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
21 * THE USE OR OTHER DEALINGS IN THE SOFTWARE.
22 *
23 * Except as contained in this notice, the name of Sony Corporation
24 * shall not be used in advertising or otherwise to promote the sale, use
25 * or other dealings in this Software without prior written authorization
26 * from Sony Corporation.
27 *
28 */
29
30 /*
31 * $SonyRCSfile: edit.c,v $
32 * $SonyRevision: 1.2 $
33 * $SonyDate: 1997/01/23 11:09:36 $
34 */
35
36
37
38 #include <stdlib.h>
39 #include <string.h>
40 #include "common.h"
41 #include "key.h"
42
43 #include "sj3.h"
44
45 static wchar16_t *jpoint;
46 static int iedit, jedit;
47 static int ilen, jlen;
48
49 void
push_obj(int i,int j)50 push_obj(int i, int j)
51 {
52 Conversion *cv;
53
54 cv = GetConversion ();
55 jpoint = cv->Ppoint[j];
56 ilen = cv->Plen[i];
57 jlen = cv->Plen[j];
58 iedit = cv->Bkettei[i];
59 jedit = cv->Bkettei[j];
60 }
61
62 void
pop_obj(int i,int j)63 pop_obj(int i, int j)
64 {
65 Conversion *cv;
66
67 cv = GetConversion ();
68 cv->Ppoint[j] = jpoint;
69 cv->Plen[i] = ilen;
70 cv->Plen[j] = jlen;
71 cv->Bkettei[i] = iedit;
72 cv->Bkettei[j] = jedit;
73 }
74
75
76
77 int
Bbig()78 Bbig()
79 {
80 Conversion *cv;
81 int i, j, k;
82 int moji, last, val;
83
84 cv = GetConversion ();
85 if (cv->CurBun < 0)
86 cv->CurBun = 0;
87 i = cv->CurBun;
88 j = i + 1;
89 while (j < cv->Bnum) {
90 if (cv->Plen[j] > 0) {
91 push_obj (i, j);
92
93 k = cv->Ppoint[j] - cv->Ppoint[0];
94 last = k + cv->Plen[j];
95 moji = 0;
96 for (; k < last; k++) {
97 if (k < last-1 &&(cv->out_mode[k+1]&OMODE_ZEN)){
98 moji += 2;
99 k++;
100 }else
101 moji++;
102 if (cv->out_mode[k+1] & OMODE_MASK)
103 break;
104 }
105 cv->Plen[i] += moji;
106 cv->Plen[j] -= moji;
107 cv->Ppoint[j] = cv->Ppoint[i] + cv->Plen[i];
108
109 cv->PreBun = j;
110
111 if (cv->Bkettei[i] & Bhenkan) {
112 val = Sdouon (0);
113
114 }
115 else {
116 cv->Bkettei[i] |= Bmuhenkan;
117 cv->Bkettei[i] &= ~Bhenkan;
118 cv->Bkettei[j] |= Bmuhenkan;
119 cv->Bkettei[j] &= ~Bhenkan;
120 val = 0;
121 }
122 if (!val) {
123 cv->Dflag = -1;
124 Rdisp ();
125 return (1);
126 }
127 break;
128 }
129 else
130 j ++;
131 }
132 beep ();
133 if (j < cv->Bnum)
134 pop_obj (i, j);
135 return (0);
136 }
137
138
139
140 int
Bsmall(int small)141 Bsmall(int small)
142 {
143 Conversion *cv;
144 int i, j, k, moji;
145 int val;
146
147 cv = GetConversion ();
148 if (cv->CurBun < 0)
149 cv->CurBun = 0;
150 i = cv->CurBun;
151 j = i + 1;
152 if (j <= cv->Bnum && cv->Plen[i] > 1) {
153 if (j == cv->Bnum) {
154 cv->Bnum ++;
155 cv->Bkettei[cv->Bnum] = Bend;
156 cv->Plen[j] = 0;
157 cv->Pkettei[j] = cv->Pkettei[i];
158 cv->Bkettei[j] |= Bmuhenkan;
159 cv->Bkettei[j] &= ~Bhenkan;
160 }
161 else if (small) {
162 while (j < cv->Bnum - 1 && cv->Plen[j] == 0)
163 j ++;
164 if (j == cv->Bnum)
165 j --;
166 }
167 else if (cv->Plen[j] != 0 && cv->Enum < MAXENUM) {
168 for (k = cv->Bnum ; k > j ; k --) {
169 cv->Plen[k] = cv->Plen[k - 1];
170 cv->Ppoint[k] = cv->Ppoint[k - 1];
171 cv->Pkettei[k] = cv->Pkettei[k - 1];
172
173 cv->Bpoint[k] = cv->Bpoint[k - 1];
174 cv->Bkettei[k] = cv->Bkettei[k - 1];
175
176 cv->Displen[k] = cv->Displen[k - 1];
177 cv->Dispmod[k] = cv->Dispmod[k - 1];
178
179 cv->Edit[k] = cv->Edit[k - 1];
180 }
181 cv->Bnum ++;
182 cv->Plen[j] = 0;
183 cv->Bkettei[j] = Bmuhenkan;
184 cv->Displen[j] = 0;
185 }
186 else if (cv->Plen[j] != 0) {
187 while (j < cv->Bnum - 1 && cv->Plen[j] == 0)
188 j ++;
189 if (j == cv->Bnum)
190 j --;
191 }
192 else {
193 while (j < cv->Bnum - 1 && cv->Plen[j] == 0 &&
194 cv->Plen[j+1] == 0)
195 j ++;
196 }
197
198 push_obj (i, j);
199
200 k = cv->Ppoint[i] - cv->Ppoint[0] + cv->Plen[i] - 1;
201 if (cv->out_mode[k] & OMODE_ZEN)
202 moji = 2;
203 else
204 moji = 1;
205 cv->Plen[i] -= moji;
206 cv->Plen[j] += moji;
207 cv->Ppoint[j] = cv->Ppoint[i] + cv->Plen[i];
208
209 if (cv->Plen[i] < 1) {
210 beep ();
211 pop_obj (i, j);
212 return(0);
213 }
214
215 cv->PreBun = j;
216
217 if (cv->Bkettei[i] & Bhenkan) {
218 val = Sdouon (0);
219
220 }
221 else {
222 cv->Bkettei[i] |= Bmuhenkan;
223 cv->Bkettei[i] &= ~Bhenkan;
224 cv->Bkettei[j] |= Bmuhenkan;
225 cv->Bkettei[j] &= ~Bhenkan;
226 val = 0;
227 }
228 if (!val) {
229 cv->Dflag = -1;
230 Rdisp ();
231 return (1);
232 }
233 beep ();
234 pop_obj (i, j);
235 }
236 else {
237 beep ();
238 }
239 return (0);
240 }
241
242
243
244 void
Bdelete()245 Bdelete()
246 {
247 Conversion *cv;
248 int i, j, deletelen, val;
249
250 cv = GetConversion ();
251 if (cv->CurBun < 0) {
252 cv->CurBun = 0;
253 return;
254 }
255 i = cv->CurBun;
256 j = i + 1;
257 if (j <= cv->Bnum && cv->Plen[i] > 0) {
258 while (j < cv->Bnum && cv->Plen[j] == 0)
259 j ++;
260 if (j == cv->Bnum) {
261 j = i - 1;
262 while (j >= 0 && cv->Plen[j] == 0)
263 j --;
264 if (j == -1)
265 j = i;
266 }
267
268 push_obj (i, j);
269
270 deletelen = cv->Plen[i];
271 cv->Plen[i] = 0;
272
273 cv->PreBun = i;
274 cv->CurBun = j;
275
276 val = Sdouon (0);
277 if (!val) {
278 cv->Dflag = -1;
279 Chain (i, deletelen);
280 Rdisp ();
281 if (i == j)
282 all_set_up ();
283 } else {
284 beep ();
285 pop_obj (i, j);
286 }
287 }
288 else {
289 beep ();
290 all_set_up ();
291 }
292 }
293
294
295
296 void
Chain(int n,int len)297 Chain(int n, int len)
298 {
299 Conversion *cv;
300 int i;
301 wchar16_t *p;
302 u_short *pp;
303 int mlen, plen, ipos, rlen, imlen;
304
305 cv = GetConversion ();
306 if (cv->Ppoint[n+1] == 0)
307 return;
308 /*
309 * Remove warning.
310 * Patched by Hidekazu Kuroki(hidekazu@cs.titech.ac.jp) 1996/8/10
311 */
312 mlen = strlen ((char *)cv->Ppoint[n+1]);
313 plen = cv->Ppoint[n] - cv->Ppoint[0];
314 p = cv->Ppoint[n];
315 pp = &cv->out_mode[plen];
316 ipos = getipos(plen);
317 if (cv->Ppoint[n+1] > cv->Ppoint[0])
318 rlen = getipos(cv->Ppoint[n+1] - cv->Ppoint[0]) - ipos;
319 else
320 rlen = 0;
321 imlen = 0;
322 for (i = 0 ; i < mlen ; i ++) {
323 p[i] = p[i+len];
324 pp[i] = pp[i+len];
325 imlen += pp[i] & OMODE_MASK;
326 }
327 p[mlen] = '\0';
328 cv->out_point -= len;
329
330 p = &cv->Halpha[ipos];
331 for (i = 0; i < imlen; i++)
332 p[i] = p[i+rlen];
333 p[imlen] = '\0';
334 cv->ha_point -= rlen;
335
336 for (i = n + 1 ; i < cv->Bnum ; i ++)
337 cv->Ppoint[i] -= len;
338
339 }
340
341 static int Elimit;
342 static int Ehlimit;
343 int
exec_edit()344 exec_edit()
345 {
346 Conversion *cv;
347 int edit, inc, i;
348 wchar16_t *s;
349 wchar16_t Htmp[BUFFLENGTH], Ztmp[BUFFLENGTH * 2];
350 u_short Omode[BUFFLENGTH * 2];
351 int bun;
352 int edited, editlen;
353 int len, rlen, hlen, diff;
354 int Zcol, cur, icur, res, ncur;
355 wchar16_t number[3];
356 wchar16_t tmp[3];
357 int num, numpoint;
358
359 cv = GetConversion ();
360 bun = cv->CurBun;
361 len = load_bun2(bun, Htmp, Ztmp, Omode);
362 rlen = wslen(Htmp);
363 if (len > DLEN) {
364 guide_print_pause(WCGedit, WCTooLong);
365 return(0);
366 }
367 TopGuide ();
368 spaceR (WCGedit);
369 SJ_print (Ztmp);
370 Clear_EOL ();
371 backspace (wcbyte (Ztmp));
372 Zcol = 0;
373 Flush ();
374
375
376 cur = cv->Ppoint[bun] - cv->Ppoint[0];
377 ncur = cur + cv->Plen[bun];
378 s = cv->Ppoint[bun];
379 s += cv->Plen[bun];
380 res = wslen(s);
381 i = BUFFLENGTH * 2 - res - cur - 1;
382 if (i < DLEN)
383 Elimit = i;
384 else
385 Elimit = DLEN;
386 i = BUFFLENGTH - wslen(cv->Halpha) + rlen - 1;
387 if (i < DLEN)
388 Ehlimit = i;
389 else
390 Ehlimit = DLEN;
391 edited = 0;
392 edit = 1;
393 numpoint = 0;
394 SaveConversion ();
395 while (edit) {
396 inc = inkey ();
397 cv = GetConversion ();
398 if (AnotherConversion ()) {
399 unget_key (inc);
400 edited = 0;
401 break;
402 }
403 if (keyvalue == KEY_CONV)
404 return (0);
405 if (keyvalue == KEY_HENKAN || keyvalue == KEY_KETTEI)
406 break;
407 else if (keyvalue == KEY_UP)
408 inc = 'a';
409 else if (keyvalue == KEY_DOWN)
410 inc = 'i';
411 else if (keyvalue == KEY_RIGHT)
412 inc = 'l';
413 else if (keyvalue == KEY_LEFT)
414 inc = 'h';
415 switch (inc) {
416 case EOF:
417 case ESC:
418 edit = 0;
419 break;
420 case 'l':
421 case ' ':
422 num = getnum (number, &numpoint);
423 if (Zcol >= len - 1) {
424 beep ();
425 break;
426 }
427 for (i = 0 ; i < num && Zcol < len - 1 ; i++) {
428 tmp[0] = Ztmp[Zcol];
429 tmp[1] = 0;
430 SJ_print(tmp);
431 Zcol ++;
432 }
433 Flush ();
434 break;
435 case 'h':
436 case BS:
437 num = getnum (number, &numpoint);
438 if (Zcol <= 0) {
439 beep ();
440 break;
441 }
442 for (i = 0 ; i < num && Zcol >= 1 ; i ++)
443 backspace(2);
444 Zcol -= 1;
445 Flush ();
446 break;
447 case '\014':
448 case '$':
449 num = getnum (number, &numpoint);
450 if (len <= 0)
451 break;
452 Zcol = len - 1;
453 TopGuide ();
454 spaceR (WCGedit);
455 SJ_print (Ztmp);
456 Clear_EOL ();
457 backspace (2);
458 Flush ();
459 break;
460 case 'a':
461 if (len >= 1) {
462 tmp[0] = Ztmp[Zcol];
463 tmp[1] = 0;
464 SJ_print (tmp);
465 Zcol ++;
466 Flush ();
467 }
468
469 case 'i':
470 num = getnum (number, &numpoint);
471 if (editlen = Insert(Htmp, Ztmp, Omode, Zcol)) {
472 len += editlen;
473 Zcol += editlen;
474 edited = 1;
475 }
476 if (Zcol >= 1) {
477 backspace(2);
478 Zcol -= 1;
479 }
480 Print_EOL (&Ztmp[Zcol]);
481 Flush ();
482 break;
483 case DEL:
484 case 'x':
485 num = getnum (number, &numpoint);
486 if (len <= 0) {
487 beep ();
488 break;
489 }
490 len -= EditDel (Htmp, Ztmp, Omode, Zcol, num);
491 if (Zcol >= len && Zcol >= 1) {
492 backspace(2);
493 Zcol -= 1;
494 }
495 Print_EOL (&Ztmp[Zcol]);
496 Flush ();
497 edited = 1;
498 break;
499 case 'r':
500 num = getnum (number, &numpoint);
501 if (len <= 0) {
502 beep ();
503 break;
504 }
505 i = Replace(Htmp, Ztmp, Omode, Zcol, num);
506 if (i > 0) {
507 i -= 1;
508 Zcol += i;
509 backspace(2);
510 edited = 1;
511 }
512 Print_EOL (&Ztmp[Zcol]);
513 Flush ();
514 break;
515 case 's':
516 num = getnum (number, &numpoint);
517 if (len <= 0) {
518 beep ();
519 break;
520 }
521 if (editlen = Substitute(Htmp,Ztmp,Omode,&Zcol,num)) {
522 len += editlen;
523 }
524 if (Zcol >= 1) {
525 backspace(2);
526 Zcol -= 1;
527 }
528 Print_EOL (&Ztmp[Zcol]);
529 Flush ();
530 edited = 1;
531 break;
532 case '0':
533 if (numpoint == 0) {
534 num = getnum (number, &numpoint);
535 TopGuide ();
536 spaceR (WCGedit);
537 Flush ();
538 Zcol = 0;
539 break;
540 }
541
542 default:
543 if (iswdigit (inc)) {
544 if (numpoint > 1) {
545
546
547 number[0] = number[1];
548 number[1] = inc;
549 }
550 else
551 number[numpoint ++] = inc;
552 }
553 else {
554 num = getnum (number, &numpoint);
555 beep ();
556 }
557 break;
558 }
559 }
560
561 if (edited) {
562 for (i = 0; i < res; i++) {
563 Ztmp[i + len] = *s++;
564 Omode[i + len] = cv->out_mode[i + ncur];
565 }
566 res += len;
567 s = cv->Ppoint[bun];
568 for (i = 0; i < res; i++) {
569 *s++ = Ztmp[i];
570 cv->out_mode[i + cur] = Omode[i];
571 }
572 *s = '\0';
573 hlen = wslen(Htmp);
574 icur = getipos(cur);
575 s = &cv->Halpha[icur];
576 s += rlen;
577 if (*s)
578 wscat (Htmp, s);
579 wscpy (&cv->Halpha[icur], Htmp);
580 if ((diff = len - cv->Plen[bun]) != 0) {
581 cv->Plen[bun] = len;
582 cv->out_point += diff;
583 cv->out_epoint += diff;
584 for (i = bun + 1 ; i < cv->Bnum ; i ++)
585 cv->Ppoint[i] += diff;
586 }
587 if ((diff = hlen - rlen) != 0) {
588 cv->ha_point += diff;
589 cv->ha_epoint += diff;
590 }
591 if ((i = cv->Bpoint[bun]) < (unsigned int)cv->Bpoint[0])
592 i = cv->span_point;
593 cv->kettei[i - 1] = MODE_ZHIRA;
594 cv->Pedited[bun] = 1;
595 cv->Dflag = -1;
596 return (1);
597 }
598 return (0);
599 }
600
601 int
getnum(wchar16_t number[],int * numpoint)602 getnum(wchar16_t number[], int *numpoint)
603 {
604 char temp[3];
605 int i=0;
606
607 if (*numpoint == 0)
608 return (1);
609 number[*numpoint] = '\0';
610 *numpoint = 0;
611 do {
612 temp[i] = WcLowByte(number[i]);
613 } while (number[i++] != 0) ;
614
615 return (atoi (temp));
616 }
617
618 int
Replace(wchar16_t * Hs,wchar16_t * Zs,u_short * omode,int cur,int num)619 Replace(wchar16_t *Hs, wchar16_t *Zs, u_short *omode, int cur, int num)
620 {
621 int i, len, inc;
622 int beep_on, icur1, icur2;
623 wchar16_t roma[SHORTBUFFSIZE+1], kana[SHORTBUFFSIZE+1];
624 wchar16_t work[DLEN+1];
625 u_short otmp[SHORTBUFFSIZE+1];
626
627 *roma = '\0';
628 *kana = '\0';
629 SaveConversion(GetConversion());
630 while (1) {
631 inc = inkey();
632 if (AnotherConversion(GetConversion())) {
633 unget_key(inc);
634 *kana = '\0';
635 break;
636 }
637 len = wslen(roma);
638 if (inc == ESC) {
639 if (len > 0)
640 (void)exec_romaji2(0, roma, kana, otmp,
641 wslen(kana), len);
642 break;
643 }
644 if (iswcntrl(inc) && !(len > 0 && is_bs(inc))) {
645 beep();
646 *kana = '\0';
647 break;
648 }
649 if (exec_romaji2(inc, roma, kana, otmp, wslen(kana), len))
650 break;
651 }
652 sj3_rkclear();
653 if ((len = wslen(kana)) <= 0)
654 return(0);
655 if (kana[2] != '\0') {
656 beep_on = 1;
657 *otmp = sj_zentohan(roma, kana, 2);
658 kana[2] = '\0';
659 } else
660 beep_on = 0;
661 backspace(wcbyte(kana));
662 len = wslen(&Zs[cur]);
663 if (num <= 0)
664 num = 2;
665 if (!(omode[cur] & OMODE_MASK))
666 chhstr(Hs, Zs, omode, cur);
667 icur1 = getipos2(omode, cur);
668 if (len <= num) {
669 num = len;
670 *work = '\0';
671 } else {
672 if (!(omode[cur + num] & OMODE_MASK))
673 chhstr(Hs, Zs, omode, cur + num);
674 icur2 = getipos2(omode, cur + num);
675 wscpy(work, &Hs[icur2]);
676 }
677 Hs[icur1] = '\0';
678 for (i = 0; i < num; i += 2) {
679 SJ_print(kana);
680 Zs[cur] = kana[0];
681 omode[cur++] = otmp[0];
682 Zs[cur] = kana[1];
683 omode[cur++] = otmp[1];
684 wscat(Hs, roma);
685 }
686 Flush();
687 wscat(Hs, work);
688 if (beep_on)
689 beep();
690 return(num);
691 }
692
693
694 int
Substitute(wchar16_t * Hs,wchar16_t * Zs,u_short * omode,int * cur,int num)695 Substitute(wchar16_t *Hs, wchar16_t *Zs, u_short *omode, int *cur, int num)
696 {
697 wchar16_t work[DLEN + 1];
698 wchar16_t work2[DLEN + 1];
699 int len;
700
701 len = wslen(&Zs[*cur]);
702 if (len < num)
703 num = len;
704
705 Strncpy (work, &Zs[*cur], num - 1);
706 work[num - 1] = '\0';
707 wscpy(work2, work);
708 wscat(work2, WCDollar);
709 SJ_print (work2);
710 backspace (wcbyte(&Zs[*cur]));
711
712 Flush ();
713 (void)EditDel(Hs, Zs, omode, *cur, num);
714 if (len = Insert(Hs, Zs, omode, *cur))
715 *cur += len;
716 len -= num;
717 return (len);
718 }
719
720 int
Insert(wchar16_t * Hs,wchar16_t * Zs,u_short * omode,int cur)721 Insert(wchar16_t *Hs, wchar16_t *Zs, u_short *omode, int cur)
722 {
723 int inc, len, i;
724 int limit, hlimit, ylen, res, icur, rlen;
725 wchar16_t ztmp[DLEN + 1], htmp[DLEN + 1];
726 u_short otmp[DLEN + 1];
727
728 ylen = wslen(Zs);
729 limit = Elimit - ylen;
730 /*
731 * Remove warning.
732 * Patched by Hidekazu Kuroki(hidekazu@cs.titech.ac.jp) 1996/8/10
733 */
734 hlimit = Ehlimit - strlen((char *)Hs);
735 *ztmp = '\0';
736 *htmp = '\0';
737 SaveConversion (GetConversion ());
738 while (1) {
739 inc = inkey ();
740 if (AnotherConversion (GetConversion ())) {
741 unget_key (inc);
742 sj3_rkclear();
743 return(0);
744 }
745 if (inc == ESC)
746 break;
747 if (iswcntrl(inc) && !is_bs(inc))
748 beep ();
749 else if (((len = wslen(ztmp)) >= limit ||
750 (rlen = wslen(htmp)) >= hlimit) && !is_bs(inc))
751 beep();
752 else
753 (void)exec_romaji2(inc, htmp, ztmp, otmp, len, rlen);
754 }
755 /*
756 * Remove warning.
757 * Patched by Hidekazu Kuroki(hidekazu@cs.titech.ac.jp) 1996/8/10
758 */
759 (void)exec_romaji2(0, htmp, ztmp, otmp, strlen((char *)ztmp), strlen((char *)htmp));
760 sj3_rkclear();
761 len = wslen (ztmp);
762 backspace(wcbyte(ztmp));
763 SJ_print(ztmp);
764 Flush();
765 if (len) {
766 if (!(omode[cur] & OMODE_MASK))
767 chhstr(Hs, Zs, omode, cur);
768 icur = getipos2(omode, cur);
769 res = ylen - cur;
770 for (i = 0; i < res; i++) {
771 ztmp[i + len] = Zs[i + cur];
772 otmp[i + len] = omode[i + cur];
773 }
774 res += len;
775 for (i = 0; i < res; i++) {
776 Zs[i + cur] = ztmp[i];
777 omode[i + cur] = otmp[i];
778 }
779 Zs[i + cur] = '\0';
780 wscat(htmp, &Hs[icur]);
781 wscpy(&Hs[icur], htmp);
782 }
783 return (len);
784 }
785
786 int
EditDel(wchar16_t * Hs,wchar16_t * Zs,u_short * omode,int cur,int num)787 EditDel(wchar16_t *Hs, wchar16_t *Zs, u_short *omode, int cur, int num)
788 {
789 int i, j;
790 int icur, len, rlen;
791
792 if (!(omode[cur] & OMODE_MASK))
793 chhstr(Hs, Zs, omode, cur);
794 len = wslen(&Zs[cur]);
795 icur = getipos2(omode, cur);
796 if (len < num) {
797 Zs[cur] = '\0';
798 Hs[icur] = '\0';
799 } else {
800 if (!(omode[cur + num] & OMODE_MASK))
801 chhstr(Hs, Zs, omode, cur + num);
802 rlen = getipos2(omode, cur + num) - icur;
803 j = len - num + cur;
804 for (i = cur; i < j; i++) {
805 Zs[i] = Zs[i + num];
806 omode[i] = omode[i + num];
807 }
808 Zs[i] = '\0';
809 j = wslen(Hs) - rlen;
810 for (i = icur; i < j; i++)
811 Hs[i] = Hs[i + rlen];
812 Hs[i] = '\0';
813 len = num;
814 }
815 return (len);
816 }
817
818 int
chhstr(wchar16_t * Hs,wchar16_t * Zs,u_short * omode,int cur)819 chhstr(wchar16_t *Hs, wchar16_t *Zs, u_short *omode, int cur)
820 {
821 int i, j, len;
822 int prep, nextp;
823 int hprep, hnextp;
824 wchar16_t hkana[BUFFLENGTH], *hkp;
825
826 len = wslen(Zs);
827 prep = cur;
828 hprep = getipos2(omode, prep);
829 nextp = cur + 1;
830 hnextp = getipos2(omode, nextp);
831 hkp = hkana;
832 for(i = prep; i < nextp; i++) {
833 if (i < nextp - 1 && (WcIsZENKAKU(Zs[i]))) {
834 j = sj_zentohan(hkp, &Zs[i], 1);
835 hkp += j;
836 omode[i] = j;
837 } else {
838 *hkp++ = Zs[i];
839 omode[i] = 1;
840 }
841 }
842 wscpy(hkp, &Hs[hnextp]);
843 wscpy(&Hs[hprep], hkana);
844 }
845
846 void
Print_EOL(wchar16_t * s)847 Print_EOL(wchar16_t *s)
848 {
849 if (*s != '\0')
850 SJ_print (s);
851 Clear_EOL ();
852 if (*s != '\0')
853 backspace (wcbyte (s));
854 }
855
856 void
backspace(int n)857 backspace(int n)
858 {
859 int i;
860
861 for (i = 0 ; i < n ; i ++)
862 Backspace ();
863 }
864