Mercurial > hg > xemacs-beta

comparison src/mule-canna.c @ 70:131b0175ea99 r20-0b30

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Import from CVS: tag r20-0b30
author cvs
date Mon, 13 Aug 2007 09:02:59 +0200
parents
children 54cc21c15cbb
comparison
equal deleted inserted replaced
69:804d1389bcd6 70:131b0175ea99
1 /* CANNA interface
2
3 Copyright (C) 1995 Free Software Foundation, Inc.
4 Copyright (C) 1995 Sun Microsystems, Inc.
5
6 This file is part of XEmacs.
7
8 XEmacs is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any
11 later version.
12
13 XEmacs is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with XEmacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
22
23 /* Synched up with: Mule 2.3. Not in FSF. */
24
25 /* #### The comments in this file are mostly in EUC-formatted Japanese.
26 It would be ***soooo*** much nicer if someone could translate
27 them ... */
28
29 /*
30
31 Authors: Akira Kon (kon@d1.bs2.mt.nec.co.jp)
32 Ichiro Hirakura (hirakura@uxp.bs2.mt.nec.co.jp)
33
34 Functions defined in this file are
35
36 (canna-key-proc key)
37 key: single STRING
38 RETURNS:
39 Length of converted string if no error occurs.
40 Error string if error occurs.
41 DESCRIPTION:
42 Convert a key input to a set of strings. The
43 strings contain both well-formed string and a
44 intermediate result to show the translation
45 information to a user. converted strings are
46 stored in specific variables.
47
48 (canna-initialize)
49 RETURNS:
50 List of the following things:
51 - list of keys to toggle Japanese-mode
52 - error message
53 - list of warning messages
54 DESCRIPTION:
55 Initialize ``canna'', which is a kana-to-kanji
56 converter for GNU Emacs. The first arg
57 specifies if inserting space character between
58 BUNSETSU when candidates are displayed. The
59 second arg specifies server. The third arg
60 specifies a file which will be used as a
61 customization description. If nil is
62 specified for each arg, the default value will
63 be used.
64
65 (canna-finalize)
66 RETURNS:
67 list of warning messages
68 DESCRIPTION:
69 finalize ``canna'', which is a kana-to-kanji
70 converter for GNU Emacs. This cause to write
71 miscellaneous informations to kana-to-kanji
72 dictionary.
73
74 (canna-touroku-string string)
75 string:
76 String to register to a dictionary.
77 RETURNS:
78 The same thing returns as canna-key-proc does.
79 DESCRIPTION:
80 Register Kanji words into kana-to-kanji
81 conversion dictionary.
82
83 (canna-set-width width)
84 width:
85 Column width of the place where the candidates
86 of kana-to-kanji conversion will be shown.
87 RETURNS:
88 nil
89 DESCRIPTION:
90 Set status-line width information, which is
91 used to display kanji candidates.
92
93 (canna-change-mode num)
94 num:
95 The mode number of Canna.
96 RETURNS:
97 The same thing returns as canna-key-proc does.
98 DESCRIPTION:
99 Change Japanese pre-edit mode.
100
101 (canna-store-yomi yomi roma)
102 yomi:
103 ``Yomi'' to be stored.
104 roma:
105 ``Romaji'' which corresponds to the ``Yomi''.
106 RETURNS:
107 The same thing returns as canna-key-proc does.
108 DESCRIPTION:
109 Store yomi characters as a YOMI of
110 kana-to-kanji conversion.
111
112 (canna-do-function num ch)
113 num:
114 A function number to be called.
115 ch:
116 A character will be specified in order to feed
117 the character to the function if the function
118 needs a input character.
119 RETURNS:
120 The same thing returns as canna-key-proc does.
121 DESCRIPTION:
122 Do specified function at current mode.
123
124 (canna-parse string)
125 string:
126 To be parsed.
127 RETURNS:
128 List of warning messages.
129 DESCRIPTION:
130 Parse customize string.
131
132 (canna-query-mode)
133 RETURNS:
134 A string which indicate the current mode.
135 DESCRIPTION:
136 Get current mode string.
137
138 Functions below are used for KKCP compatible library. These
139 functions provides a base kana-to-kanji conversion system for EGG.
140 These functions may be used when users want to change the engine
141 from Wnn to Canna without changing user interface of Japanese input.
142
143 (canna-henkan-begin)
144 (canna-henkan-next)
145 (canna-bunsetu-henkou)
146 (canna-henkan-kakutei)
147 (canna-henkan-end)
148 (canna-henkan-quit)
149
150 */
151
152 #include <config.h>
153 #include "lisp.h"
154
155 #include "buffer.h"
156 #include "mule-coding.h"
157
158 #ifdef CANNA2
159 #define IROHA_BC
160 #include "canna/jrkanji.h"
161 #include "canna/RK.h"
162 #else /* !CANNA2 */
163 #include "iroha/jrkanji.h"
164 #include "iroha/RK.h"
165 #endif /* !CANNA2 */
166 extern char *jrKanjiError;
167
168 #define KEYTOSTRSIZE 2048
169 static unsigned char buf[KEYTOSTRSIZE];
170 static char **warning;
171
172 static int Vcanna_empty_info, Vcanna_through_info;
173 static int Vcanna_underline;
174 static int Vcanna_inhibit_hankakukana;
175
176 static Lisp_Object Vcanna_kakutei_string;
177 static Lisp_Object Vcanna_kakutei_yomi;
178 static Lisp_Object Vcanna_kakutei_romaji;
179 static Lisp_Object Vcanna_henkan_string;
180 static int Vcanna_henkan_length;
181 static int Vcanna_henkan_revPos;
182 static int Vcanna_henkan_revLen;
183 static Lisp_Object Vcanna_ichiran_string;
184 static int Vcanna_ichiran_length;
185 static int Vcanna_ichiran_revPos;
186 static int Vcanna_ichiran_revLen;
187 static Lisp_Object Vcanna_mode_string;
188
189 static int IRCP_context;
190
191 static Lisp_Object storeResults (unsigned char *, int, jrKanjiStatus *);
192 static Lisp_Object kanjiYomiList (int, int);
193
194 #ifdef CANNA_MULE
195 static void m2c (unsigned char *, int, unsigned char *);
196 static Lisp_Object mule_make_string (unsigned char *, int);
197 static mule_strlen (unsigned char *, int);
198 static count_char (unsigned char *,int, int, int, int *, int *, int *);
199 #define make_string mule_make_string
200 #endif
201
202 /* Lisp functions definition */
203
204 DEFUN ("canna-key-proc", Fcanna_key_proc, 1, 1, 0, /*
205 Translate a key input to a set of strings. The strings contain both
206 well-formed string and intermediate result to show the translation
207 information to a user. Converted strings are stored in specific
208 variables.
209 */
210 (ch))
211 {
212 jrKanjiStatus ks;
213 int len;
214
215 CHECK_CHAR (ch);
216 len = jrKanjiString (0, XCHAR (ch), buf, KEYTOSTRSIZE, &ks);
217 return storeResults (buf, len, &ks);
218 }
219
220 static Lisp_Object
221 storeResults (unsigned char *buf, int len, jrKanjiStatus *ks)
222 {
223 Lisp_Object val = Qnil;
224
225 if (len < 0)
226 { /* Error detected */
227 val = make_string ((unsigned char*) jrKanjiError, strlen (jrKanjiError));
228 }
229 else
230 {
231 /* 確定した文字列 */
232 Vcanna_kakutei_string = make_string (buf, len);
233 val = make_int (len);
234 /* 確定した文字列の読みの情報... */
235 Vcanna_kakutei_yomi = Vcanna_kakutei_romaji = Qnil;
236 if (ks->info & KanjiYomiInfo)
237 {
238 unsigned char *p = buf + len + 1;
239 int yomilen = strlen (p);
240
241 if (len + yomilen + 1 < KEYTOSTRSIZE)
242 {
243 int yomilen2;
244
245 Vcanna_kakutei_yomi = make_string (p, yomilen); /* 読み */
246 p += yomilen + 1;
247 yomilen2 = strlen (p);
248 if (len + yomilen + yomilen2 + 2 < KEYTOSTRSIZE)
249 {
250 Vcanna_kakutei_romaji = make_string (p, yomilen2); /* ローマ字 */
251 }
252 }
253 }
254
255
256 /* 候補表示の文字列です。*/
257 Vcanna_henkan_string = Qnil;
258 if (ks->length >= 0)
259 {
260 Vcanna_henkan_string = make_string (ks->echoStr, ks->length);
261 #ifndef CANNA_MULE
262 Vcanna_henkan_length = ks->length;
263 Vcanna_henkan_revPos = ks->revPos;
264 Vcanna_henkan_revLen = ks->revLen;
265 #else /* CANNA_MULE */
266 if (Vcanna_underline)
267 {
268 Vcanna_henkan_length = mule_strlen (ks->echoStr,ks->length);
269 Vcanna_henkan_revPos = mule_strlen (ks->echoStr,ks->revPos);
270 Vcanna_henkan_revLen = mule_strlen (ks->echoStr+ks->revPos,ks->revLen);
271 }
272 else
273 {
274 count_char (ks->echoStr, ks->length, ks->revPos, ks->revLen,
275 &Vcanna_henkan_length, &Vcanna_henkan_revPos,
276 &Vcanna_henkan_revLen);
277 }
278 #endif /* CANNA_MULE */
279 }
280
281 /* 一覧の情報 */
282 Vcanna_ichiran_string = Qnil;
283 if (ks->info & KanjiGLineInfo && ks->gline.length >= 0)
284 {
285 Vcanna_ichiran_string = make_string (ks->gline.line, ks->gline.length);
286 #ifndef CANNA_MULE
287 Vcanna_ichiran_length = ks->gline.length;
288 Vcanna_ichiran_revPos = ks->gline.revPos;
289 Vcanna_ichiran_revLen = ks->gline.revLen;
290 #else /* CANNA_MULE */
291 count_char (ks->gline.line, ks->gline.length,
292 ks->gline.revPos, ks->gline.revLen, &Vcanna_ichiran_length,
293 &Vcanna_ichiran_revPos, &Vcanna_ichiran_revLen);
294 #endif /* CANNA_MULE */
295 }
296
297 /* モードの情報 */
298 Vcanna_mode_string = Qnil;
299 if (ks->info & KanjiModeInfo)
300 {
301 Vcanna_mode_string = make_string (ks->mode, strlen (ks->mode));
302 }
303
304 /* その他の情報 */
305 Vcanna_empty_info = (ks->info & KanjiEmptyInfo) ? 1 : 0;
306 Vcanna_through_info = (ks->info & KanjiThroughInfo) ? 1 : 0;
307 }
308
309 return val;
310 }
311
312 DEFUN ("canna-set-bunsetsu-kugiri", Fcanna_set_bunsetsu, 0, 1, 0, /*
313 This function sets the clause separator.
314 If non-nil value is specified, the white space separator will be used.
315 No separator will be used otherwise.
316 */
317 (num))
318 {
319 int kugiri; /* 文節区切りをするか？ */
320
321 kugiri = NILP (num) ? 0 : 1;
322
323 jrKanjiControl (0, KC_SETBUNSETSUKUGIRI, (char *) kugiri);
324 }
325
326 DEFUN ("canna-initialize", Fcanna_initialize, 0, 3, 0, /*
327 Initialize ``canna'', which is a kana-to-kanji converter for GNU Emacs.
328 The first arg specifies if inserting space character between BUNSETSU when
329 candidates are displayed.
330 The second arg specifies server.
331 The third arg specifies a file which will be used as a customization
332 description.
333 If nil is specified for each arg, the default value will be used.
334 */
335 (num, server, rcfile))
336 {
337 Lisp_Object val;
338 int res;
339 unsigned char **p, **q;
340
341 int kugiri; /* 文節区切りをするか？ */
342
343 IRCP_context = -1;
344
345 if (NILP (num))
346 {
347 kugiri = 1;
348 }
349 else
350 {
351 CHECK_INT (num);
352 kugiri = XINT (num);
353 kugiri = (kugiri == 1) ? 1 : 0;
354 }
355
356 if (NILP (server))
357 {
358 jrKanjiControl (0, KC_SETSERVERNAME, (char *) 0);
359 }
360 else
361 {
362 char servername[256];
363
364 CHECK_STRING (server);
365 strncpy (servername, XSTRING (server)->_data, XSTRING (server)->_size);
366 servername[XSTRING (server)->_size] = '\0';
367 jrKanjiControl (0, KC_SETSERVERNAME, servername);
368 }
369
370 if (NILP (rcfile))
371 {
372 jrKanjiControl (0, KC_SETINITFILENAME, (char *) 0);
373 }
374 else
375 {
376 char rcname[256];
377
378 CHECK_STRING (rcfile);
379 strncpy (rcname, XSTRING (rcfile)->_data, XSTRING (rcfile)->_size);
380 rcname[XSTRING (rcfile)->_size] = '\0';
381 jrKanjiControl (0, KC_SETINITFILENAME, rcname);
382 }
383
384 warning = (char **) 0;
385 #ifdef nec_ews_svr4
386 stop_polling ();
387 #endif /* nec_ews_svr4 */
388 res = jrKanjiControl (0, KC_INITIALIZE, (char *)&warning);
389 #ifdef nec_ews_svr4
390 start_polling ();
391 #endif /* nec_ews_svr4 */
392 val = Qnil;
393 if (warning)
394 {
395 for (p = q = (unsigned char **) warning ; *q ; q++)
396 ;
397 while (p < q)
398 {
399 q--;
400 val = Fcons (make_string (*q, strlen (*q)), val);
401 }
402 }
403 val = Fcons (val, Qnil);
404
405 if (res == -1)
406 {
407 val = Fcons (make_string ((unsigned char*) jrKanjiError,
408 strlen (jrKanjiError)), val);
409 /* イニシャライズで失敗した場合。 */
410 return Fcons (Qnil, val);
411 }
412 else
413 {
414 extern (*jrBeepFunc)();
415 Lisp_Object Fding (), CANNA_mode_keys ();
416
417 jrBeepFunc = Fding;
418
419 #ifdef KC_SETAPPNAME
420 #ifndef CANNA_MULE
421 wcKanjiControl (0, KC_SETAPPNAME, "nemacs");
422 #else /* CANNA_MULE */
423 wcKanjiControl (0, KC_SETAPPNAME, "mule");
424 #endif /* CANNA_MULE */
425 #endif /* KC_SETAPPNAME */
426
427 jrKanjiControl (0, KC_SETBUNSETSUKUGIRI, (char *) kugiri);
428 jrKanjiControl (0, KC_SETWIDTH, (char *) 78);
429 #ifndef CANNA_MULE
430 jrKanjiControl (0, KC_INHIBITHANKAKUKANA, (char *) 1);
431 #else
432 /* mule だったら半角カタカナも使える */
433 if (Vcanna_inhibit_hankakukana)
434 jrKanjiControl (0, KC_INHIBITHANKAKUKANA, (char *) 1);
435 #endif
436 jrKanjiControl (0, KC_YOMIINFO, (char *) 2); /* ※２: ローマ字まで返す */
437 val = Fcons (Qnil, val);
438 return Fcons (CANNA_mode_keys (), val);
439 }
440 }
441
442 DEFUN ("canna-finalize", Fcanna_finalize, 0, 0, 0, /*
443 finalize ``canna'', which is a kana-to-kanji converter for GNU Emacs.
444 This cause to write miscellaneous informations to kana-to-kanji dictionary.
445 */
446 ())
447 {
448 Lisp_Object val;
449 unsigned char **p;
450
451 jrKanjiControl (0, KC_FINALIZE, (char *)&warning);
452
453 val = Qnil;
454 if (warning)
455 {
456 for (p = (unsigned char**) warning ; *p ; p++)
457 {
458 val = Fcons (make_string (*p, strlen (*p)), val);
459 }
460 }
461 val = Fcons (val, Qnil);
462 IRCP_context = -1;
463 return val;
464 }
465
466 DEFUN ("canna-touroku-string", Fcanna_touroku_string, 1, 1, 0, /*
467 Register Kanji words into kana-to-kanji conversion dictionary.
468 */
469 (str))
470 {
471 jrKanjiStatusWithValue ksv;
472 jrKanjiStatus ks;
473 int len;
474 Lisp_Object val;
475 #ifdef CANNA_MULE
476 unsigned char cbuf[4096];
477 #endif
478
479 CHECK_STRING (str);
480 ksv.buffer = (unsigned char *) buf;
481 ksv.bytes_buffer = KEYTOSTRSIZE;
482 #ifndef CANNA_MULE
483 ks.echoStr = XSTRING (str)->_data;
484 ks.length = XSTRING (str)->_size;
485 #else /* CANNA_MULE */
486 m2c (XSTRING (str)->_data, XSTRING (str)->_size, cbuf);
487 ks.echoStr = cbuf;
488 ks.length = strlen (cbuf);
489 #endif /* CANNA_MULE */
490 ksv.ks = &ks;
491 len = jrKanjiControl (0, KC_DEFINEKANJI, (char *)&ksv);
492 val = storeResults (buf, ksv.val, ksv.ks);
493 return val;
494 }
495
496 DEFUN ("canna-set-width", Fcanna_set_width, 1, 1, 0, /*
497 Set status-line width information, which is used to display
498 kanji candidates.
499 */
500 (num))
501 {
502 CHECK_INT (num);
503
504 jrKanjiControl (0, KC_SETWIDTH, (char *) XINT (num));
505 return Qnil;
506 }
507
508 DEFUN ("canna-change-mode", Fcanna_change_mode, 1, 1, 0, /*
509 Change Japanese pre-edit mode.
510 */
511 (num))
512 {
513 jrKanjiStatusWithValue ksv;
514 jrKanjiStatus ks;
515 Lisp_Object val;
516
517 CHECK_INT (num);
518
519 ksv.buffer = (unsigned char *) buf;
520 ksv.bytes_buffer = KEYTOSTRSIZE;
521 ksv.ks = &ks;
522 ksv.val = XINT (num);
523 jrKanjiControl (0, KC_CHANGEMODE, (char *)&ksv);
524 val = storeResults (buf, ksv.val, ksv.ks);
525 return val;
526 }
527
528 Lisp_Object
529 CANNA_mode_keys (void)
530 {
531 #define CANNAWORKBUFSIZE 32
532 char xxx[CANNAWORKBUFSIZE];
533 Lisp_Object val;
534 int i, n;
535
536 n = jrKanjiControl (0, KC_MODEKEYS, xxx);
537 val = Qnil;
538 for (i = n ; i > 0 ;)
539 {
540 --i;
541 /* !!#### something fucked here */
542 val = Fcons (make_char ((int)(0xFF & (unsigned char) xxx[i])), val);
543 }
544 return val;
545 }
546
547 DEFUN ("canna-store-yomi", Fcanna_store_yomi, 1, 2, 0, /*
548 Store yomi characters as a YOMI of kana-to-kanji conversion.
549 */
550 (yomi, roma))
551 {
552 jrKanjiStatusWithValue ksv;
553 jrKanjiStatus ks;
554
555 CHECK_STRING (yomi);
556 #ifndef CANNA_MULE
557 strncpy (buf, XSTRING (yomi)->_data, XSTRING (yomi)->_size);
558 ks.length = XSTRING (yomi)->_size;
559 buf[ks.length] = '\0';
560 #else /* CANNA_MULE */
561 m2c (XSTRING (yomi)->_data, XSTRING (yomi)->_size, buf);
562 ks.length = strlen (buf);
563 #endif /* CANNA_MULE */
564
565 if (NILP (roma))
566 {
567 ks.mode = 0;
568 }
569 else
570 {
571 CHECK_STRING (roma);
572
573 #ifndef CANNA_MULE
574 strncpy (buf + XSTRING (yomi)->_size + 1, XSTRING (roma)->_data,
575 XSTRING (roma)->_size);
576 buf[XSTRING (yomi)->_size + 1 + XSTRING (roma)->_size] = '\0';
577 ks.mode = (unsigned char *)(buf + XSTRING (yomi)->_size + 1);
578 #else /* CANNA_MULE */
579 ks.mode = (unsigned char *)(buf + ks.length + 1);
580 m2c (XSTRING (roma)->_data, XSTRING (roma)->_size, ks.mode);
581 #endif /* CANNA_MULE */
582 }
583
584 ks.echoStr = (unsigned char *) buf;
585 ksv.buffer = (unsigned char *) buf; /* 返値用 */
586 ksv.bytes_buffer = KEYTOSTRSIZE;
587 ksv.ks = &ks;
588
589 jrKanjiControl (0, KC_STOREYOMI, (char *)&ksv);
590
591 return storeResults (buf, ksv.val, ksv.ks);
592 }
593
594 DEFUN ("canna-do-function", Fcanna_do_function, 1, 2, 0, /*
595 Do specified function at current mode.
596 */
597 (num, ch))
598 {
599 jrKanjiStatusWithValue ksv;
600 jrKanjiStatus ks;
601 Lisp_Object val;
602
603 CHECK_INT (num);
604
605 if (NILP (ch))
606 {
607 *buf = '@';
608 }
609 else
610 {
611 CHECK_CHAR (ch);
612 *buf = XCHAR (ch);
613 }
614
615 ksv.buffer = (unsigned char *) buf;
616 ksv.bytes_buffer = KEYTOSTRSIZE;
617 ksv.ks = &ks;
618 ksv.val = XINT (num);
619 jrKanjiControl (0, KC_DO, (char *) &ksv);
620 val = storeResults (buf, ksv.val, ksv.ks);
621 return val;
622 }
623
624 DEFUN ("canna-parse", Fcanna_parse, 1, 1, 0, /*
625 Parse customize string.
626 */
627 (str))
628 {
629 jrKanjiStatusWithValue ksv;
630 jrKanjiStatus ks;
631 Lisp_Object val;
632 unsigned char **p;
633 int n;
634
635 CHECK_STRING (str);
636
637 #ifndef CANNA_MULE
638 strncpy (buf, XSTRING (str)->_data, XSTRING (str)->_size);
639 buf[XSTRING (str)->_size] = '\0';
640 #else /* CANNA_MULE */
641 m2c (XSTRING (str)->_data, XSTRING (str)->_size, buf);
642 #endif /* CANNA_MULE */
643 p = (unsigned char**) buf;
644 n = jrKanjiControl (0, KC_PARSE, (char *) &p);
645 val = Qnil;
646 while (n > 0)
647 {
648 n--;
649 val = Fcons (make_string (p[n], strlen (p[n])), val);
650 }
651 return val;
652 }
653
654 DEFUN ("canna-query-mode", Fcanna_query_mode, 0, 0, 0, /*
655 Get current mode string.
656 */
657 ())
658 {
659 unsigned char buf[256];
660
661 jrKanjiControl (0, KC_QUERYMODE, buf);
662 return make_string (buf, strlen (buf));
663 }
664
665 /*
666 * Functions following this line are for KKCP interface compatible
667 * library. These functions may be used by MILK system.
668 */
669
670 #define RKBUFSIZE 1024
671
672 static unsigned char yomibuf[RKBUFSIZE];
673 static short kugiri[RKBUFSIZE / 2];
674
675 static int
676 confirmContext (void)
677 {
678 if (IRCP_context < 0)
679 {
680 int context;
681
682 if ((context = jrKanjiControl (0, KC_GETCONTEXT, (char *) 0)) == -1)
683 {
684 return 0;
685 }
686 IRCP_context = context;
687 }
688 return 1;
689 }
690
691 static int
692 byteLen (int bun, int len)
693 {
694 int i = 0, offset = 0, ch;
695
696 if (0 <= bun && bun < RKBUFSIZE)
697 {
698 offset = kugiri[bun];
699 }
700
701 while (len-- > 0 && (ch = (int) yomibuf[offset + i]))
702 {
703 i++;
704 if (ch & 0x80)
705 {
706 i++;
707 }
708 }
709 return i;
710 }
711
712 DEFUN ("canna-henkan-begin", Fcanna_henkan_begin, 1, 1, 0, /*
713 かな漢字変換した結果を返還する。文節切りがしてある。
714 */
715 (yomi))
716 {
717 int nbun;
718 Lisp_Object res;
719
720 CHECK_STRING (yomi);
721 if (confirmContext () == 0)
722 {
723 return Qnil;
724 }
725 #ifndef CANNA_MULE
726 strncpy (yomibuf, XSTRING (yomi)->_data, XSTRING (yomi)->_size);
727 yomibuf[XSTRING (yomi)->_size] = '\0';
728 nbun = RkBgnBun (IRCP_context, XSTRING (yomi)->_data, XSTRING (yomi)->_size,
729 (RK_XFER << RK_XFERBITS) | RK_KFER);
730 #else /* CANNA_MULE */
731 m2c (XSTRING (yomi)->_data, XSTRING (yomi)->_size, yomibuf);
732 nbun = RkBgnBun (IRCP_context, (char *) yomibuf, strlen (yomibuf),
733 (RK_XFER << RK_XFERBITS) | RK_KFER);
734 #endif /* CANNA_MULE */
735
736 return kanjiYomiList (IRCP_context, nbun);
737 }
738
739 static Lisp_Object
740 kanjiYomiList (int context, int nbun)
741 {
742 Lisp_Object val, res = Qnil;
743 unsigned char RkBuf[RKBUFSIZE];
744 int len, i, total;
745
746 for (i = nbun ; i > 0 ; )
747 {
748 i--;
749 RkGoTo (context, i);
750 len = RkGetKanji (context, RkBuf, RKBUFSIZE);
751 val = make_string (RkBuf, len);
752 len = RkGetYomi (context, RkBuf, RKBUFSIZE);
753 res = Fcons (Fcons (val, make_string (RkBuf, len)), res);
754 if (i < RKBUFSIZE / 2)
755 {
756 kugiri[i] = len;
757 }
758 }
759 for (i = 0, total = 0 ; i < nbun ; i++)
760 {
761 int temp = kugiri[i];
762 kugiri[i] = total;
763 total += temp;
764 }
765 return res;
766 }
767
768 DEFUN ("canna-henkan-next", Fcanna_henkan_next, 1, 1, 0, /*
769 候補一覧を求める。
770 */
771 (bunsetsu))
772 {
773 int i, nbun, slen, len;
774 unsigned char *p, RkBuf[RKBUFSIZE];
775 Lisp_Object res = Qnil, endp;
776
777 CHECK_INT (bunsetsu);
778 if (confirmContext () == 0)
779 {
780 return Qnil;
781 }
782 RkGoTo (IRCP_context, XINT (bunsetsu));
783 len = RkGetKanjiList (IRCP_context, RkBuf, RKBUFSIZE);
784 p = RkBuf;
785 for (i = 0 ; i < len ; i++)
786 {
787 slen = strlen (p);
788 if (res == Qnil)
789 {
790 endp = res = Fcons (make_string (p, slen), Qnil);
791 }
792 else
793 {
794 endp = XCONS (endp)->cdr = Fcons (make_string (p, slen), Qnil);
795 }
796 p += slen + 1;
797 }
798 return res;
799 }
800
801 DEFUN ("canna-bunsetu-henkou", Fcanna_bunsetu_henkou, 2, 2, 0, /*
802 文節の長さを指定する。
803 */
804 (bunsetsu, bunlen))
805 {
806 int nbun, len;
807
808 CHECK_INT (bunsetsu);
809 CHECK_INT (bunlen);
810
811 nbun = XINT (bunsetsu);
812 if (confirmContext () == 0)
813 {
814 return Qnil;
815 }
816 RkGoTo (IRCP_context, nbun);
817 len = byteLen (nbun, XINT (bunlen));
818 return kanjiYomiList (IRCP_context, RkResize (IRCP_context, len));
819 }
820
821 DEFUN ("canna-henkan-kakutei", Fcanna_henkan_kakutei, 2, 2, 0, /*
822 候補選択。
823 */
824 (bun, kouho))
825 {
826 if (confirmContext () == 0)
827 {
828 return Qnil;
829 }
830 RkGoTo (IRCP_context, bun);
831 RkXfer (IRCP_context, kouho);
832 return Qt;
833 }
834
835 DEFUN ("canna-henkan-end", Fcanna_henkan_end, 0, 0, 0, /*
836 変換終了。
837 */
838 ())
839 {
840 if (confirmContext () == 0)
841 {
842 return Qnil;
843 }
844 RkEndBun (IRCP_context, 1); /* 学習はいつでも行って良いものなのか？ */
845 return Qt;
846 }
847
848 DEFUN ("canna-henkan-quit", Fcanna_henkan_quit, 0, 0, 0, /*
849 変換終了。
850 */
851 ())
852 {
853 if (confirmContext () == 0)
854 {
855 return Qnil;
856 }
857 RkEndBun (IRCP_context, 0);
858 return Qt;
859 }
860
861 /* variables below this line is constants of Canna */
862
863 static int Vcanna_mode_AlphaMode = IROHA_MODE_AlphaMode;
864 static int Vcanna_mode_EmptyMode = IROHA_MODE_EmptyMode;
865 static int Vcanna_mode_KigoMode = IROHA_MODE_KigoMode;
866 static int Vcanna_mode_YomiMode = IROHA_MODE_YomiMode;
867 static int Vcanna_mode_JishuMode = IROHA_MODE_JishuMode;
868 static int Vcanna_mode_TankouhoMode = IROHA_MODE_TankouhoMode;
869 static int Vcanna_mode_IchiranMode = IROHA_MODE_IchiranMode;
870 static int Vcanna_mode_YesNoMode = IROHA_MODE_YesNoMode;
871 static int Vcanna_mode_OnOffMode = IROHA_MODE_OnOffMode;
872 #ifdef CANNA_MODE_AdjustBunsetsuMode
873 static int Vcanna_mode_AdjustBunsetsuMode = CANNA_MODE_AdjustBunsetsuMode;
874 #endif
875 #ifdef CANNA_MODE_ChikujiYomiMode
876 static int Vcanna_mode_ChikujiYomiMode = CANNA_MODE_ChikujiYomiMode;
877 static int Vcanna_mode_ChikujiTanMode = CANNA_MODE_ChikujiTanMode;
878 #endif
879
880 static int Vcanna_mode_HenkanMode = IROHA_MODE_HenkanMode;
881 #ifdef CANNA_MODE_HenkanNyuryokuMode
882 static int Vcanna_mode_HenkanNyuryokuMode = CANNA_MODE_HenkanNyuryokuMode;
883 #endif
884 #ifdef CANNA_MODE_ZenHiraHenkanMode
885 static int Vcanna_mode_ZenHiraHenkanMode = CANNA_MODE_ZenHiraHenkanMode;
886 #ifdef CANNA_MODE_HanHiraHenkanMode
887 static int Vcanna_mode_HanHiraHenkanMode = CANNA_MODE_HanHiraHenkanMode;
888 #endif
889 static int Vcanna_mode_ZenKataHenkanMode = CANNA_MODE_ZenKataHenkanMode;
890 static int Vcanna_mode_HanKataHenkanMode = CANNA_MODE_HanKataHenkanMode;
891 static int Vcanna_mode_ZenAlphaHenkanMode = CANNA_MODE_ZenAlphaHenkanMode;
892 static int Vcanna_mode_HanAlphaHenkanMode = CANNA_MODE_HanAlphaHenkanMode;
893 #endif
894 static int Vcanna_mode_ZenHiraKakuteiMode = IROHA_MODE_ZenHiraKakuteiMode;
895 #ifdef CANNA_MODE_HanHiraKakuteiMode
896 static int Vcanna_mode_HanHiraKakuteiMode = CANNA_MODE_HanHiraKakuteiMode;
897 #endif
898 static int Vcanna_mode_ZenKataKakuteiMode = IROHA_MODE_ZenKataKakuteiMode;
899 static int Vcanna_mode_HanKataKakuteiMode = IROHA_MODE_HanKataKakuteiMode;
900 static int Vcanna_mode_ZenAlphaKakuteiMode = IROHA_MODE_ZenAlphaKakuteiMode;
901 static int Vcanna_mode_HanAlphaKakuteiMode = IROHA_MODE_HanAlphaKakuteiMode;
902 static int Vcanna_mode_HexMode = IROHA_MODE_HexMode;
903 static int Vcanna_mode_BushuMode = IROHA_MODE_BushuMode;
904 static int Vcanna_mode_ExtendMode = IROHA_MODE_ExtendMode;
905 static int Vcanna_mode_RussianMode = IROHA_MODE_RussianMode;
906 static int Vcanna_mode_GreekMode = IROHA_MODE_GreekMode;
907 static int Vcanna_mode_LineMode = IROHA_MODE_LineMode;
908 static int Vcanna_mode_ChangingServerMode = IROHA_MODE_ChangingServerMode;
909 static int Vcanna_mode_HenkanMethodMode = IROHA_MODE_HenkanMethodMode;
910 static int Vcanna_mode_DeleteDicMode = IROHA_MODE_DeleteDicMode;
911 static int Vcanna_mode_TourokuMode = IROHA_MODE_TourokuMode;
912 static int Vcanna_mode_TourokuEmptyMode = IROHA_MODE_TourokuEmptyMode;
913 static int Vcanna_mode_TourokuHinshiMode = IROHA_MODE_TourokuHinshiMode;
914 static int Vcanna_mode_TourokuDicMode = IROHA_MODE_TourokuDicMode;
915 static int Vcanna_mode_QuotedInsertMode = IROHA_MODE_QuotedInsertMode;
916 static int Vcanna_mode_BubunMuhenkanMode = IROHA_MODE_BubunMuhenkanMode;
917 static int Vcanna_mode_MountDicMode = IROHA_MODE_MountDicMode;
918
919 static int Vcanna_fn_SelfInsert = IROHA_FN_SelfInsert;
920 static int Vcanna_fn_FunctionalInsert = IROHA_FN_FunctionalInsert;
921 static int Vcanna_fn_QuotedInsert = IROHA_FN_QuotedInsert;
922 static int Vcanna_fn_JapaneseMode = IROHA_FN_JapaneseMode;
923 static int Vcanna_fn_AlphaMode = IROHA_FN_AlphaMode;
924 static int Vcanna_fn_HenkanNyuryokuMode = IROHA_FN_HenkanNyuryokuMode;
925 static int Vcanna_fn_Forward = IROHA_FN_Forward;
926 static int Vcanna_fn_Backward = IROHA_FN_Backward;
927 static int Vcanna_fn_Next = IROHA_FN_Next;
928 static int Vcanna_fn_Prev = IROHA_FN_Prev;
929 static int Vcanna_fn_BeginningOfLine = IROHA_FN_BeginningOfLine;
930 static int Vcanna_fn_EndOfLine = IROHA_FN_EndOfLine;
931 static int Vcanna_fn_DeleteNext = IROHA_FN_DeleteNext;
932 static int Vcanna_fn_DeletePrevious = IROHA_FN_DeletePrevious;
933 static int Vcanna_fn_KillToEndOfLine = IROHA_FN_KillToEndOfLine;
934 static int Vcanna_fn_Henkan = IROHA_FN_Henkan;
935 static int Vcanna_fn_Kakutei = IROHA_FN_Kakutei;
936 static int Vcanna_fn_Extend = IROHA_FN_Extend;
937 static int Vcanna_fn_Shrink = IROHA_FN_Shrink;
938 #ifdef CANNA_FN_AdjustBunsetsu
939 static int Vcanna_fn_AdjustBunsetsu = CANNA_FN_AdjustBunsetsu;
940 #endif
941 static int Vcanna_fn_Quit = IROHA_FN_Quit;
942 static int Vcanna_fn_ConvertAsHex = IROHA_FN_ConvertAsHex;
943 static int Vcanna_fn_ConvertAsBushu = IROHA_FN_ConvertAsBushu;
944 static int Vcanna_fn_KouhoIchiran = IROHA_FN_KouhoIchiran;
945 static int Vcanna_fn_BubunMuhenkan = IROHA_FN_BubunMuhenkan;
946 static int Vcanna_fn_Zenkaku = IROHA_FN_Zenkaku;
947 static int Vcanna_fn_Hankaku = IROHA_FN_Hankaku;
948 static int Vcanna_fn_ToUpper = IROHA_FN_ToUpper;
949 static int Vcanna_fn_Capitalize = IROHA_FN_Capitalize;
950 static int Vcanna_fn_ToLower = IROHA_FN_ToLower;
951 static int Vcanna_fn_Hiragana = IROHA_FN_Hiragana;
952 static int Vcanna_fn_Katakana = IROHA_FN_Katakana;
953 static int Vcanna_fn_Romaji = IROHA_FN_Romaji;
954 #ifdef CANNA_FN_BaseHiragana
955 static int Vcanna_fn_BaseHiragana = CANNA_FN_BaseHiragana;
956 static int Vcanna_fn_BaseKatakana = CANNA_FN_BaseKatakana;
957 static int Vcanna_fn_BaseEisu = CANNA_FN_BaseEisu;
958 static int Vcanna_fn_BaseZenkaku = CANNA_FN_BaseZenkaku;
959 static int Vcanna_fn_BaseHankaku = CANNA_FN_BaseHankaku;
960 static int Vcanna_fn_BaseKana = CANNA_FN_BaseKana;
961 static int Vcanna_fn_BaseKakutei = CANNA_FN_BaseKakutei;
962 static int Vcanna_fn_BaseHenkan = CANNA_FN_BaseHenkan;
963 static int Vcanna_fn_BaseHiraKataToggle = CANNA_FN_BaseHiraKataToggle;
964 static int Vcanna_fn_BaseZenHanToggle = CANNA_FN_BaseZenHanToggle;
965 static int Vcanna_fn_BaseKanaEisuToggle = CANNA_FN_BaseKanaEisuToggle;
966 static int Vcanna_fn_BaseKakuteiHenkanToggle =
967 CANNA_FN_BaseKakuteiHenkanToggle;
968 static int Vcanna_fn_BaseRotateForward = CANNA_FN_BaseRotateForward;
969 static int Vcanna_fn_BaseRotateBackward = CANNA_FN_BaseRotateBackward;
970 #endif
971 static int Vcanna_fn_ExtendMode = IROHA_FN_ExtendMode;
972 static int Vcanna_fn_Touroku = IROHA_FN_Touroku;
973 static int Vcanna_fn_HexMode = IROHA_FN_HexMode;
974 static int Vcanna_fn_BushuMode = IROHA_FN_BushuMode;
975 static int Vcanna_fn_KigouMode = IROHA_FN_KigouMode;
976 #ifdef CANNA_FN_Mark
977 static int Vcanna_fn_Mark = CANNA_FN_Mark;
978 #endif
979 #ifdef CANNA_FN_TemporalMode
980 static int Vcanna_fn_TemporalMode = CANNA_FN_TemporalMode;
981 #endif
982
983 static int Vcanna_key_Nfer = IROHA_KEY_Nfer;
984 static int Vcanna_key_Xfer = IROHA_KEY_Xfer;
985 static int Vcanna_key_Up = IROHA_KEY_Up;
986 static int Vcanna_key_Left = IROHA_KEY_Left;
987 static int Vcanna_key_Right = IROHA_KEY_Right;
988 static int Vcanna_key_Down = IROHA_KEY_Down;
989 static int Vcanna_key_Insert = IROHA_KEY_Insert;
990 static int Vcanna_key_Rollup = IROHA_KEY_Rollup;
991 static int Vcanna_key_Rolldown = IROHA_KEY_Rolldown;
992 static int Vcanna_key_Home = IROHA_KEY_Home;
993 static int Vcanna_key_Help = IROHA_KEY_Help;
994 static int Vcanna_key_KP_Key = IROHA_KEY_KP_Key;
995 static int Vcanna_key_Shift_Nfer = IROHA_KEY_Shift_Nfer;
996 static int Vcanna_key_Shift_Xfer = IROHA_KEY_Shift_Xfer;
997 static int Vcanna_key_Shift_Up = IROHA_KEY_Shift_Up;
998 static int Vcanna_key_Shift_Left = IROHA_KEY_Shift_Left;
999 static int Vcanna_key_Shift_Right = IROHA_KEY_Shift_Right;
1000 static int Vcanna_key_Shift_Down = IROHA_KEY_Shift_Down;
1001 static int Vcanna_key_Cntrl_Nfer = IROHA_KEY_Cntrl_Nfer;
1002 static int Vcanna_key_Cntrl_Xfer = IROHA_KEY_Cntrl_Xfer;
1003 static int Vcanna_key_Cntrl_Up = IROHA_KEY_Cntrl_Up;
1004 static int Vcanna_key_Cntrl_Left = IROHA_KEY_Cntrl_Left;
1005 static int Vcanna_key_Cntrl_Right = IROHA_KEY_Cntrl_Right;
1006 static int Vcanna_key_Cntrl_Down = IROHA_KEY_Cntrl_Down;
1007
1008 Lisp_Object VCANNA; /* by MORIOKA Tomohiko <morioka@jaist.ac.jp>
1009 1996/6/7 */
1010
1011 void
1012 syms_of_mule_canna (void)
1013 {
1014 DEFVAR_LISP ("CANNA", &VCANNA); /* hir@nec, 1992.5.21 */
1015 VCANNA = Qt; /* hir@nec, 1992.5.21 */
1016
1017 DEFSUBR (Fcanna_key_proc);
1018 DEFSUBR (Fcanna_initialize);
1019 DEFSUBR (Fcanna_finalize);
1020 DEFSUBR (Fcanna_touroku_string);
1021 DEFSUBR (Fcanna_set_width);
1022 DEFSUBR (Fcanna_change_mode);
1023 DEFSUBR (Fcanna_store_yomi);
1024 DEFSUBR (Fcanna_do_function);
1025 DEFSUBR (Fcanna_parse);
1026 DEFSUBR (Fcanna_query_mode);
1027 DEFSUBR (Fcanna_set_bunsetsu);
1028
1029 DEFSUBR (Fcanna_henkan_begin);
1030 DEFSUBR (Fcanna_henkan_next);
1031 DEFSUBR (Fcanna_bunsetu_henkou);
1032 DEFSUBR (Fcanna_henkan_kakutei);
1033 DEFSUBR (Fcanna_henkan_end);
1034 DEFSUBR (Fcanna_henkan_quit);
1035 }
1036
1037 void
1038 vars_of_mule_canna (void)
1039 {
1040 DEFVAR_LISP ("canna-kakutei-string", &Vcanna_kakutei_string /*
1041
1042 */ );
1043 DEFVAR_LISP ("canna-kakutei-yomi", &Vcanna_kakutei_yomi /*
1044
1045 */ );
1046 DEFVAR_LISP ("canna-kakutei-romaji", &Vcanna_kakutei_romaji /*
1047
1048 */ );
1049 DEFVAR_LISP ("canna-henkan-string", &Vcanna_henkan_string /*
1050
1051 */ );
1052 DEFVAR_INT ("canna-henkan-length", &Vcanna_henkan_length /*
1053
1054 */ );
1055 DEFVAR_INT ("canna-henkan-revpos", &Vcanna_henkan_revPos /*
1056
1057 */ );
1058 DEFVAR_INT ("canna-henkan-revlen", &Vcanna_henkan_revLen /*
1059
1060 */ );
1061 DEFVAR_LISP ("canna-ichiran-string", &Vcanna_ichiran_string /*
1062
1063 */ );
1064 DEFVAR_INT ("canna-ichiran-length", &Vcanna_ichiran_length /*
1065
1066 */ );
1067 DEFVAR_INT ("canna-ichiran-revpos", &Vcanna_ichiran_revPos /*
1068
1069 */ );
1070 DEFVAR_INT ("canna-ichiran-revlen", &Vcanna_ichiran_revLen /*
1071
1072 */ );
1073 DEFVAR_LISP ("canna-mode-string", &Vcanna_mode_string /*
1074
1075 */ );
1076
1077 DEFVAR_BOOL ("canna-empty-info", &Vcanna_empty_info /*
1078 For canna
1079 */ );
1080 DEFVAR_BOOL ("canna-through-info", &Vcanna_through_info /*
1081 For canna
1082 */ );
1083 DEFVAR_BOOL ("canna-underline", &Vcanna_underline /*
1084 For canna
1085 */ );
1086 DEFVAR_BOOL ("canna-inhibit-hankakukana", &Vcanna_inhibit_hankakukana /*
1087 For canna
1088 */ );
1089
1090 DEFVAR_INT ("canna-mode-alpha-mode", &Vcanna_mode_AlphaMode /*
1091
1092 */ );
1093 DEFVAR_INT ("canna-mode-empty-mode", &Vcanna_mode_EmptyMode /*
1094
1095 */ );
1096 DEFVAR_INT ("canna-mode-kigo-mode", &Vcanna_mode_KigoMode /*
1097
1098 */ );
1099 DEFVAR_INT ("canna-mode-yomi-mode", &Vcanna_mode_YomiMode /*
1100
1101 */ );
1102 DEFVAR_INT ("canna-mode-jishu-mode", &Vcanna_mode_JishuMode /*
1103
1104 */ );
1105 DEFVAR_INT ("canna-mode-tankouho-mode", &Vcanna_mode_TankouhoMode /*
1106
1107 */ );
1108 DEFVAR_INT ("canna-mode-ichiran-mode", &Vcanna_mode_IchiranMode /*
1109
1110 */ );
1111 DEFVAR_INT ("canna-mode-yes-no-mode", &Vcanna_mode_YesNoMode /*
1112
1113 */ );
1114 DEFVAR_INT ("canna-mode-on-off-mode", &Vcanna_mode_OnOffMode /*
1115
1116 */ );
1117 #ifdef CANNA_MODE_AdjustBunsetsuMode
1118 DEFVAR_INT ("canna-mode-adjust-bunsetsu-mode",
1119 &Vcanna_mode_AdjustBunsetsuMode /*
1120
1121 */ );
1122 #endif
1123 #ifdef CANNA_MODE_ChikujiYomiMode
1124 DEFVAR_INT ("canna-mode-chikuji-yomi-mode", &Vcanna_mode_ChikujiYomiMode /*
1125
1126 */ );
1127 DEFVAR_INT ("canna-mode-chikuji-bunsetsu-mode",
1128 &Vcanna_mode_ChikujiTanMode /*
1129
1130 */ );
1131 #endif
1132
1133 DEFVAR_INT ("canna-mode-henkan-mode", &Vcanna_mode_HenkanMode /*
1134
1135 */ );
1136 #ifdef CANNA_MODE_HenkanNyuryokuMode
1137 DEFVAR_INT ("canna-mode-henkan-nyuuryoku-mode",
1138 &Vcanna_mode_HenkanNyuryokuMode /*
1139
1140 */ );
1141 #endif
1142 #ifdef CANNA_MODE_ZenHiraHenkanMode
1143 DEFVAR_INT ("canna-mode-zen-hira-henkan-mode",
1144 &Vcanna_mode_ZenHiraHenkanMode /*
1145
1146 */ );
1147 #ifdef CANNA_MODE_HanHiraHenkanMode
1148 DEFVAR_INT ("canna-mode-han-hira-henkan-mode",
1149 &Vcanna_mode_HanHiraHenkanMode /*
1150
1151 */ );
1152 #endif
1153 DEFVAR_INT ("canna-mode-zen-kata-henkan-mode",
1154 &Vcanna_mode_ZenKataHenkanMode /*
1155
1156 */ );
1157 DEFVAR_INT ("canna-mode-han-kata-henkan-mode",
1158 &Vcanna_mode_HanKataHenkanMode /*
1159
1160 */ );
1161 DEFVAR_INT ("canna-mode-zen-alpha-henkan-mode",
1162 &Vcanna_mode_ZenAlphaHenkanMode /*
1163
1164 */ );
1165 DEFVAR_INT ("canna-mode-han-alpha-henkan-mode",
1166 &Vcanna_mode_HanAlphaHenkanMode /*
1167
1168 */ );
1169 #endif
1170 DEFVAR_INT ("canna-mode-zen-hira-kakutei-mode",
1171 &Vcanna_mode_ZenHiraKakuteiMode /*
1172
1173 */ );
1174 #ifdef CANNA_MODE_HanHiraKakuteiMode
1175 DEFVAR_INT ("canna-mode-han-hira-kakutei-mode",
1176 &Vcanna_mode_HanHiraKakuteiMode /*
1177
1178 */ );
1179 #endif
1180 DEFVAR_INT ("canna-mode-zen-kata-kakutei-mode",
1181 &Vcanna_mode_ZenKataKakuteiMode /*
1182
1183 */ );
1184 DEFVAR_INT ("canna-mode-han-kata-kakutei-mode",
1185 &Vcanna_mode_HanKataKakuteiMode /*
1186
1187 */ );
1188 DEFVAR_INT ("canna-mode-zen-alpha-kakutei-mode",
1189 &Vcanna_mode_ZenAlphaKakuteiMode /*
1190
1191 */ );
1192 DEFVAR_INT ("canna-mode-han-alpha-kakutei-mode",
1193 &Vcanna_mode_HanAlphaKakuteiMode /*
1194
1195 */ );
1196 DEFVAR_INT ("canna-mode-hex-mode", &Vcanna_mode_HexMode /*
1197
1198 */ );
1199 DEFVAR_INT ("canna-mode-bushu-mode", &Vcanna_mode_BushuMode /*
1200
1201 */ );
1202 DEFVAR_INT ("canna-mode-extend-mode", &Vcanna_mode_ExtendMode /*
1203
1204 */ );
1205 DEFVAR_INT ("canna-mode-russian-mode", &Vcanna_mode_RussianMode /*
1206
1207 */ );
1208 DEFVAR_INT ("canna-mode-greek-mode", &Vcanna_mode_GreekMode /*
1209
1210 */ );
1211 DEFVAR_INT ("canna-mode-line-mode", &Vcanna_mode_LineMode /*
1212
1213 */ );
1214 DEFVAR_INT ("canna-mode-changing-server-mode",
1215 &Vcanna_mode_ChangingServerMode /*
1216
1217 */ );
1218 DEFVAR_INT ("canna-mode-henkan-method-mode",
1219 &Vcanna_mode_HenkanMethodMode /*
1220
1221 */ );
1222 DEFVAR_INT ("canna-mode-delete-dic-mode", &Vcanna_mode_DeleteDicMode /*
1223
1224 */ );
1225 DEFVAR_INT ("canna-mode-touroku-mode", &Vcanna_mode_TourokuMode /*
1226
1227 */ );
1228 DEFVAR_INT ("canna-mode-touroku-empty-mode",
1229 &Vcanna_mode_TourokuEmptyMode /*
1230
1231 */ );
1232 DEFVAR_INT ("canna-mode-touroku-hinshi-mode",
1233 &Vcanna_mode_TourokuHinshiMode /*
1234
1235 */ );
1236 DEFVAR_INT ("canna-mode-touroku-dic-mode", &Vcanna_mode_TourokuDicMode /*
1237
1238 */ );
1239 DEFVAR_INT ("canna-mode-quoted-insert-mode",
1240 &Vcanna_mode_QuotedInsertMode /*
1241
1242 */ );
1243 DEFVAR_INT ("canna-mode-bubun-muhenkan-mode",
1244 &Vcanna_mode_BubunMuhenkanMode /*
1245
1246 */ );
1247 DEFVAR_INT ("canna-mode-mount-dic-mode", &Vcanna_mode_MountDicMode /*
1248
1249 */ );
1250
1251 DEFVAR_INT ("canna-func-self-insert", &Vcanna_fn_SelfInsert /*
1252
1253 */ );
1254 DEFVAR_INT ("canna-func-functional-insert", &Vcanna_fn_FunctionalInsert /*
1255
1256 */ );
1257 DEFVAR_INT ("canna-func-quoted-insert", &Vcanna_fn_QuotedInsert /*
1258
1259 */ );
1260 DEFVAR_INT ("canna-func-japanese-mode", &Vcanna_fn_JapaneseMode /*
1261
1262 */ );
1263 DEFVAR_INT ("canna-func-alpha-mode", &Vcanna_fn_AlphaMode /*
1264
1265 */ );
1266 DEFVAR_INT ("canna-func-henkan-nyuryoku-mode",
1267 &Vcanna_fn_HenkanNyuryokuMode /*
1268
1269 */ );
1270 DEFVAR_INT ("canna-func-forward", &Vcanna_fn_Forward /*
1271
1272 */ );
1273 DEFVAR_INT ("canna-func-backward", &Vcanna_fn_Backward /*
1274
1275 */ );
1276 DEFVAR_INT ("canna-func-next", &Vcanna_fn_Next /*
1277
1278 */ );
1279 DEFVAR_INT ("canna-func-previous", &Vcanna_fn_Prev /*
1280
1281 */ );
1282 DEFVAR_INT ("canna-func-beginning-of-line", &Vcanna_fn_BeginningOfLine /*
1283
1284 */ );
1285 DEFVAR_INT ("canna-func-end-of-line", &Vcanna_fn_EndOfLine /*
1286
1287 */ );
1288 DEFVAR_INT ("canna-func-delete-next", &Vcanna_fn_DeleteNext /*
1289
1290 */ );
1291 DEFVAR_INT ("canna-func-delete_previous", &Vcanna_fn_DeletePrevious /*
1292
1293 */ );
1294 DEFVAR_INT ("canna-func-kill-to-end-of-line", &Vcanna_fn_KillToEndOfLine /*
1295
1296 */ );
1297 DEFVAR_INT ("canna-func-henkan", &Vcanna_fn_Henkan /*
1298
1299 */ );
1300 DEFVAR_INT ("canna-func-kakutei", &Vcanna_fn_Kakutei /*
1301
1302 */ );
1303 DEFVAR_INT ("canna-func-extend", &Vcanna_fn_Extend /*
1304
1305 */ );
1306 DEFVAR_INT ("canna-func-shrink", &Vcanna_fn_Shrink /*
1307
1308 */ );
1309 #ifdef CANNA_FN_AdjustBunsetsu
1310 DEFVAR_INT ("canna-func-adjust-bunsetsu", &Vcanna_fn_AdjustBunsetsu /*
1311
1312 */ );
1313 #endif
1314 DEFVAR_INT ("canna-func-quit", &Vcanna_fn_Quit /*
1315
1316 */ );
1317 DEFVAR_INT ("canna-func-convert-as-hex", &Vcanna_fn_ConvertAsHex /*
1318
1319 */ );
1320 DEFVAR_INT ("canna-func-convert-as-bushu", &Vcanna_fn_ConvertAsBushu /*
1321
1322 */ );
1323 DEFVAR_INT ("canna-func-kouho-ichiran", &Vcanna_fn_KouhoIchiran /*
1324
1325 */ );
1326 DEFVAR_INT ("canna-func-bubun-muhenkan", &Vcanna_fn_BubunMuhenkan /*
1327
1328 */ );
1329 DEFVAR_INT ("canna-func-zenkaku", &Vcanna_fn_Zenkaku /*
1330
1331 */ );
1332 DEFVAR_INT ("canna-func-hankaku", &Vcanna_fn_Hankaku /*
1333
1334 */ );
1335 DEFVAR_INT ("canna-func-to-upper", &Vcanna_fn_ToUpper /*
1336
1337 */ );
1338 DEFVAR_INT ("canna-func-capitalize", &Vcanna_fn_Capitalize /*
1339
1340 */ );
1341 DEFVAR_INT ("canna-func-to-lower", &Vcanna_fn_ToLower /*
1342
1343 */ );
1344 DEFVAR_INT ("canna-func-hiragana", &Vcanna_fn_Hiragana /*
1345
1346 */ );
1347 DEFVAR_INT ("canna-func-katakana", &Vcanna_fn_Katakana /*
1348
1349 */ );
1350 DEFVAR_INT ("canna-func-romaji", &Vcanna_fn_Romaji /*
1351
1352 */ );
1353 #ifdef CANNA_FN_BaseHiragana
1354 DEFVAR_INT ("canna-func-base-hiragana", &Vcanna_fn_BaseHiragana /*
1355
1356 */ );
1357 DEFVAR_INT ("canna-func-base-katakana", &Vcanna_fn_BaseKatakana /*
1358
1359 */ );
1360 DEFVAR_INT ("canna-func-base-eisu", &Vcanna_fn_BaseEisu /*
1361
1362 */ );
1363 DEFVAR_INT ("canna-func-base-zenkaku", &Vcanna_fn_BaseZenkaku /*
1364
1365 */ );
1366 DEFVAR_INT ("canna-func-base-hankaku", &Vcanna_fn_BaseHankaku /*
1367
1368 */ );
1369 DEFVAR_INT ("canna-func-base-kana", &Vcanna_fn_BaseKana /*
1370
1371 */ );
1372 DEFVAR_INT ("canna-func-base-kakutei", &Vcanna_fn_BaseKakutei /*
1373
1374 */ );
1375 DEFVAR_INT ("canna-func-base-henkan", &Vcanna_fn_BaseHenkan /*
1376
1377 */ );
1378 DEFVAR_INT ("canna-func-base-hiragana-katakana-toggle",
1379 &Vcanna_fn_BaseHiraKataToggle /*
1380
1381 */ );
1382 DEFVAR_INT ("canna-func-base-zenkaku-hankaku-toggle",
1383 &Vcanna_fn_BaseZenHanToggle /*
1384
1385 */ );
1386 DEFVAR_INT ("canna-func-base-kana-eisu-toggle",
1387 &Vcanna_fn_BaseKanaEisuToggle /*
1388
1389 */ );
1390 DEFVAR_INT ("canna-func-base-kakutei-henkan-toggle",
1391 &Vcanna_fn_BaseKakuteiHenkanToggle /*
1392
1393 */ );
1394 DEFVAR_INT ("canna-func-base-rotate-forward",
1395 &Vcanna_fn_BaseRotateForward /*
1396
1397 */ );
1398 DEFVAR_INT ("canna-func-base-rotate-backward",
1399 &Vcanna_fn_BaseRotateBackward /*
1400
1401 */ );
1402 #endif
1403 DEFVAR_INT ("canna-func-extend-mode", &Vcanna_fn_ExtendMode /*
1404
1405 */ );
1406 DEFVAR_INT ("canna-func-touroku", &Vcanna_fn_Touroku /*
1407
1408 */ );
1409 DEFVAR_INT ("canna-func-hex-mode", &Vcanna_fn_HexMode /*
1410
1411 */ );
1412 DEFVAR_INT ("canna-func-bushu-mode", &Vcanna_fn_BushuMode /*
1413
1414 */ );
1415 DEFVAR_INT ("canna-func-kigo-mode", &Vcanna_fn_KigouMode /*
1416
1417 */ );
1418 #ifdef CANNA_FN_Mark
1419 DEFVAR_INT ("canna-func-mark", &Vcanna_fn_Mark /*
1420
1421 */ );
1422 #endif
1423 #ifdef CANNA_FN_TemporalMode
1424 DEFVAR_INT ("canna-func-temporal-mode", &Vcanna_fn_TemporalMode /*
1425
1426 */ );
1427 #endif
1428
1429 DEFVAR_INT ("canna-key-nfer", &Vcanna_key_Nfer /*
1430
1431 */ );
1432 DEFVAR_INT ("canna-key-xfer", &Vcanna_key_Xfer /*
1433
1434 */ );
1435 DEFVAR_INT ("canna-key-up", &Vcanna_key_Up /*
1436
1437 */ );
1438 DEFVAR_INT ("canna-key-left", &Vcanna_key_Left /*
1439
1440 */ );
1441 DEFVAR_INT ("canna-key-right", &Vcanna_key_Right /*
1442
1443 */ );
1444 DEFVAR_INT ("canna-key-down", &Vcanna_key_Down /*
1445
1446 */ );
1447 DEFVAR_INT ("canna-key-insert", &Vcanna_key_Insert /*
1448
1449 */ );
1450 DEFVAR_INT ("canna-key-rollup", &Vcanna_key_Rollup /*
1451
1452 */ );
1453 DEFVAR_INT ("canna-key-rolldown", &Vcanna_key_Rolldown /*
1454
1455 */ );
1456 DEFVAR_INT ("canna-key-home", &Vcanna_key_Home /*
1457
1458 */ );
1459 DEFVAR_INT ("canna-key-help", &Vcanna_key_Help /*
1460
1461 */ );
1462 DEFVAR_INT ("canna-key-kp-key", &Vcanna_key_KP_Key /*
1463
1464 */ );
1465 DEFVAR_INT ("canna-key-shift-nfer", &Vcanna_key_Shift_Nfer /*
1466
1467 */ );
1468 DEFVAR_INT ("canna-key-shift-xfer", &Vcanna_key_Shift_Xfer /*
1469
1470 */ );
1471 DEFVAR_INT ("canna-key-shift-up", &Vcanna_key_Shift_Up /*
1472
1473 */ );
1474 DEFVAR_INT ("canna-key-shift-left", &Vcanna_key_Shift_Left /*
1475
1476 */ );
1477 DEFVAR_INT ("canna-key-shift-right", &Vcanna_key_Shift_Right /*
1478
1479 */ );
1480 DEFVAR_INT ("canna-key-shift-down", &Vcanna_key_Shift_Down /*
1481
1482 */ );
1483 DEFVAR_INT ("canna-key-control-nfer", &Vcanna_key_Cntrl_Nfer /*
1484
1485 */ );
1486 DEFVAR_INT ("canna-key-control-xfer", &Vcanna_key_Cntrl_Xfer /*
1487
1488 */ );
1489 DEFVAR_INT ("canna-key-control-up", &Vcanna_key_Cntrl_Up /*
1490
1491 */ );
1492 DEFVAR_INT ("canna-key-control-left", &Vcanna_key_Cntrl_Left /*
1493
1494 */ );
1495 DEFVAR_INT ("canna-key-control-right", &Vcanna_key_Cntrl_Right /*
1496
1497 */ );
1498 DEFVAR_INT ("canna-key-control-down", &Vcanna_key_Cntrl_Down /*
1499
1500 */ );
1501 }
1502
1503 #ifdef CANNA_MULE
1504 /* To handle MULE internal code and EUC.
1505 I assume CANNA can handle only Japanese EUC. */
1506
1507 /* EUC multibyte string to MULE internal string */
1508
1509 static void
1510 c2mu (char *cp, int l, char *mp)
1511 {
1512 char ch, *ep = cp+l;
1513
1514 while ((cp < ep) && (ch = *cp))
1515 {
1516 if ((unsigned char) ch == ISO_CODE_SS2)
1517 {
1518 *mp++ = LEADING_BYTE_JAPANESE_JISX0201_KANA;
1519 cp++;
1520 }
1521 else if ((unsigned char) ch == ISO_CODE_SS3)
1522 {
1523 *mp++ = LEADING_BYTE_JAPANESE_JISX0212;
1524 cp++;
1525 *mp++ = *cp++;
1526 }
1527 else if (ch & 0x80)
1528 {
1529 *mp++ = LEADING_BYTE_JAPANESE_JISX0208;
1530 *mp++ = *cp++;
1531 }
1532 *mp++ = *cp++;
1533 }
1534 *mp = 0;
1535 }
1536
1537 /* MULE internal string to EUC multibyte string */
1538
1539 static void
1540 m2c (unsigned char *mp, int l, unsigned char *cp)
1541 {
1542 unsigned char ch, *ep = mp + l;;
1543
1544 while ((mp < ep) && (ch = *mp++))
1545 {
1546 switch (ch)
1547 {
1548 case LEADING_BYTE_JAPANESE_JISX0201_KANA:
1549 *cp++ = ISO_CODE_SS2;
1550 *cp++ = *mp++;
1551 break;
1552 case LEADING_BYTE_JAPANESE_JISX0212:
1553 *cp++ = ISO_CODE_SS3;
1554 case LEADING_BYTE_JAPANESE_JISX0208:
1555 *cp++ = *mp++;
1556 *cp++ = *mp++;
1557 break;
1558 default:
1559 *cp++ = ch;
1560 break;
1561 }
1562 }
1563 *cp = 0;
1564 }
1565
1566 #undef make_string
1567
1568 /* make_string after converting EUC string to MULE internal string */
1569 static Lisp_Object
1570 mule_make_string (unsigned char *p, int l)
1571 {
1572 unsigned char cbuf[4096];
1573
1574 c2mu (p,l,cbuf);
1575 return (make_string (cbuf,strlen (cbuf)));
1576 }
1577
1578 /* return the MULE internal string length of EUC string */
1579 static int
1580 mule_strlen (unsigned char *p, int l)
1581 {
1582 unsigned char ch, *cp = p;
1583 int len = 0;
1584
1585 while ((cp < p + l) && (ch = *cp))
1586 {
1587 if ((unsigned char) ch == ISO_CODE_SS2)
1588 {
1589 len += 2;
1590 cp += 2;
1591 }
1592 else if ((unsigned char) ch == ISO_CODE_SS3)
1593 {
1594 len += 3;
1595 cp += 3;
1596 }
1597 else if (ch & 0x80)
1598 {
1599 len += 3;
1600 cp += 2;
1601 }
1602 else
1603 {
1604 len++;
1605 cp++;
1606 }
1607 }
1608 return (len);
1609 }
1610
1611 /* count number of characters */
1612 static
1613 count_char (unsigned char *p, int len, int pos, int rev, int *clen, int *cpos,
1614 int *crev)
1615 {
1616 unsigned char *q = p;
1617
1618 *clen = *cpos = *crev = 0;
1619 if (len == 0) return;
1620 while (q < p + pos)
1621 {
1622 (*clen)++;
1623 (*cpos)++;
1624 if (*q++ & 0x80) q++;
1625 }
1626 while (q < p + pos + rev)
1627 {
1628 (*clen)++;
1629 (*crev)++;
1630 if (*q++ & 0x80) q++;
1631 }
1632 while (q < p + len)
1633 {
1634 (*clen)++;
1635 if (*q++ & 0x80) q++;
1636 }
1637 }
1638 #endif /* CANNA_MULE */