1 /* Copyright 1992 NEC Corporation, Tokyo, Japan.
2 *
3 * Permission to use, copy, modify, distribute and sell this software
4 * and its documentation for any purpose is hereby granted without
5 * fee, provided that the above copyright notice appear in all copies
6 * and that both that copyright notice and this permission notice
7 * appear in supporting documentation, and that the name of NEC
8 * Corporation not be used in advertising or publicity pertaining to
9 * distribution of the software without specific, written prior
10 * permission. NEC Corporation makes no representations about the
11 * suitability of this software for any purpose. It is provided "as
12 * is" without express or implied warranty.
13 *
14 * NEC CORPORATION DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
15 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
16 * NO EVENT SHALL NEC CORPORATION BE LIABLE FOR ANY SPECIAL, INDIRECT OR
17 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
18 * USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
19 * OTHER TORTUOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
20 * PERFORMANCE OF THIS SOFTWARE.
21 */
22
23 /* filedef
24
25 util.c -- �桼�ƥ���ƥ��ؿ������
26
27 �ʲ��δؿ������롣(�ɲä����ͤϤ����Ƚ��Ȥ��Ƥ�)
28
29 GlineClear �����ɥ饤���ä����褦�ʥ�����ͤ���
30 Gline2echostr �����ɥ饤����֤����Ȥ�����Τ��ξ���֤�
31 echostrClear ���ξ줬�����ä����褦�ʥ�����ͤ���
32 checkGLineLen �����ɥ饤���ɽ��������뤫�ɤ����Υ����å�
33 NothingChanged �����Ѳ����ʤ����Ȥ���������ͤ���
34 NothingForGLine �����ɥ饤��˴ؤ��Ƥϲ����Ѳ����ʤ�
35 NothingChangedWithBeep
36 NothingChange ���Ƥ���˥ӡ��ײ����Ĥ餹
37 NothingForGLineWithBeep
38 NothingForGLine ���Ƥ���˥ӡ��ײ����Ĥ餹
39 CannaBeep �ӡ��ײ���ʤ餹��
40 makeGLineMessage ������ʸ�����GLine��ɽ������褦�ʥ�����ͤ���
41 makeGLineMessageFromString
42 ������eucʸ�����GLine��ɽ������褦�ʥ�����ͤ���
43 setWStrings ʸ������ν������Ԥ�
44 NoMoreMemory ���꤬�ʤ����饨�顼����Ȥ������顼�ͤ��֤�
45 GLineNGReturn ���顼��å����������ɥ饤��˰ܤ�
46 GLineNGReturnFI �����⡼�ɤ�ȴ���� GLineNGReturn ���롣
47 GLineNGReturnTK ��Ͽ�⡼�ɤ�ȴ���� GLineNGReturn ���롣
48 WStrlen �磻�ɥ���饯��ʸ�����Ĺ������� (cf. strlen)
49 WStrcat �磻�ɥ���饯��ʸ�����ä��롣(cf. strcat)
50 WStrcpy �磻�ɥ���饯��ʸ������ԡ����롣(cf. strcpy)
51 WStrncpy �磻�ɥ���饯��ʸ������ʸ�����ԡ����롣(cf. strncpy)
52 WStraddbcpy �磻�ɥ���饯��ʸ��������ʸ�������֡��Хå�����å���
53 �����˥Хå�����å��������ʤ��饳�ԡ����롣
54 WStrcmp �磻�ɥ���饯��ʸ�������Ӥ��롣(cf. strcmp)
55 WStrncmp �磻�ɥ���饯��ʸ������ʸ����Ӥ��롣(cf. strncmp)
56 WWhatGPlain �磻�ɥ���饯����ʸ����°���륰��ե��å��ץ졼����֤�
57 WIsG0 G0�Υ磻�ɥ���饯��ʸ������
58 WIsG1 G1�Υ磻�ɥ���饯��ʸ������
59 WIsG2 G2�Υ磻�ɥ���饯��ʸ������
60 WIsG3 G3�Υ磻�ɥ���饯��ʸ������
61 CANNA_mbstowcs EUC ��磻�ɥ���饯��ʸ������Ѵ�
62 CNvW2E �磻�ɥ���饯���� EUC ���Ѵ�(�����å��դ�)
63 CANNA_wcstombs �磻�ɥ���饯���� EUC ���Ѵ�
64 WSfree WString�dz��ݤ����ΰ��������
65 WString EUC ��磻�ɤ��Ѵ����� malloc �ޤǤ����֤�(free ����)
66 WStringOpen �嵭�ؿ��ν��������
67 WStringClose �嵭�ؿ��ν�λ����
68 WToupper ������ʸ������ʸ���ˤ���
69 WTolower ������ʸ����ʸ���ˤ���
70 key2wchar �����ܡ������Ϥ�磻�ɥ���饯���ˤ��롣
71 US2WS Ushort �� wchar_t ���Ѵ����롣
72 WS2US wchar_t �� Ushort ���Ѵ����롣
73 confirmContext yc->context ���Ȥ����Τ���ǧ����
74 makeRkError Rk �δؿ��ǥ��顼���Ǥ��Ȥ��ν������롣
75 canna_alert ��å������� Gline �˽��� key ���Ԥġ�
76
77 */
78
79 #if !defined(lint) && !defined(__CODECENTER__)
80 static char rcs_id[] = "@(#) 102.1 $Id: util.c,v 1.6 2003/09/17 08:50:53 aida_s Exp $";
81 #endif /* lint */
82
83 #include "canna.h"
84 #include <errno.h>
85
86 #ifdef luna88k
87 extern int errno;
88 #endif
89
90 /*********************************************************************
91 * wchar_t replace begin *
92 *********************************************************************/
93 #ifdef wchar_t
94 # error "wchar_t is already defined"
95 #endif
96 #define wchar_t cannawc
97
98 /* arraydef
99
100 tmpbuf -- ����äȲ��˻Ȥ���Хåե�
101
102 */
103
104 /*
105 * Gline ���ꥢ����
106 *
107 * ������ uiContext
108 * ����� �ʤ�
109 */
110 void
GlineClear(d)111 GlineClear(d)
112 uiContext d;
113 {
114 d->kanji_status_return->info |= KanjiGLineInfo;
115 d->kanji_status_return->gline.line = (wchar_t *)NULL;
116 d->kanji_status_return->gline.length = 0;
117 d->kanji_status_return->gline.revPos = 0;
118 d->kanji_status_return->gline.revLen = 0;
119 }
120
121 /* cfuncdef
122
123 Gline2echostr -- �����Ԥ����Ƥ��ξ�˰�ư
124
125 */
126
127 static void
Gline2echostr(d)128 Gline2echostr(d)
129 uiContext d;
130 {
131 d->kanji_status_return->echoStr =
132 d->kanji_status_return->gline.line;
133 d->kanji_status_return->length =
134 d->kanji_status_return->gline.length;
135 d->kanji_status_return->revPos =
136 d->kanji_status_return->gline.revPos;
137 d->kanji_status_return->revLen =
138 d->kanji_status_return->gline.revLen;
139 GlineClear(d);
140 }
141
142 void
echostrClear(d)143 echostrClear(d)
144 uiContext d;
145 {
146 d->kanji_status_return->echoStr = (wchar_t *)NULL;
147 d->kanji_status_return->length =
148 d->kanji_status_return->revPos = d->kanji_status_return->revLen = 0;
149 }
150
151 /*
152 * ʸ�����饳��������ü����ؿ�
153 */
154
155 static
colwidth(s,len)156 colwidth(s, len)
157 wchar_t *s;
158 int len;
159 {
160 int ret = 0;
161 wchar_t *es = s + len;
162
163 for (; s < es ; s++) {
164 switch (WWhatGPlain(*s)) {
165 case 0:
166 case 2:
167 ret ++;
168 break;
169 case 1:
170 case 3:
171 ret += 2;
172 break;
173 }
174 }
175 return ret;
176 }
177
178
179 /* cfuncdef
180
181 checkGLineLen -- �����Ԥ�ɽ���Ǥ���Ĺ����ۤ��Ƥ��뤫������å�
182
183 Ĺ�����ۤ��Ƥ����顢����������ʬ��ɽ�������褦�ˤ��롣
184
185 */
186
checkGLineLen(d)187 checkGLineLen(d)
188 uiContext d;
189 {
190 if (d->kanji_status_return->info & KanjiGLineInfo) {
191 if (colwidth(d->kanji_status_return->gline.line,
192 d->kanji_status_return->gline.length) > d->ncolumns) {
193 Gline2echostr(d);
194 return -1;
195 }
196 }
197 return 0;
198 }
199
200 /* cfuncdef
201
202 NothingChanged -- �ɤߤˤĤ��Ƥϲ����Ѥ��ʤ��褦�ˤ���
203
204 */
205
NothingChanged(d)206 NothingChanged(d)
207 uiContext d;
208 {
209 d->kanji_status_return->length = -1; /* �Ѥ��ʤ��� */
210 d->kanji_status_return->revPos
211 = d->kanji_status_return->revLen = 0;
212 d->kanji_status_return->info = 0;
213 return 0;
214 }
215
NothingForGLine(d)216 NothingForGLine(d)
217 uiContext d;
218 {
219 d->kanji_status_return->length = -1; /* �Ѥ��ʤ��� */
220 d->kanji_status_return->revPos
221 = d->kanji_status_return->revLen = 0;
222 return 0;
223 }
224
225 void
CannaBeep()226 CannaBeep()
227 {
228 extern int (*jrBeepFunc) pro((void));
229
230 if (jrBeepFunc) {
231 jrBeepFunc();
232 }
233 }
234
NothingChangedWithBeep(d)235 NothingChangedWithBeep(d)
236 uiContext d;
237 {
238 CannaBeep();
239 return NothingChanged(d);
240 }
241
NothingForGLineWithBeep(d)242 NothingForGLineWithBeep(d)
243 uiContext d;
244 {
245 CannaBeep();
246 return NothingForGLine(d);
247 }
248
249 #ifdef SOMEONE_USE_THIS
250 /* ï��ȤäƤ��ʤ��ߤ����� */
Insertable(ch)251 Insertable(ch)
252 unsigned char ch;
253 {
254 if ((0x20 <= ch && ch <= 0x7f) || (0xa0 <= ch && ch <= 0xff)) {
255 return 1;
256 }
257 else {
258 return 0;
259 }
260 }
261 #endif /* SOMEONE_USE_THIS */
262
263 extern extractJishuString pro((yomiContext, wchar_t *, wchar_t *,
264 wchar_t **, wchar_t **));
265
266 /*
267 extractSimpleYomiString -- yomiContext ���ɤ���ʬ��������Ф�
268
269 ����
270 yc -- yomiContext
271 s -- ���Ф���Υ��ɥ쥹
272 e -- ������ۤ��Ƽ��Ф��ƤϤʤ�ʤ����ȸ������ɥ쥹
273 sr -- ȿž�ΰ�γ��ϰ��֤��֤����ɥ쥹
274 er -- ȿž�ΰ�ν�λ���֤��֤����ɥ쥹
275 pat -- pointer to an attribute buffer.
276 focused -- indicates yc is focused or not
277 */
278
279 static int extractSimpleYomiString
280 pro((yomiContext, wchar_t *, wchar_t *, wchar_t **, wchar_t **,
281 wcKanjiAttributeInternal *, int));
282
283 static int
extractSimpleYomiString(yc,s,e,sr,er,pat,focused)284 extractSimpleYomiString(yc, s, e, sr, er, pat, focused)
285 yomiContext yc;
286 wchar_t *s, *e, **sr, **er;
287 wcKanjiAttributeInternal *pat;
288 int focused;
289 {
290 int len = yc->kEndp - yc->cStartp;
291
292 if (yc->jishu_kEndp) {
293 int len = extractJishuString(yc, s, e, sr, er);
294 char target = focused ?
295 CANNA_ATTR_TARGET_NOTCONVERTED : CANNA_ATTR_CONVERTED;
296 if (pat && pat->sp + len < pat->ep) {
297 char *ap = pat->sp, *ep = ap + len;
298 char *mp1 = ap + (*sr - s), *mp2 = ap + (*er - s);
299 while (ap < mp1) {
300 *ap++ = CANNA_ATTR_INPUT;
301 }
302 while (ap < mp2) {
303 *ap++ = target;
304 }
305 while (ap < ep) {
306 *ap++ = CANNA_ATTR_INPUT;
307 }
308 pat->sp = ap;
309 }
310 return len;
311 }
312
313 if (s + len >= e) {
314 len = (int)(e - s);
315 }
316 WStrncpy(s, yc->kana_buffer + yc->cStartp, len);
317 if (pat && pat->sp + len < pat->ep) {
318 char *ap = pat->sp, *ep = ap + len;
319
320 if (focused) {
321 pat->u.caretpos = (ap - pat->u.attr) + yc->kCurs - yc->cStartp;
322 /* �嵭�η��β���: �����åȤΰ��֤ϡ�����������ߤ��褦��
323 ���Ƥ�����֤�������Фǡ�������yc->kCurs - yc->cStartp �ΰ�
324 �֤Ǥ��롣 */
325 }
326
327 while (ap < ep) {
328 *ap++ = CANNA_ATTR_INPUT;
329 }
330 pat->sp = ap;
331 }
332 if (cannaconf.ReverseWidely) {
333 *sr = s;
334 *er = s + yc->kCurs - yc->cStartp;
335 }
336 else if (yc->kCurs == yc->kEndp && !yc->right) {
337 *sr = *er = s + yc->kCurs - yc->cStartp;
338 }
339 else {
340 *sr = s + yc->kCurs - yc->cStartp;
341 *er = *sr + 1;
342 }
343 return len;
344 }
345
346 /*
347 extractKanjiString -- yomiContext �δ����������Ф�
348
349 ����
350 yc -- yomiContext
351 s -- ���Ф���Υ��ɥ쥹
352 e -- ������ۤ��Ƽ��Ф��ƤϤʤ�ʤ����ȸ������ɥ쥹
353 b -- ʸ����ڤ���뤫�ɤ���
354 sr -- ȿž�ΰ�γ��ϰ��֤��֤����ɥ쥹
355 er -- ȿž�ΰ�ν�λ���֤��֤����ɥ쥹
356 pat -- wcKanjiAttributeInternal structure to store attribute information
357 focused -- focus is on this yc.
358 */
359
360 static int extractKanjiString
361 pro((yomiContext, wchar_t *, wchar_t *, int, wchar_t **, wchar_t **,
362 wcKanjiAttributeInternal *, int));
363
364 static int
extractKanjiString(yc,s,e,b,sr,er,pat,focused)365 extractKanjiString(yc, s, e, b, sr, er, pat, focused)
366 yomiContext yc;
367 wchar_t *s, *e, **sr, **er;
368 int b;
369 wcKanjiAttributeInternal *pat;
370 int focused;
371 {
372 wchar_t *ss = s;
373 int i, len, nbun;
374
375 nbun = yc->bunlen ? yc->curbun : yc->nbunsetsu;
376
377 for (i = 0 ; i < nbun ; i++) {
378 if (i && b && s < e) {
379 *s++ = (wchar_t)' ';
380 if (pat && pat->sp < pat->ep) {
381 *pat->sp++ = CANNA_ATTR_CONVERTED;
382 }
383 }
384 RkwGoTo(yc->context, i);
385 len = RkwGetKanji(yc->context, s, (int)(e - s));
386 if (len < 0) {
387 if (errno == EPIPE) {
388 jrKanjiPipeError();
389 }
390 jrKanjiError = "�����ȸ������Ф��ޤ���Ǥ���";
391 }
392 else {
393 char curattr;
394 if (i == yc->curbun && !yc->bunlen && focused) { /* focused */
395 *sr = s; *er = s + len;
396 curattr = CANNA_ATTR_TARGET_CONVERTED;
397 }
398 else {
399 curattr = CANNA_ATTR_CONVERTED;
400 }
401 if (pat && pat->sp + len < pat->ep) {
402 char *ap = pat->sp, *ep = ap + len;
403 while (ap < ep) {
404 *ap++ = curattr;
405 }
406 pat->sp = ap;
407 }
408 s += len;
409 }
410 }
411
412 if (yc->bunlen) {
413 if (i && b && s < e) {
414 *s++ = (wchar_t)' ';
415 if (pat && pat->sp < pat->ep) {
416 *pat->sp++ = CANNA_ATTR_CONVERTED;
417 }
418 }
419 len = yc->kEndp - yc->kanjilen;
420 if ((int)(e - s) < len) {
421 len = (int)(e - s);
422 }
423 WStrncpy(s, yc->kana_buffer + yc->kanjilen, len);
424 if (pat && pat->sp + len < pat->ep) {
425 char *ap = pat->sp, *mp = ap + yc->bunlen, *ep = ap + len;
426 char target = focused ?
427 CANNA_ATTR_TARGET_NOTCONVERTED : CANNA_ATTR_CONVERTED;
428 while (ap < mp) {
429 *ap++ = target;
430 }
431 while (ap < ep) {
432 *ap++ = CANNA_ATTR_INPUT;
433 }
434 pat->sp = ap;
435 }
436 if (b) {
437 *er = (*sr = s + yc->bunlen) +
438 ((yc->kanjilen + yc->bunlen == yc->kEndp) ? 0 : 1);
439 }
440 else {
441 *sr = s; *er = s + yc->bunlen;
442 }
443 s += len;
444 }
445
446 if (s < e) {
447 *s = (wchar_t)'\0';
448 }
449
450 RkwGoTo(yc->context, yc->curbun);
451 return (int)(s - ss);
452 }
453
454 /*
455 extractYomiString -- yomiContext ��ʸ������Ф�
456
457 ����
458 yc -- yomiContext
459 s -- ���Ф���Υ��ɥ쥹
460 e -- ������ۤ��Ƽ��Ф��ƤϤʤ�ʤ����ȸ������ɥ쥹
461 b -- ʸ����ڤ���뤫�ɤ���
462 sr -- ȿž�ΰ�γ��ϰ��֤��֤����ɥ쥹
463 er -- ȿž�ΰ�ν�λ���֤��֤����ɥ쥹
464 pat -- wcKanjiAttributeInternal structure to store attribute information
465 focused -- The yc is now focused.
466 */
467
468 static int extractYomiString
469 pro((yomiContext, wchar_t *, wchar_t *, int, wchar_t **, wchar_t **,
470 wcKanjiAttributeInternal *, int));
471
472 static int
extractYomiString(yc,s,e,b,sr,er,pat,focused)473 extractYomiString(yc, s, e, b, sr, er, pat, focused)
474 yomiContext yc;
475 wchar_t *s, *e, **sr, **er;
476 int b;
477 wcKanjiAttributeInternal *pat;
478 int focused;
479 {
480 int autoconvert = yc->generalFlags & CANNA_YOMI_CHIKUJI_MODE, len;
481 wchar_t *ss = s;
482
483 if (autoconvert) {
484 int OnBunsetsu = ((yc->status & CHIKUJI_ON_BUNSETSU) ||
485 (yc->nbunsetsu && !(yc->status & CHIKUJI_OVERWRAP)));
486 len = extractKanjiString(yc, s, e, b, sr, er, pat, focused && OnBunsetsu);
487 s += len;
488 if (yc->kEndp - yc->cStartp > 0) {
489 wchar_t *ssr, *eer;
490
491 if (b && len && s < e) {
492 *s++ = (wchar_t)' ';
493 if (pat && pat->sp < pat->ep) {
494 *pat->sp++ = CANNA_ATTR_CONVERTED;
495 }
496 }
497 len = extractSimpleYomiString(yc, s, e, &ssr, &eer, pat,
498 focused && !OnBunsetsu);
499 /* �Ǹ�� !OnBunsetsu �äƤȤ���ϡ��ʲ��Τ褦�ˤ�������ɽ���������å�
500 �Ĥ��ǡ�ȿžʸ��ФƤ⥭���åȤ���������ݥ������Ǥ��뤳�Ȥ���
501 ����䤹���Τ�����OVERWRAP �ե饰�������ȥ⡼�����Ȥ��б�������Ƥ�
502 �ʤ��褦�ʤΤǡ��Ȥꤢ�����嵭�ΤޤޤȤ��롣
503 (!yc->nbunsetsu ||
504 (yc->status & CHIKUJI_OVERWRAP)));
505 */
506 s += len;
507 if (!OnBunsetsu) {
508 *sr = ssr; *er = eer;
509 if (pat && focused) {
510 pat->u.caretpos = pat->sp - pat->u.attr - (s - *sr);
511 /* �嵭�η��β���: �����åȰ��֤ϡ����奢�ȥ�ӥ塼��
512 ���������֤�����ä����֤ˤ��롣�ɤΤ��餤��뤫��
513 �����ȡ�����ʸ������������֤��顢ȿž���ϰ��֤ޤ�
514 ����̤������ */
515 }
516 }
517 }
518 }
519 else if (yc->nbunsetsu) { /* ñ����⡼�� */
520 len = extractKanjiString(yc, s, e, b, sr, er, pat, focused);
521 s += len;
522 }
523 else {
524 len = extractSimpleYomiString(yc, s, e, sr, er, pat, focused);
525 s += len;
526 }
527 if (s < e) {
528 *s = (wchar_t)'\0';
529 }
530 return (int)(s - ss);
531 }
532
533 static
extractString(str,s,e)534 extractString(str, s, e)
535 wchar_t *str, *s, *e;
536 {
537 int len;
538
539 len = WStrlen(str);
540 if (s + len < e) {
541 WStrcpy(s, str);
542 return len;
543 }
544 else {
545 WStrncpy(s, str, (int)(e - s));
546 return (int)(e - s);
547 }
548 }
549
550 /*
551 extractTanString -- tanContext ��ʸ������Ф�
552
553 ����
554 tan -- tanContext
555 s -- ���Ф���Υ��ɥ쥹
556 e -- ������ۤ��Ƽ��Ф��ƤϤʤ�ʤ����ȸ������ɥ쥹
557 */
558
559 int
extractTanString(tan,s,e)560 extractTanString(tan, s, e)
561 tanContext tan;
562 wchar_t *s, *e;
563 {
564 return extractString(tan->kanji, s, e);
565 }
566
567 /*
568 extractTanYomi -- tanContext ��ʸ������Ф�
569
570 ����
571 tan -- tanContext
572 s -- ���Ф���Υ��ɥ쥹
573 e -- ������ۤ��Ƽ��Ф��ƤϤʤ�ʤ����ȸ������ɥ쥹
574 */
575
576 int
extractTanYomi(tan,s,e)577 extractTanYomi(tan, s, e)
578 tanContext tan;
579 wchar_t *s, *e;
580 {
581 return extractString(tan->yomi, s, e);
582 }
583
584 /*
585 extractTanRomaji -- tanContext ��ʸ������Ф�
586
587 ����
588 tan -- tanContext
589 s -- ���Ф���Υ��ɥ쥹
590 e -- ������ۤ��Ƽ��Ф��ƤϤʤ�ʤ����ȸ������ɥ쥹
591 */
592
593 int
extractTanRomaji(tan,s,e)594 extractTanRomaji(tan, s, e)
595 tanContext tan;
596 wchar_t *s, *e;
597 {
598 return extractString(tan->roma, s, e);
599 }
600
601 void
makeKanjiStatusReturn(d,yc)602 makeKanjiStatusReturn(d, yc)
603 uiContext d;
604 yomiContext yc;
605 {
606 int len;
607 wchar_t *s = d->genbuf, *e = s + ROMEBUFSIZE, *sr, *er, *sk, *ek;
608 tanContext tan = (tanContext)yc;
609 long truecaret = -1;
610
611 if (d->attr) {
612 d->attr->sp = d->attr->u.attr;
613 d->attr->ep = d->attr->u.attr + d->attr->len;
614 }
615
616 /* �ǽ���Ѵ�����Ƥ�����ʬ����Ф� */
617 while (tan->left) {
618 tan = tan->left;
619 }
620
621 while (tan) {
622 if (d->attr) d->attr->u.caretpos = -1;
623 switch (tan->id) {
624 case TAN_CONTEXT:
625 len = extractTanString(tan, s, e);
626 sk = s; ek = s + len;
627 if (d->attr &&
628 d->attr->sp + len < d->attr->ep) {
629 char *ap = d->attr->sp, *ep = ap + len;
630 char curattr =
631 ((mode_context)tan == (mode_context)yc) ?
632 CANNA_ATTR_TARGET_CONVERTED : CANNA_ATTR_CONVERTED;
633 for (; ap < ep ; ap++) {
634 *ap = curattr;
635 }
636 d->attr->sp = ap;
637 }
638 break;
639 case YOMI_CONTEXT:
640 len = extractYomiString((yomiContext)tan, s, e, cannaconf.BunsetsuKugiri,
641 &sk, &ek, d->attr,
642 (mode_context)tan == (mode_context)yc);
643 break;
644 default:
645 break;
646 }
647
648 if ((mode_context)tan == (mode_context)yc) {
649 sr = sk;
650 er = ek;
651 if (d->attr) truecaret = d->attr->u.caretpos;
652 }
653 s += len;
654 tan = tan->right;
655 if (cannaconf.BunsetsuKugiri && tan && s < e) {
656 *s++ = (wchar_t)' ';
657 if (d->attr && d->attr->sp < d->attr->ep) {
658 *d->attr->sp++ = CANNA_ATTR_CONVERTED;
659 }
660 }
661 }
662
663 if (s < e) {
664 *s = (wchar_t)'\0';
665 }
666
667 d->kanji_status_return->length = (int)(s - d->genbuf);
668 d->kanji_status_return->echoStr = d->genbuf;
669 d->kanji_status_return->revPos = (int)(sr - d->genbuf);
670 d->kanji_status_return->revLen = (int)(er - sr);
671 if (d->attr) {
672 d->attr->u.caretpos = truecaret;
673 if (d->kanji_status_return->length < d->attr->len) {
674 d->attr->u.attr[d->kanji_status_return->length] = '\0';
675 }
676 d->kanji_status_return->info |= KanjiAttributeInfo;
677 }
678 }
679
680 #define MESSBUFSIZE 256
681
682 /*
683 * ��С����ʤ��Υ�å����������ɥ饤���ɽ������
684 * �������Ϥ����ä��Ȥ��˾ä���褦�˥ե饰�����ꤹ��
685 */
686 void
makeGLineMessage(d,msg,sz)687 makeGLineMessage(d, msg, sz)
688 uiContext d;
689 wchar_t *msg;
690 int sz;
691 {
692 static wchar_t messbuf[MESSBUFSIZE];
693 int len = sz < MESSBUFSIZE ? sz : MESSBUFSIZE - 1;
694
695 WStrncpy(messbuf, msg, len);
696 messbuf[len] = (wchar_t)0;
697 d->kanji_status_return->gline.line = messbuf;
698 d->kanji_status_return->gline.length = len;
699 d->kanji_status_return->gline.revPos = 0;
700 d->kanji_status_return->gline.revLen = 0;
701 d->kanji_status_return->info |= KanjiGLineInfo;
702
703 d->flags &= ~PCG_RECOGNIZED;
704 d->flags |= PLEASE_CLEAR_GLINE;
705 checkGLineLen(d);
706 }
707
708 void
makeGLineMessageFromString(d,msg)709 makeGLineMessageFromString(d, msg)
710 uiContext d;
711 char *msg;
712 {
713 int len;
714
715 len = MBstowcs(d->genbuf, msg, ROMEBUFSIZE);
716 makeGLineMessage(d, d->genbuf, len);
717 }
718
setWStrings(ws,s,sz)719 setWStrings(ws, s, sz)
720 wchar_t **ws;
721 char **s;
722 int sz;
723 {
724 int f = sz;
725 wchar_t *WString();
726
727 for (; (f && sz) || (!f && *s); ws++, s++, sz--) {
728 *ws = WString(*s);
729 if (!*ws) {
730 return NG;
731 }
732 }
733 return 0;
734 }
735
736 #ifdef DEBUG
dbg_msg(fmt,x,y,z)737 dbg_msg(fmt, x, y, z)
738 char *fmt;
739 int x, y, z;
740 {
741 if (iroha_debug) {
742 fprintf(stderr, fmt, x, y, z);
743 }
744 }
745
checkModec(d)746 checkModec(d)
747 uiContext d;
748 {
749 coreContext c;
750 struct callback *cb;
751 int depth = 0, cbDepth = 0;
752 int callbacks = 0;
753
754 for (c = (coreContext)d->modec ; c ; c = (coreContext)c->next)
755 depth++;
756 for (cb = d->cb ; cb ; cb = cb->next) {
757 int i;
758
759 cbDepth++;
760 for (i = 0 ; i < 4 ; i++) {
761 callbacks <<= 1;
762 if (cb->func[i]) {
763 callbacks++;
764 }
765 }
766 }
767 if (depth != cbDepth) {
768 fprintf(stderr, "�����������������������㤦������������������\n");
769 }
770 debug_message("\242\243\40\277\274\244\265: d->modec:%d d->cb:%d callbacks:0x%08x ",
771 depth, cbDepth, callbacks);
772 /* �� ���� */
773 debug_message("EXIT_CALLBACK = 0x%x\n", d->cb->func[EXIT_CALLBACK],0,0);
774 {
775 extern KanjiModeRec yomi_mode;
776 if (d->current_mode == &yomi_mode) {
777 yomiContext yc = (yomiContext)d->modec;
778 if (yc->kana_buffer[yc->kEndp]) {
779 fprintf(stderr, "���������� ���ʥХåե��˥��ߤ����äƤ��뤾��\n");
780 }
781 }
782 }
783 }
784
785 static char pbufstr[] = " o|do?b%";
786
showRomeStruct(dpy,win)787 showRomeStruct(dpy, win)
788 unsigned int dpy, win;
789 {
790 uiContext d, keyToContext();
791 extern defaultContext;
792 static int n = 0;
793 int i;
794 char buf[1024];
795
796 n++;
797 fprintf(stderr, "\n�ڥǥХ���å�����(%d)��\n", n);
798 d = keyToContext((unsigned int)dpy, (unsigned int)win);
799 fprintf(stderr, "buffer(0x%x), bytes(%d)\n",
800 d->buffer_return, d->n_buffer);
801 fprintf(stderr, "nbytes(%d), ch(0x%x)\n", d->nbytes, d->ch);
802 fprintf(stderr, "�⡼��: %d\n", ((coreContext)d->modec)->minorMode);
803 /* ����ƥ����� */
804 fprintf(stderr, "����ƥ�����(%d)\n", d->contextCache);
805 fprintf(stderr, "�ǥե���ȥ���ƥ�����(%d)\n", defaultContext);
806
807 /* �������ʴ�Ϣ */
808 if (((coreContext)d->modec)->id == YOMI_CONTEXT) {
809 yomiContext yc = (yomiContext)d->modec;
810
811 fprintf(stderr, "r: Start(%d), Cursor(%d), End(%d)\n",
812 yc->rStartp, yc->rCurs, yc->rEndp);
813 fprintf(stderr, "k: ̤�Ѵ�Start(%d), Cursor(%d), End(%d)\n",
814 yc->kRStartp, yc->kCurs, yc->kEndp);
815 WStrncpy(buf, yc->romaji_buffer, yc->rEndp);
816 buf[yc->rEndp] = '\0';
817 fprintf(stderr, "romaji_buffer(%s)\n", buf);
818 fprintf(stderr, "romaji_attrib(");
819 for (i = 0 ; i <= yc->rEndp ; i++) {
820 fprintf(stderr, "%1x", yc->rAttr[i]);
821 }
822 fprintf(stderr, ")\n");
823 fprintf(stderr, "romaji_pointr(");
824 for (i = 0 ; i <= yc->rEndp ; i++) {
825 int n = 0;
826 if (i == yc->rStartp)
827 n |= 1;
828 if (i == yc->rCurs)
829 n |= 2;
830 if (i == yc->rEndp)
831 n |= 4;
832 fprintf(stderr, "%c", pbufstr[n]);
833 }
834 fprintf(stderr, ")\n");
835 WStrncpy(buf, yc->kana_buffer, yc->kEndp);
836 buf[yc->kEndp] = '\0';
837 fprintf(stderr, "kana_buffer(%s)\n", buf);
838 fprintf(stderr, "kana_attrib(");
839 for (i = 0 ; i <= yc->kEndp ; i++) {
840 fprintf(stderr, "%1x", yc->kAttr[i]);
841 }
842 fprintf(stderr, ")\n");
843 fprintf(stderr, "kana_pointr(");
844 for (i = 0 ; i <= yc->kEndp ; i++) {
845 int n = 0;
846 if (i == yc->kRStartp)
847 n |= 1;
848 if (i == yc->kCurs)
849 n |= 2;
850 if (i == yc->kEndp)
851 n |= 4;
852 fprintf(stderr, "%c", pbufstr[n]);
853 }
854 fprintf(stderr, ")\n");
855 fprintf(stderr, "\n");
856 }
857 /* RkPrintDic(0, "kon"); */
858 }
859 #endif /* DEBUG */
860
861 extern char *jrKanjiError;
862
NoMoreMemory()863 NoMoreMemory()
864 {
865 jrKanjiError = "\245\341\245\342\245\352\244\254\311\324\302\255\244\267\244\306\244\244\244\336\244\271\241\243";
866 /* ���꤬�����Ƥ��ޤ��� */
867 return NG;
868 }
869
GLineNGReturn(d)870 GLineNGReturn(d)
871 uiContext d;
872 {
873 int len;
874 len = MBstowcs(d->genbuf, jrKanjiError, ROMEBUFSIZE);
875 makeGLineMessage(d, d->genbuf, len);
876 currentModeInfo(d);
877
878 return(0);
879 }
880
GLineNGReturnFI(d)881 GLineNGReturnFI(d)
882 uiContext d;
883 {
884 popForIchiranMode(d);
885 popCallback(d);
886 GLineNGReturn(d);
887 return(0);
888 }
889
890 #ifndef NO_EXTEND_MENU
891
GLineNGReturnTK(d)892 GLineNGReturnTK(d)
893 uiContext d;
894 {
895 extern void popTourokuMode pro((uiContext));
896 popTourokuMode(d);
897 popCallback(d);
898 GLineNGReturn(d);
899 return(0);
900 }
901
902 #endif /* NO_EXTEND_MENU */
903
904 #ifdef USE_COPY_ATTRIBUTE
copyAttribute(dest,src,n)905 copyAttribute(dest, src, n)
906 BYTE *dest;
907 BYTE *src;
908 int n;
909 {
910 if (dest > src && dest < src + n) {
911 dest += n;
912 src += n;
913 while (n-- > 0) {
914 *--dest = *--src;
915 }
916 }
917 else {
918 while (n-- > 0) {
919 *dest++ = *src++;
920 }
921 }
922 }
923 #endif
924
925 #ifdef DEBUG_ALLOC
926 int fail_malloc = 0;
927
928 #undef malloc
929
930 char *
debug_malloc(n)931 debug_malloc(n)
932 int n;
933 {
934 if (fail_malloc)
935 return (char *)0;
936 else
937 return malloc(n);
938 }
939 #endif /* DEBUG_ALLOC */
940
941 /*
942 * �磻�ɥ���饯�����ڥ졼�����
943 *
944 */
945
946 int
WStrlen(ws)947 WStrlen(ws)
948 wchar_t *ws;
949 {
950 int res = 0;
951 while (*ws++) {
952 res++;
953 }
954 return res;
955 }
956
957 wchar_t *
WStrcpy(ws1,ws2)958 WStrcpy(ws1, ws2)
959 wchar_t *ws1, *ws2;
960 {
961 wchar_t *ws;
962 int cnt, len;
963
964 ws = ws2;
965 while (*ws) {
966 ws++;
967 }
968 len = cnt = ws - ws2;
969 if (ws2 < ws1 && ws1 < ws /* == ws2 + cnt */) {
970 while (cnt--) {
971 ws1[cnt] = ws2[cnt];
972 }
973 }
974 else {
975 ws = ws1;
976 while (*ws2) {
977 *ws++ = *ws2++;
978 }
979 }
980 ws1[len] = (wchar_t)0;
981 return ws1;
982 }
983
984 wchar_t *
WStrncpy(ws1,ws2,cnt)985 WStrncpy(ws1, ws2, cnt)
986 wchar_t *ws1, *ws2;
987 int cnt;
988 {
989 wchar_t *ws;
990
991 if (ws2 == (wchar_t *)0)
992 return((wchar_t *)0);
993 if (ws2 < ws1 && ws1 < ws2 + cnt) {
994 while (cnt--) {
995 ws1[cnt] = ws2[cnt];
996 }
997 }
998 else {
999 int i = 0;
1000 ws = ws1;
1001 while (i++ < cnt && *ws2) {
1002 *ws++ = *ws2++;
1003 }
1004 }
1005 return ws1;
1006 }
1007
1008 wchar_t *
WStraddbcpy(ws1,ws2,cnt)1009 WStraddbcpy(ws1, ws2, cnt)
1010 wchar_t *ws1, *ws2;
1011 int cnt;
1012 {
1013 wchar_t *strp = ws1, *endp = ws1 + cnt - 1;
1014
1015 while (*ws2 != (wchar_t)'\0' && ws1 < endp) {
1016 if (*ws2 == (wchar_t)' ' || *ws2 == (wchar_t)'\t' || *ws2 == (wchar_t)'\\')
1017 *ws1++ = (wchar_t)'\\';
1018 *ws1++ = *ws2++;
1019 }
1020 if (ws1 == endp) {
1021 ws1--;
1022 }
1023 *ws1 = (wchar_t)'\0';
1024 return(strp);
1025 }
1026
1027 wchar_t *
WStrcat(ws1,ws2)1028 WStrcat(ws1, ws2)
1029 wchar_t *ws1, *ws2;
1030 {
1031 wchar_t *ws;
1032
1033 ws = ws1;
1034 while (*ws) {
1035 ws++;
1036 }
1037 WStrcpy(ws, ws2);
1038 return ws1;
1039 }
1040
1041 int
WStrcmp(w1,w2)1042 WStrcmp(w1, w2)
1043 wchar_t *w1, *w2;
1044 {
1045 while (*w1 && *w1 == *w2) {
1046 w1++;
1047 w2++;
1048 }
1049 return(*w1 - *w2);
1050 }
1051
1052 int
WStrncmp(w1,w2,n)1053 WStrncmp(w1, w2, n)
1054 wchar_t *w1, *w2;
1055 int n;
1056 {
1057 if (n == 0) return(0);
1058 while (--n && *w1 && *w1 == *w2) {
1059 w1++;
1060 w2++;
1061 }
1062 return *w1 - *w2;
1063 }
1064
1065 /* WWhatGPlain -- �ɤΥ���ե��å��ץ졼���ʸ������
1066
1067 �����:
1068 0 : G0 ASCII
1069 1 : G1 ����(JISX0208)
1070 2 : G2 Ⱦ�ѥ�������(JISX0201)
1071 3 : G3 ����(������� JISX0212)
1072 */
1073
1074 int
1075 #ifdef __STDC__
WWhatGPlain(wchar_t wc)1076 WWhatGPlain(wchar_t wc)
1077 #else
1078 WWhatGPlain(wc)
1079 wchar_t wc;
1080 #endif
1081 {
1082 static char plain[4] = {0, 2, 3, 1};
1083
1084 #ifdef CANNA_WCHAR16
1085 switch (((unsigned long)wc) & 0x8080) {
1086 case 0x0000:
1087 return 0;
1088 case 0x8080:
1089 return 1;
1090 case 0x0080:
1091 return 2;
1092 case 0x8000:
1093 return 3;
1094 }
1095 /* NOTREACHED */
1096 #else /* !CANNA_WCHAR16 */
1097 return plain[(((unsigned long)wc) >> 28) & 3];
1098 #endif /* !CANNA_WCHAR16 */
1099 }
1100
1101 int
1102 #ifdef __STDC__
WIsG0(wchar_t wc)1103 WIsG0(wchar_t wc)
1104 #else
1105 WIsG0(wc)
1106 wchar_t wc;
1107 #endif
1108 {
1109 return (WWhatGPlain(wc) == 0);
1110 }
1111
1112 int
1113 #ifdef __STDC__
WIsG1(wchar_t wc)1114 WIsG1(wchar_t wc)
1115 #else
1116 WIsG1(wc)
1117 wchar_t wc;
1118 #endif
1119 {
1120 return (WWhatGPlain(wc) == 1);
1121 }
1122
1123 int
1124 #ifdef __STDC__
WIsG2(wchar_t wc)1125 WIsG2(wchar_t wc)
1126 #else
1127 WIsG2(wc)
1128 wchar_t wc;
1129 #endif
1130 {
1131 return (WWhatGPlain(wc) == 2);
1132 }
1133
1134 int
1135 #ifdef __STDC__
WIsG3(wchar_t wc)1136 WIsG3(wchar_t wc)
1137 #else
1138 WIsG3(wc)
1139 wchar_t wc;
1140 #endif
1141 {
1142 return (WWhatGPlain(wc) == 3);
1143 }
1144
1145 int
CANNA_mbstowcs(dest,src,destlen)1146 CANNA_mbstowcs(dest, src, destlen)
1147 wchar_t *dest;
1148 char *src;
1149 int destlen;
1150 {
1151 register int i, j;
1152 register unsigned ec;
1153
1154 #ifdef CANNA_WCHAR16
1155 for (i = 0, j = 0 ;
1156 (ec = (unsigned)(unsigned char)src[i]) != 0 && j < destlen ; i++) {
1157 if (ec & 0x80) {
1158 switch (ec) {
1159 case 0x8e: /* SS2 */
1160 dest[j++] = (wchar_t)(0x80 | ((unsigned)src[++i] & 0x7f));
1161 break;
1162 case 0x8f: /* SS3 */
1163 dest[j++] = (wchar_t)(0x8000
1164 | (((unsigned)src[i + 1] & 0x7f) << 8)
1165 | ((unsigned)src[i + 2] & 0x7f));
1166 i += 2;
1167 break;
1168 default:
1169 dest[j++] = (wchar_t)(0x8080 | (((unsigned)src[i] & 0x7f) << 8)
1170 | ((unsigned)src[i + 1] & 0x7f));
1171 i++;
1172 break;
1173 }
1174 }
1175 else {
1176 dest[j++] = (wchar_t)ec;
1177 }
1178 }
1179 if (j < destlen)
1180 dest[j] = (wchar_t)0;
1181 return j;
1182 #else /* !CANNA_WCHAR16 */
1183 for (i = 0, j = 0 ;
1184 (ec = (unsigned)(unsigned char)src[i]) != 0 && j < destlen ; i++) {
1185 if (ec & 0x80) {
1186 switch (ec) {
1187 case 0x8e: /* SS2 */
1188 dest[j++] = (wchar_t)(0x10000000L | ((unsigned)src[++i] & 0x7f));
1189 break;
1190 case 0x8f: /* SS3 */
1191 dest[j++] = (wchar_t)(0x20000000L
1192 | (((unsigned)src[i + 1] & 0x7f) << 7)
1193 | ((unsigned)src[i + 2] & 0x7f));
1194 i += 2;
1195 break;
1196 default:
1197 dest[j++] = (wchar_t)(0x30000000L | (((unsigned)src[i] & 0x7f) << 7)
1198 | ((unsigned)src[i + 1] & 0x7f));
1199 i++;
1200 break;
1201 }
1202 }
1203 else {
1204 dest[j++] = (wchar_t)ec;
1205 }
1206 }
1207 if (j < destlen)
1208 dest[j] = (wchar_t)0;
1209 return j;
1210 #endif /* !CANNA_WCHAR16 */
1211 }
1212
1213 int
CNvW2E(src,srclen,dest,destlen)1214 CNvW2E(src, srclen, dest, destlen)
1215 wchar_t *src;
1216 char *dest;
1217 int srclen, destlen;
1218 {
1219 register int i, j;
1220
1221 #ifdef CANNA_WCHAR16
1222 for (i = 0, j = 0 ; i < srclen && j + 2 < destlen ; i++) {
1223 wchar_t wc = src[i];
1224 switch (wc & 0x8080) {
1225 case 0:
1226 /* ASCII */
1227 dest[j++] = (char)((unsigned)wc & 0x7f);
1228 break;
1229 case 0x0080:
1230 /* Ⱦ�ѥ��� */
1231 dest[j++] = (char)0x8e; /* SS2 */
1232 dest[j++] = (char)(((unsigned)wc & 0x7f) | 0x80);
1233 break;
1234 case 0x8000:
1235 /* ���� */
1236 dest[j++] = (char)0x8f; /* SS3 */
1237 dest[j++] = (char)((((unsigned)wc & 0x7f00) >> 8) | 0x80);
1238 dest[j++] = (char)(((unsigned)wc & 0x7f) | 0x80);
1239 break;
1240 case 0x8080:
1241 /* ���� */
1242 dest[j++] = (char)((((unsigned)wc & 0x7f00) >> 8) | 0x80);
1243 dest[j++] = (char)(((unsigned)wc & 0x7f) | 0x80);
1244 break;
1245 }
1246 }
1247 dest[j] = (char)0;
1248 return j;
1249 #else /* !CANNA_WCHAR16 */
1250 for (i = 0, j = 0 ; i < srclen && j + 2 < destlen ; i++) {
1251 wchar_t wc = src[i];
1252 switch (wc >> 28) {
1253 case 0:
1254 /* ASCII */
1255 dest[j++] = (char)((unsigned)wc & 0x7f);
1256 break;
1257 case 1:
1258 /* Ⱦ�ѥ��� */
1259 dest[j++] = (char)0x8e; /* SS2 */
1260 dest[j++] = (char)(((unsigned)wc & 0x7f) | 0x80);
1261 break;
1262 case 2:
1263 /* ���� */
1264 dest[j++] = (char)0x8f; /* SS3 */
1265 dest[j++] = (char)((((unsigned)wc & 0x3f80) >> 7) | 0x80);
1266 dest[j++] = (char)(((unsigned)wc & 0x7f) | 0x80);
1267 break;
1268 case 3:
1269 /* ���� */
1270 dest[j++] = (char)((((unsigned)wc & 0x3f80) >> 7) | 0x80);
1271 dest[j++] = (char)(((unsigned)wc & 0x7f) | 0x80);
1272 break;
1273 }
1274 }
1275 dest[j] = (char)0;
1276 return j;
1277 #endif /* !CANNA_WCHAR16 */
1278 }
1279
1280 int
CANNA_wcstombs(dest,src,destlen)1281 CANNA_wcstombs(dest, src, destlen)
1282 char *dest;
1283 wchar_t *src;
1284 int destlen;
1285 {
1286 return CNvW2E(src, WStrlen(src), dest, destlen);
1287 }
1288
1289 /* cfuncdef
1290
1291 WString -- EUC����磻�ɥ���饯���ؤΥޥåԥ������ malloc
1292
1293 WString �ϰ�����ʸ�����磻�ɥ���饯�����Ѵ���������ʸ�������ޤ�
1294 �����Υ���� malloc ��������ʸ�����Ǽ���֤���
1295
1296 ���ѼԤϤ��δؿ��������ݥ����� free ����ɬ�פϤ��ޤ�ʤ���
1297
1298 ���ʤ�������δؿ�����������ϸ�� WStringClose ��ƤӽФ����Ȥ���
1299 free ����롣
1300
1301 ������������ʤΤǤ��δؿ������ˤ˸ƤӽФ��ƤϤ����ʤ������ޤ�EUC��
1302 �������Ǥ��Ƥ���ʸ����ʤɤ�α���٤��Ǥ��롣
1303
1304 ���ε�ǽ��Ȥ��ͤϺǽ�� WStringOpen ��ƤӽФ��ʤ���Фʤ�ʤ�����
1305 �桼�������ե������饤�֥��Ǥϥ����ƥब��ưŪ���ɤ�Ǥ�����
1306 �Ǥ���ɬ�פϤʤ���
1307
1308 */
1309
1310 static wchar_t **wsmemories = (wchar_t **)NULL;
1311 static int nwsmemories = 0;
1312
1313 #define WSBLOCKSIZE 128
1314
1315 int
WStringOpen()1316 WStringOpen()
1317 {
1318 return 0;
1319 }
1320
1321 wchar_t *
WString(s)1322 WString(s)
1323 char *s;
1324 {
1325 int i, len;
1326 wchar_t *temp, **wm;
1327
1328 if (wsmemories == (wchar_t **)NULL) {
1329 nwsmemories = WSBLOCKSIZE;
1330 if (!(wsmemories = (wchar_t **)calloc(nwsmemories, sizeof(wchar_t *))))
1331 return((wchar_t *)0) ;
1332 /* calloc ���줿����ϥ��ꥢ����Ƥ��� */
1333 }
1334
1335 for (i = 0 ; i < nwsmemories && wsmemories[i] ;) {
1336 i++;
1337 }
1338
1339 if (i == nwsmemories) { /* �Ȥ��ڤä��Τ����䤹 */
1340 if (!(wm = (wchar_t **)realloc(wsmemories,
1341 (nwsmemories + WSBLOCKSIZE)
1342 * sizeof(wchar_t *))))
1343 return((wchar_t *)0);
1344 wsmemories = wm;
1345 for (; i < nwsmemories + WSBLOCKSIZE ; i++)
1346 wsmemories[i] = (wchar_t *)0;
1347 i = nwsmemories;
1348 nwsmemories += WSBLOCKSIZE;
1349 }
1350
1351 /* �Ȥꤢ�����礭���ȤäƤ����ơ����Υ������������٤Υ�������
1352 ľ�����֤� */
1353
1354 len = strlen(s);
1355 if (!(temp = (wchar_t *)malloc((len + 1) * WCHARSIZE)))
1356 return((wchar_t *)0);
1357 len = MBstowcs(temp, s, len + 1);
1358 if (!(wsmemories[i] = (wchar_t *)malloc((len + 1) * WCHARSIZE))) {
1359 free(temp);
1360 return((wchar_t *) 0);
1361 }
1362 WStrncpy(wsmemories[i], temp, len);
1363 wsmemories[i][len] = (wchar_t)0;
1364 free(temp);
1365 return(wsmemories[i]);
1366 }
1367
1368 void
WStringClose()1369 WStringClose()
1370 {
1371 int i;
1372
1373 for (i = 0 ; i < nwsmemories ; i++)
1374 if (wsmemories[i])
1375 free(wsmemories[i]);
1376 free(wsmemories);
1377 wsmemories = (wchar_t **)0;
1378 nwsmemories = 0;
1379 }
1380
WSfree(s)1381 WSfree(s)
1382 wchar_t *s;
1383 {
1384 int i;
1385 wchar_t **t;
1386
1387 for (t = wsmemories, i = nwsmemories; s != *t && i;) {
1388 t++;
1389 i--;
1390 }
1391 if (s != *t)
1392 return(-1);
1393 free(*t);
1394 *t = (wchar_t *) 0;
1395 return(0);
1396 }
1397
1398 /*
1399 generalReplace -- ���ʥХåե��ˤ�����Хåե��ˤ�Ȥ����ִ��롼����
1400
1401 �����ִ��롼�����ʸ����Υ������ִ���Ԥ�����Υ饤�֥��롼��
1402 ��Ǥ��롣������ʸ������ݻ����Ƥ������Ȥߤϼ��Τ褦�ˤʤäƤ���
1403 ��ΤȤ��롣
1404
1405 ��ʸ�����ѤΥХåե�
1406 ��ʸ����°���ѤΥХåե�
1407 ����������(����ǥå���(�ݥ����ǤϤʤ�))
1408 ��ʸ����ν�����ؤ�����ǥå���
1409 ��ɬ�����������꺸��¸�ߤ��륤��ǥå���(̤�Ѵ�ʸ���ؤΥ���ǥ�
1410 �����˻Ȥä��ꤹ��)
1411
1412 �嵭�˼������Хåե���Υ���������������λ��ꤵ�줿Ĺ����ʸ����
1413 ���̤˻��ꤵ���ʸ������֤�������������롣
1414
1415 �ȡ�����ΥХ��ȿ����Ѳ��������ʸ����ν�����ؤ�����ǥå�����
1416 �ͤ��Ѳ������롣�ޤ������������������ʬ���Ф���ʸ������ִ���Ԥ���
1417 ��ˤϥ�������ݥ��������ͤ��Ѳ������롣����������Ѳ���������̡�
1418 ̤�Ѵ�ʸ�����ؤΥ���ǥå������⾮�����ʤä����ˤϡ�̤�Ѵ�ʸ����
1419 �ؤΥ���ǥå������ͤ���������ͤ˹�碌�ƾ��������롣
1420
1421 ���δؿ��κǽ������ˤϿ�������������ʸ�����°���˴ؤ���ҥ�Ȥ�����
1422 �Ǥ��롣���������������ʸ����γ�ʸ�����Ф��ơ��ҥ�Ȥ�Ϳ����줿��
1423 ���Ȥ�°���ͤȤ��Ƴ�Ǽ����롣
1424
1425 �ڰ�����
1426 buf �Хåե��ؤΥݥ���
1427 attr °���Хåե��ؤΥݥ���
1428 startp �Хåե���̤����ʸ����ʤɤؤΥ���ǥå��������Ƥ�����
1429 ���ؤΥݥ���
1430 cursor ����������֤����Ƥ����ѿ��ؤΥݥ���
1431 endp ʸ����κǽ����֤�ؤ������Ƥ����ѿ��ؤΥݥ���
1432
1433 bytes ���Х����ִ����뤫����ο������ꤵ���ȥ��������������
1434 ʬ�� |bytes| ʬ��ʸ�����ִ����оݤȤʤꡢ���ο�������
1435 �����ȥ�������θ�����ʬ�� bytes ʬ��ʸ�����оݤ�
1436 �ʤ롣
1437 rplastr �������֤�ʸ����ؤΥݥ���
1438 len �������֤�ʸ�����Ĺ��
1439 attrmask �������֤�ʸ�����°���Υҥ��
1440
1441 �ºݤˤϤ��δؿ���ľ�ܤ˻Ȥ鷺�ˡ�bytes, rplastr, len, attrmask ����
1442 ��Ϳ��������Ǥ���ޥ���kanaReplace, romajiReplace ��Ȥ��Τ��ɤ���
1443 */
1444
1445 void
generalReplace(buf,attr,startp,cursor,endp,bytes,rplastr,len,attrmask)1446 generalReplace(buf, attr, startp, cursor, endp, bytes, rplastr, len, attrmask)
1447 wchar_t *buf, *rplastr;
1448 BYTE *attr;
1449 int *startp, *cursor, *endp, bytes, len, attrmask;
1450 {
1451 int idou, begin, end, i;
1452 int cursorMove;
1453
1454 if (bytes > 0) {
1455 cursorMove = 0;
1456 begin = *cursor;
1457 end = *endp;
1458 }
1459 else {
1460 bytes = -bytes;
1461 cursorMove = 1;
1462 begin = *cursor - bytes;
1463 end = *endp;
1464 }
1465
1466 idou = len - bytes;
1467
1468 moveStrings(buf, attr, begin + bytes, end, idou);
1469 *endp += idou;
1470 if (cursorMove) {
1471 *cursor += idou;
1472 if (*cursor < *startp)
1473 *startp = *cursor;
1474 }
1475
1476 WStrncpy(buf + begin, rplastr, len);
1477 for (i = 0 ; i < len ; i++) {
1478 attr[begin + i] = attrmask;
1479 }
1480 /* if (len)
1481 attr[begin] |= attrmask; */
1482 }
1483
1484 #ifdef __STDC__
WToupper(wchar_t w)1485 WToupper(wchar_t w)
1486 #else
1487 WToupper(w)
1488 wchar_t w;
1489 #endif
1490 {
1491 if ('a' <= w && w <= 'z')
1492 return((wchar_t) (w - 'a' + 'A'));
1493 else
1494 return(w);
1495 }
1496
1497 #ifdef __STDC__
WTolower(wchar_t w)1498 WTolower(wchar_t w)
1499 #else
1500 WTolower(w)
1501 wchar_t w;
1502 #endif
1503 {
1504 if ('A' <= w && w <= 'Z') {
1505 return (wchar_t)(w - 'A' + 'a');
1506 }
1507 else {
1508 return w;
1509 }
1510 }
1511
1512 /*
1513 ������ wchar ��ʸ�����Ѵ����롣
1514
1515 ����:
1516 key ���Ϥ��줿����
1517 check wchar_t ���Ѵ����줿���ɤ������Ǽ���뤿����ѿ��Υ��ɥ쥹
1518 ����:
1519 �ؿ������� �Ѵ����줿 wchar_t ��ʸ��
1520 check ���ޤ��Ѵ��Ǥ������ɤ���
1521 ���:
1522 check ��ɬ��ͭ�����ѿ��Υ��ɥ쥹��ݥ���Ȥ��뤳�ȡ�
1523 check �Υݥ�������ͭ������ key2wchar �Ǥϥ����å����ʤ���
1524 */
1525
1526 wchar_t
key2wchar(key,check)1527 key2wchar(key, check)
1528 int key;
1529 int *check;
1530 {
1531 *check = 1; /* Success as default */
1532 if (161 <= key && key <= 223) { /* �������ʤ��ϰϤ��ä��� */
1533 char xxxx[4];
1534 wchar_t yyyy[4];
1535 int nchars;
1536
1537 xxxx[0] = (char)0x8e; /* SS2 */
1538 xxxx[1] = (char)key;
1539 xxxx[2] = '\0';
1540 nchars = MBstowcs(yyyy, xxxx, 4);
1541 if (nchars != 1) {
1542 *check = 0;
1543 return 0; /* ���顼 */
1544 }
1545 return yyyy[0];
1546 }
1547 else {
1548 return (wchar_t)key;
1549 }
1550 }
1551
1552 int
confirmContext(d,yc)1553 confirmContext(d, yc)
1554 uiContext d;
1555 yomiContext yc;
1556 {
1557 extern defaultContext;
1558
1559 if (yc->context < 0) {
1560 if (d->contextCache >= 0) {
1561 yc->context = d->contextCache;
1562 d->contextCache = -1;
1563 }
1564 else {
1565 if (defaultContext == -1) {
1566 if (KanjiInit() < 0 || defaultContext == -1) {
1567 jrKanjiError = KanjiInitError();
1568 return -1;
1569 }
1570 }
1571 yc->context = RkwDuplicateContext(defaultContext);
1572 if (yc->context < 0) {
1573 if (errno == EPIPE) {
1574 jrKanjiPipeError();
1575 }
1576 jrKanjiError = "\244\253\244\312\264\301\273\372\312\321\264\271\244\313\274\272\307\324\244\267\244\336\244\267\244\277";
1577 /* ���ʴ����Ѵ��˼��Ԥ��ޤ��� */
1578 return -1;
1579 }
1580 }
1581 }
1582 return yc->context;
1583 }
1584
1585 int
abandonContext(d,yc)1586 abandonContext(d, yc)
1587 uiContext d;
1588 yomiContext yc;
1589 {
1590 extern defaultContext;
1591
1592 if (yc->context >= 0) {
1593 if (d->contextCache >= 0) {
1594 RkwCloseContext(yc->context);
1595 }
1596 else {
1597 d->contextCache = yc->context;
1598 }
1599 yc->context = -1;
1600 }
1601 return 0;
1602 }
1603
1604 int
makeRkError(d,str)1605 makeRkError(d, str)
1606 uiContext d;
1607 char *str;
1608 {
1609 if (errno == EPIPE) {
1610 jrKanjiPipeError();
1611 }
1612 jrKanjiError = str;
1613 makeGLineMessageFromString(d, jrKanjiError);
1614 return -1;
1615 }
1616
1617 /* �ʲ���å������� gline �˽Ф�����λ��Ȥ� */
1618
1619 static
ProcAnyKey(d)1620 ProcAnyKey(d)
1621 uiContext d;
1622 {
1623 coreContext cc = (coreContext)d->modec;
1624
1625 d->current_mode = cc->prevMode;
1626 d->modec = cc->next;
1627 freeCoreContext(cc);
1628
1629 d->status = EXIT_CALLBACK;
1630 return 0;
1631 }
1632
1633 static wait_anykey_func pro((uiContext, KanjiMode, int, int, int));
1634
1635 static
wait_anykey_func(d,mode,whattodo,key,fnum)1636 wait_anykey_func(d, mode, whattodo, key, fnum)
1637 uiContext d;
1638 KanjiMode mode;
1639 int whattodo;
1640 int key;
1641 int fnum;
1642 /* ARGSUSED */
1643 {
1644 switch (whattodo) {
1645 case KEY_CALL:
1646 return ProcAnyKey(d);
1647 case KEY_CHECK:
1648 return 1;
1649 case KEY_SET:
1650 return 0;
1651 }
1652 /* NOTREACHED */
1653 }
1654
1655 static KanjiModeRec canna_message_mode = {
1656 wait_anykey_func,
1657 0, 0, 0,
1658 };
1659
1660 static void
cannaMessageMode(d,cnt)1661 cannaMessageMode(d, cnt)
1662 uiContext d;
1663 canna_callback_t cnt;
1664 {
1665 coreContext cc;
1666 extern coreContext newCoreContext pro((void));
1667
1668
1669 cc = newCoreContext();
1670 if (cc == 0) {
1671 NothingChangedWithBeep(d);
1672 return;
1673 }
1674 cc->prevMode = d->current_mode;
1675 cc->next = d->modec;
1676 cc->majorMode = d->majorMode;
1677 cc->minorMode = d->minorMode;
1678 if (pushCallback(d, d->modec, NO_CALLBACK, cnt,
1679 NO_CALLBACK, NO_CALLBACK) == (struct callback *)0) {
1680 freeCoreContext(cc);
1681 NothingChangedWithBeep(d);
1682 return;
1683 }
1684 d->modec = (mode_context)cc;
1685 d->current_mode = &canna_message_mode;
1686 return;
1687 }
1688
1689 /*
1690 canna_alert(d, message, cnt) -- ��å������� gline �˽Ф�
1691
1692 �������������Ϥ��줿�� cnt �ȸ����ؿ���ƤӽФ���
1693
1694 ����:
1695 d UI Context
1696 message ������
1697 cnt ���ν�����Ԥ��ؿ�
1698
1699 cnt �Ǥ� popCallback(d) ����ʤ���Фʤ�ʤ����Ȥ���ա�
1700
1701 */
1702
canna_alert(d,message,cnt)1703 canna_alert(d, message, cnt)
1704 uiContext d;
1705 char *message;
1706 canna_callback_t cnt;
1707 {
1708 d->nbytes = 0;
1709
1710 makeGLineMessageFromString(d, message);
1711 cannaMessageMode(d, cnt);
1712 return 0;
1713 }
1714
1715 char *
KanjiInitError()1716 KanjiInitError()
1717 {
1718 return "\244\253\244\312\264\301\273\372\312\321\264\271\245\265"
1719 "\241\274\245\320\244\310\304\314\277\256\244\307\244\255\244\336"
1720 "\244\273\244\363";
1721 /* "���ʴ����Ѵ������Ф��̿��Ǥ��ޤ���" */
1722 }
1723
1724 #ifndef wchar_t
1725 # error "wchar_t is already undefined"
1726 #endif
1727 #undef wchar_t
1728 /*********************************************************************
1729 * wchar_t replace end *
1730 *********************************************************************/
1731