Mercurial > hg > xemacs-beta

comparison modules/canna/canna_api.c @ 3010:bd7174adf0f2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[xemacs-hg @ 2005-10-21 15:48:28 by stephent] Revert rename of canna_api to canna-api. <87d5lylvqq.fsf@tleepslib.sk.tsukuba.ac.jp>
author stephent
date Fri, 21 Oct 2005 15:48:42 +0000
parents
children a80f978d8342
comparison
equal deleted inserted replaced
3009:79943d344216 3010:bd7174adf0f2
1 /* CANNA interface -*- coding: euc-jp -*-
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 /* Japanese comments were translated 2000-12-06 by Stephen Turnbull
26 <stephen@xemacs.org>. I haven't verified that the Japanese comments
27 were correct. YMMV, NO WARRANTY, not even the implied warranty of
28 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. (^^;;; as the
29 Japanese say. */
30
31 /*
32
33 Authors: Akira Kon (kon@uxd.fc.nec.co.jp)
34 Ichiro Hirakura (hirakura@uxd.fc.nec.co.jp)
35
36 Functions defined in this file are
37
38 (canna-key-proc key)
39 key: single STRING
40 RETURNS:
41 Length of converted string if no error occurs.
42 Error string if error occurs.
43 DESCRIPTION:
44 Convert a key input to a set of strings. The
45 strings contain both well-formed string and a
46 intermediate result to show the translation
47 information to a user. converted strings are
48 stored in specific variables.
49
50 (canna-initialize)
51 RETURNS:
52 List of the following things:
53 - list of keys to toggle Japanese-mode
54 - error message
55 - list of warning messages
56 DESCRIPTION:
57 Initialize ``canna'', which is a kana-to-kanji
58 converter for XEmacs. The first arg
59 specifies if inserting space character between
60 BUNSETSU when candidates are displayed. The
61 second arg specifies server. The third arg
62 specifies a file which will be used as a
63 customization description. If nil is
64 specified for each arg, the default value will
65 be used.
66
67 (canna-finalize)
68 RETURNS:
69 list of warning messages
70 DESCRIPTION:
71 finalize ``canna'', which is a kana-to-kanji
72 converter for XEmacs. This cause to write
73 miscellaneous informations to kana-to-kanji
74 dictionary.
75
76 (canna-touroku-string string)
77 string:
78 String to register to a dictionary.
79 RETURNS:
80 The same thing returns as canna-key-proc does.
81 DESCRIPTION:
82 Register Kanji words into kana-to-kanji
83 conversion dictionary.
84
85 (canna-set-width width)
86 width:
87 Column width of the place where the candidates
88 of kana-to-kanji conversion will be shown.
89 RETURNS:
90 nil
91 DESCRIPTION:
92 Set status-line width information, which is
93 used to display kanji candidates.
94
95 (canna-change-mode num)
96 num:
97 The mode number of Canna.
98 RETURNS:
99 The same thing returns as canna-key-proc does.
100 DESCRIPTION:
101 Change Japanese pre-edit mode.
102
103 (canna-store-yomi yomi roma)
104 yomi:
105 ``Yomi'' to be stored.
106 roma:
107 ``Romaji'' which corresponds to the ``Yomi''.
108 RETURNS:
109 The same thing returns as canna-key-proc does.
110 DESCRIPTION:
111 Store yomi characters as a YOMI of
112 kana-to-kanji conversion.
113
114 (canna-do-function num ch)
115 num:
116 A function number to be called.
117 ch:
118 A character will be specified in order to feed
119 the character to the function if the function
120 needs a input character.
121 RETURNS:
122 The same thing returns as canna-key-proc does.
123 DESCRIPTION:
124 Do specified function at current mode.
125
126 (canna-parse string)
127 string:
128 To be parsed.
129 RETURNS:
130 List of warning messages.
131 DESCRIPTION:
132 Parse customize string.
133
134 (canna-query-mode)
135 RETURNS:
136 A string which indicate the current mode.
137 DESCRIPTION:
138 Get current mode string.
139
140 Functions below are used for KKCP compatible library. These
141 functions provides a base kana-to-kanji conversion system for EGG.
142 These functions may be used when users want to change the engine
143 from Wnn to Canna without changing user interface of Japanese input.
144
145 (canna-henkan-begin)
146 (canna-henkan-next)
147 (canna-bunsetu-henkou)
148 (canna-henkan-kakutei)
149 (canna-henkan-end)
150 (canna-henkan-quit)
151
152 */
153
154 #include <config.h>
155 #include "lisp.h"
156 #ifdef HAVE_SHLIB
157 #include "emodules.h"
158 #endif
159
160 #include "buffer.h"
161 #include "file-coding.h"
162
163 #ifdef CANNA2
164 #define IROHA_BC
165 #define CANNA_NEW_WCHAR_AWARE
166 #include "canna/jrkanji.h"
167 #include "canna/RK.h"
168 #else /* !CANNA2 */
169 #include "iroha/jrkanji.h"
170 #include "iroha/RK.h"
171 #endif /* !CANNA2 */
172 extern char *jrKanjiError;
173
174 extern int (*jrBeepFunc) (void);
175
176 /* #### is this global really necessary? */
177 #define KEYTOSTRSIZE 2048
178 static char key_buffer[KEYTOSTRSIZE];
179 static char **warning;
180
181 static int canna_empty_info, canna_through_info;
182 static int canna_underline;
183 static int canna_inhibit_hankakukana;
184
185 static Lisp_Object Vcanna_kakutei_string;
186 static Lisp_Object Vcanna_kakutei_yomi;
187 static Lisp_Object Vcanna_kakutei_romaji;
188 static Lisp_Object Vcanna_henkan_string;
189 static Fixnum canna_henkan_length;
190 static Fixnum canna_henkan_revPos;
191 static Fixnum canna_henkan_revLen;
192 static Lisp_Object Vcanna_ichiran_string;
193 static Fixnum canna_ichiran_length;
194 static Fixnum canna_ichiran_revPos;
195 static Fixnum canna_ichiran_revLen;
196 static Lisp_Object Vcanna_mode_string;
197
198 static int IRCP_context;
199
200 static Lisp_Object storeResults (char *, int, jrKanjiStatus *);
201 static Lisp_Object kanjiYomiList (int, int);
202 static Lisp_Object CANNA_mode_keys (void);
203
204 #ifdef CANNA_MULE
205 static void m2c (unsigned char *, int, unsigned char *);
206 static Lisp_Object mule_make_string (unsigned char *, int);
207 static int mule_strlen (unsigned char *, int);
208 static void count_char (unsigned char *,int, int, int, Fixnum *, Fixnum *, Fixnum *);
209 #define make_string mule_make_string
210 #endif
211
212 /* Lisp functions definition */
213
214 DEFUN ("canna-key-proc", Fcanna_key_proc, 1, 1, 0, /*
215 Translate a key input to a set of strings. The strings contain both
216 well-formed string and intermediate result to show the translation
217 information to a user. Converted strings are stored in specific
218 variables.
219 */
220 (ch))
221 {
222 jrKanjiStatus ks;
223 int len;
224
225 CHECK_CHAR_COERCE_INT (ch);
226 len = jrKanjiString (0, XCHAR (ch), key_buffer, KEYTOSTRSIZE, &ks);
227 return storeResults (key_buffer, len, &ks);
228 }
229
230 static Lisp_Object
231 storeResults (char *buf, int len, jrKanjiStatus *ks)
232 {
233 Lisp_Object val = Qnil;
234
235 if (len < 0)
236 { /* Error detected */
237 val = make_string ((unsigned char*) jrKanjiError, strlen (jrKanjiError));
238 }
239 else
240 {
241 /* 確定した文字列 (the confirmed string) */
242 Vcanna_kakutei_string = make_string ((unsigned char *) buf, len);
243 val = make_int (len);
244 /* 確定した文字列の読みの情報...
245 (info about the reading of the confirmed string) */
246 Vcanna_kakutei_yomi = Vcanna_kakutei_romaji = Qnil;
247 if (ks->info & KanjiYomiInfo)
248 {
249 char *p = buf + len + 1;
250 int yomilen = strlen (p);
251
252 if (len + yomilen + 1 < KEYTOSTRSIZE)
253 {
254 int yomilen2;
255
256 Vcanna_kakutei_yomi =
257 make_string ((unsigned char *) p, yomilen); /* 読み (reading) */
258 p += yomilen + 1;
259 yomilen2 = strlen (p);
260 if (len + yomilen + yomilen2 + 2 < KEYTOSTRSIZE)
261 {
262 Vcanna_kakutei_romaji =
263 make_string ((unsigned char *) p, yomilen2);
264 /* ローマ字 (romanization) */
265 }
266 }
267 }
268
269
270 /* 候補表示の文字列です。
271 (string for displaying candidate translations) */
272 Vcanna_henkan_string = Qnil;
273 if (ks->length >= 0)
274 {
275 Vcanna_henkan_string = make_string (ks->echoStr, ks->length);
276 #ifndef CANNA_MULE
277 canna_henkan_length = ks->length;
278 canna_henkan_revPos = ks->revPos;
279 canna_henkan_revLen = ks->revLen;
280 #else /* CANNA_MULE */
281 if (canna_underline)
282 {
283 canna_henkan_length = mule_strlen (ks->echoStr,ks->length);
284 canna_henkan_revPos = mule_strlen (ks->echoStr,ks->revPos);
285 canna_henkan_revLen = mule_strlen (ks->echoStr+ks->revPos,
286 ks->revLen);
287 }
288 else
289 {
290 count_char (ks->echoStr, ks->length, ks->revPos, ks->revLen,
291 &canna_henkan_length, &canna_henkan_revPos,
292 &canna_henkan_revLen);
293 }
294 #endif /* CANNA_MULE */
295 }
296
297 /* 一覧の情報 (information about the echo area menu) */
298 Vcanna_ichiran_string = Qnil;
299 if (ks->info & KanjiGLineInfo && ks->gline.length >= 0)
300 {
301 Vcanna_ichiran_string = make_string (ks->gline.line,
302 ks->gline.length);
303 #ifndef CANNA_MULE
304 canna_ichiran_length = ks->gline.length;
305 canna_ichiran_revPos = ks->gline.revPos;
306 canna_ichiran_revLen = ks->gline.revLen;
307 #else /* CANNA_MULE */
308 count_char (ks->gline.line, ks->gline.length,
309 ks->gline.revPos, ks->gline.revLen,
310 &canna_ichiran_length,
311 &canna_ichiran_revPos, &canna_ichiran_revLen);
312 #endif /* CANNA_MULE */
313 }
314
315 /* モードの情報 (mode information) */
316 Vcanna_mode_string = Qnil;
317 if (ks->info & KanjiModeInfo)
318 {
319 Vcanna_mode_string =
320 make_string (ks->mode, strlen ((const char *) ks->mode));
321 }
322
323 /* その他の情報 (other information) */
324 canna_empty_info = (ks->info & KanjiEmptyInfo) ? 1 : 0;
325 canna_through_info = (ks->info & KanjiThroughInfo) ? 1 : 0;
326 }
327
328 return val;
329 }
330
331 DEFUN ("canna-set-bunsetsu-kugiri", Fcanna_set_bunsetsu, 0, 1, 0, /*
332 This function sets the clause separator.
333 If non-nil value is specified, the white space separator will be used.
334 No separator will be used otherwise.
335 */
336 (num))
337 {
338 int kugiri; /* 文節区切りをするか？ (display clause separator?) */
339
340 kugiri = NILP (num) ? 0 : 1;
341
342 jrKanjiControl (0, KC_SETBUNSETSUKUGIRI, (char *) kugiri);
343
344 return Qnil;
345 }
346
347 /* For whatever reason, calling Fding directly from libCanna loses */
348 static int
349 call_Fding (void)
350 {
351 Fding (Qnil, Qnil, Qnil);
352 return 0;
353 }
354
355 DEFUN ("canna-initialize", Fcanna_initialize, 0, 3, 0, /*
356 Initialize ``canna'', which is a kana-to-kanji converter for XEmacs.
357 The first arg specifies if inserting space character between BUNSETSU when
358 candidates are displayed.
359 The second arg specifies server.
360 The third arg specifies a file which will be used as a customization
361 description.
362 If nil is specified for each arg, the default value will be used.
363 */
364 (num, server, rcfile))
365 {
366 Lisp_Object val;
367 int res;
368 unsigned char **p, **q;
369
370 int kugiri; /* 文節区切りをするか？ (display clause separator?) */
371
372 IRCP_context = -1;
373
374 if (NILP (num))
375 {
376 kugiri = 1;
377 }
378 else
379 {
380 CHECK_INT (num);
381 kugiri = XINT (num);
382 kugiri = (kugiri == 1) ? 1 : 0;
383 }
384
385 if (NILP (server))
386 {
387 jrKanjiControl (0, KC_SETSERVERNAME, (char *) 0);
388 }
389 else
390 {
391 char servername[256];
392
393 CHECK_STRING (server);
394 strncpy (servername, (const char *) XSTRING_DATA (server),
395 XSTRING_LENGTH (server));
396 servername[XSTRING_LENGTH (server)] = '\0';
397 jrKanjiControl (0, KC_SETSERVERNAME, servername);
398 }
399
400 if (NILP (rcfile))
401 {
402 jrKanjiControl (0, KC_SETINITFILENAME, (char *) 0);
403 }
404 else
405 {
406 char rcname[256];
407
408 CHECK_STRING (rcfile);
409 strncpy (rcname, (const char *) XSTRING_DATA (rcfile),
410 XSTRING_LENGTH (rcfile));
411 rcname[XSTRING_LENGTH (rcfile)] = '\0';
412 jrKanjiControl (0, KC_SETINITFILENAME, rcname);
413 }
414
415 warning = (char **) 0;
416 #ifdef nec_ews_svr4
417 stop_polling ();
418 #endif /* nec_ews_svr4 */
419 res = jrKanjiControl (0, KC_INITIALIZE, (char *)&warning);
420 #ifdef nec_ews_svr4
421 start_polling ();
422 #endif /* nec_ews_svr4 */
423 val = Qnil;
424 if (warning)
425 {
426 for (p = q = (unsigned char **) warning ; *q ; q++)
427 ;
428 while (p < q)
429 {
430 q--;
431 val = Fcons (make_string (*q, strlen ((const char *) *q)), val);
432 }
433 }
434 val = Fcons (val, Qnil);
435
436 if (res == -1)
437 {
438 val = Fcons (make_string ((unsigned char *) jrKanjiError,
439 strlen (jrKanjiError)), val);
440 /* イニシャライズで失敗した場合。 (on initialization failure) */
441 return Fcons (Qnil, val);
442 }
443 else
444 {
445 jrBeepFunc = call_Fding;
446
447 #ifdef KC_SETAPPNAME
448 #ifndef CANNA_MULE
449 jrKanjiControl (0, KC_SETAPPNAME, "nemacs");
450 #else /* CANNA_MULE */
451 jrKanjiControl (0, KC_SETAPPNAME, "mule");
452 #endif /* CANNA_MULE */
453 #endif /* KC_SETAPPNAME */
454
455 jrKanjiControl (0, KC_SETBUNSETSUKUGIRI, (char *) kugiri);
456 jrKanjiControl (0, KC_SETWIDTH, (char *) 78);
457 #ifndef CANNA_MULE
458 jrKanjiControl (0, KC_INHIBITHANKAKUKANA, (char *) 1);
459 #else
460 /* mule だったら半角カタカナも使える
461 (Mule can use half-width katakana) */
462 if (canna_inhibit_hankakukana)
463 jrKanjiControl (0, KC_INHIBITHANKAKUKANA, (char *) 1);
464 #endif
465 jrKanjiControl (0, KC_YOMIINFO, (char *) 2); /* ※２: ローマ字まで返す
466 (*2: return to
467 romanized form) */
468 val = Fcons (Qnil, val);
469 return Fcons (CANNA_mode_keys (), val);
470 }
471 }
472
473 DEFUN ("canna-finalize", Fcanna_finalize, 0, 0, 0, /*
474 finalize ``canna'', which is a kana-to-kanji converter for XEmacs.
475 This cause to write miscellaneous informations to kana-to-kanji dictionary.
476 */
477 ())
478 {
479 Lisp_Object val;
480 unsigned char **p;
481
482 jrKanjiControl (0, KC_FINALIZE, (char *)&warning);
483
484 val = Qnil;
485 if (warning)
486 {
487 for (p = (unsigned char**) warning ; *p ; p++)
488 {
489 val = Fcons (make_string (*p, strlen ((const char *) *p)), val);
490 }
491 }
492 val = Fcons (val, Qnil);
493 IRCP_context = -1;
494 return val;
495 }
496
497 DEFUN ("canna-touroku-string", Fcanna_touroku_string, 1, 1, 0, /*
498 Register Kanji words into kana-to-kanji conversion dictionary.
499 */
500 (str))
501 {
502 jrKanjiStatusWithValue ksv;
503 jrKanjiStatus ks;
504 #ifdef CANNA_MULE
505 unsigned char cbuf[4096];
506 #endif
507
508 CHECK_STRING (str);
509 ksv.buffer = (unsigned char *) key_buffer;
510 ksv.bytes_buffer = KEYTOSTRSIZE;
511 #ifndef CANNA_MULE
512 ks.echoStr = XSTRING_DATA (str);
513 ks.length = XSTRING_LENGTH (str);
514 #else /* CANNA_MULE */
515 m2c (XSTRING_DATA (str), XSTRING_LENGTH (str), cbuf);
516 ks.echoStr = cbuf;
517 ks.length = strlen ((const char *) cbuf);
518 #endif /* CANNA_MULE */
519 ksv.ks = &ks;
520 jrKanjiControl (0, KC_DEFINEKANJI, (char *)&ksv);
521 return storeResults (key_buffer, ksv.val, ksv.ks);
522 }
523
524 DEFUN ("canna-set-width", Fcanna_set_width, 1, 1, 0, /*
525 Set status-line width information, which is used to display
526 kanji candidates.
527 */
528 (num))
529 {
530 CHECK_INT (num);
531
532 jrKanjiControl (0, KC_SETWIDTH, (char *) XINT (num));
533 return Qnil;
534 }
535
536 DEFUN ("canna-change-mode", Fcanna_change_mode, 1, 1, 0, /*
537 Change Japanese pre-edit mode.
538 */
539 (num))
540 {
541 jrKanjiStatusWithValue ksv;
542 jrKanjiStatus ks;
543
544 CHECK_INT (num);
545
546 ksv.buffer = (unsigned char *) key_buffer;
547 ksv.bytes_buffer = KEYTOSTRSIZE;
548 ksv.ks = &ks;
549 ksv.val = XINT (num);
550 jrKanjiControl (0, KC_CHANGEMODE, (char *)&ksv);
551 return storeResults (key_buffer, ksv.val, ksv.ks);
552 }
553
554 static Lisp_Object
555 CANNA_mode_keys (void)
556 {
557 #define CANNAWORKBUFSIZE 32
558 char xxx[CANNAWORKBUFSIZE];
559 Lisp_Object val;
560 int i, n;
561
562 n = jrKanjiControl (0, KC_MODEKEYS, xxx);
563 val = Qnil;
564 for (i = n ; i > 0 ;)
565 {
566 --i;
567 /* !!#### something fucked here */
568 val = Fcons (make_char ((int)(0xFF & (unsigned char) xxx[i])), val);
569 }
570 return val;
571 }
572
573 DEFUN ("canna-store-yomi", Fcanna_store_yomi, 1, 2, 0, /*
574 Store yomi characters as a YOMI of kana-to-kanji conversion.
575 */
576 (yomi, roma))
577 {
578 jrKanjiStatusWithValue ksv;
579 jrKanjiStatus ks;
580
581 CHECK_STRING (yomi);
582 #ifndef CANNA_MULE
583 strncpy (key_buffer, XSTRING_DATA (yomi), XSTRING_LENGTH (yomi));
584 ks.length = XSTRING_LENGTH (yomi);
585 key_buffer[ks.length] = '\0';
586 #else /* CANNA_MULE */
587 m2c (XSTRING_DATA (yomi), XSTRING_LENGTH (yomi),
588 (unsigned char *) key_buffer);
589 ks.length = strlen (key_buffer);
590 #endif /* CANNA_MULE */
591
592 if (NILP (roma))
593 {
594 ks.mode = 0;
595 }
596 else
597 {
598 CHECK_STRING (roma);
599
600 #ifndef CANNA_MULE
601 strncpy (key_buffer + XSTRING_LENGTH (yomi) + 1, XSTRING_DATA (roma),
602 XSTRING_LENGTH (roma));
603 key_buffer[XSTRING_LENGTH (yomi) + 1 + XSTRING_LENGTH (roma)] = '\0';
604 ks.mode = (unsigned char *)(key_buffer + XSTRING_LENGTH (yomi) + 1);
605 #else /* CANNA_MULE */
606 ks.mode = (unsigned char *)(key_buffer + ks.length + 1);
607 m2c (XSTRING_DATA (roma), XSTRING_LENGTH (roma),
608 (unsigned char *) ks.mode);
609 #endif /* CANNA_MULE */
610 }
611
612 ks.echoStr = (unsigned char *) key_buffer;
613 ksv.buffer = (unsigned char *) key_buffer; /* 返値用 (return value) */
614 ksv.bytes_buffer = KEYTOSTRSIZE;
615 ksv.ks = &ks;
616
617 jrKanjiControl (0, KC_STOREYOMI, (char *)&ksv);
618
619 return storeResults (key_buffer, ksv.val, ksv.ks);
620 }
621
622 DEFUN ("canna-do-function", Fcanna_do_function, 1, 2, 0, /*
623 Do specified function at current mode.
624 */
625 (num, ch))
626 {
627 jrKanjiStatusWithValue ksv;
628 jrKanjiStatus ks;
629
630 CHECK_INT (num);
631
632 if (NILP (ch))
633 {
634 *key_buffer = '@';
635 }
636 else
637 {
638 CHECK_CHAR (ch);
639 *key_buffer = XCHAR (ch);
640 }
641
642 ksv.buffer = (unsigned char *) key_buffer;
643 ksv.bytes_buffer = KEYTOSTRSIZE;
644 ksv.ks = &ks;
645 ksv.val = XINT (num);
646 jrKanjiControl (0, KC_DO, (char *) &ksv);
647 return storeResults (key_buffer, ksv.val, ksv.ks);
648 }
649
650 DEFUN ("canna-parse", Fcanna_parse, 1, 1, 0, /*
651 Parse customize string.
652 */
653 (str))
654 {
655 Lisp_Object val;
656 unsigned char **p;
657 int n;
658
659 CHECK_STRING (str);
660
661 #ifndef CANNA_MULE
662 strncpy (key_buffer, XSTRING_DATA (str), XSTRING_LENGTH (str));
663 key_buffer[XSTRING_LENGTH (str)] = '\0';
664 #else /* CANNA_MULE */
665 m2c (XSTRING_DATA (str), XSTRING_LENGTH (str), (unsigned char *) key_buffer);
666 #endif /* CANNA_MULE */
667 p = (unsigned char**) key_buffer;
668 n = jrKanjiControl (0, KC_PARSE, (char *) &p);
669 val = Qnil;
670 while (n > 0)
671 {
672 n--;
673 val = Fcons (make_string (p[n], strlen ((const char *) p[n])), val);
674 }
675 return val;
676 }
677
678 DEFUN ("canna-query-mode", Fcanna_query_mode, 0, 0, 0, /*
679 Get current mode string.
680 */
681 ())
682 {
683 char buf[256];
684
685 jrKanjiControl (0, KC_QUERYMODE, buf);
686 return make_string ((unsigned char *) buf, strlen (buf));
687 }
688
689 /*
690 * Functions following this line are for KKCP interface compatible
691 * library. These functions may be used by MILK system.
692 */
693
694 #define RKBUFSIZE 1024
695
696 static unsigned char yomibuf[RKBUFSIZE];
697 static short kugiri[RKBUFSIZE / 2];
698
699 static int
700 confirmContext (void)
701 {
702 if (IRCP_context < 0)
703 {
704 int context;
705
706 if ((context = jrKanjiControl (0, KC_GETCONTEXT, (char *) 0)) == -1)
707 {
708 return 0;
709 }
710 IRCP_context = context;
711 }
712 return 1;
713 }
714
715 static int
716 byteLen (int bun, int len)
717 {
718 int i = 0, offset = 0, ch;
719
720 if (0 <= bun && bun < RKBUFSIZE)
721 {
722 offset = kugiri[bun];
723 }
724
725 while (len-- > 0 && (ch = (int) yomibuf[offset + i]))
726 {
727 i++;
728 if (ch & 0x80)
729 {
730 i++;
731 }
732 }
733 return i;
734 }
735
736 DEFUN ("canna-henkan-begin", Fcanna_henkan_begin, 1, 1, 0, /*
737 Return the result of kana-to-kanji conversion.
738 Clause separator is set.
739 */
740 (yomi))
741 {
742 int nbun;
743
744 CHECK_STRING (yomi);
745 if (confirmContext () == 0)
746 {
747 return Qnil;
748 }
749 #ifndef CANNA_MULE
750 strncpy (yomibuf, XSTRING_DATA (yomi), XSTRING_LENGTH (yomi));
751 yomibuf[XSTRING_LENGTH (yomi)] = '\0';
752 nbun = RkBgnBun (IRCP_context, XSTRING_DATA (yomi), XSTRING_LENGTH (yomi),
753 (RK_XFER << RK_XFERBITS) | RK_KFER);
754 #else /* CANNA_MULE */
755 m2c (XSTRING_DATA (yomi), XSTRING_LENGTH (yomi), yomibuf);
756 nbun = RkBgnBun (IRCP_context, (char *) yomibuf,
757 strlen ((const char *) yomibuf),
758 (RK_XFER << RK_XFERBITS) | RK_KFER);
759 #endif /* CANNA_MULE */
760
761 return kanjiYomiList (IRCP_context, nbun);
762 }
763
764 static Lisp_Object
765 kanjiYomiList (int context, int nbun)
766 {
767 Lisp_Object val, res = Qnil;
768 unsigned char RkBuf[RKBUFSIZE];
769 int len, i, total;
770
771 for (i = nbun ; i > 0 ; )
772 {
773 i--;
774 RkGoTo (context, i);
775 len = RkGetKanji (context, RkBuf, RKBUFSIZE);
776 val = make_string (RkBuf, len);
777 len = RkGetYomi (context, RkBuf, RKBUFSIZE);
778 res = Fcons (Fcons (val, make_string (RkBuf, len)), res);
779 if (i < RKBUFSIZE / 2)
780 {
781 kugiri[i] = len;
782 }
783 }
784 for (i = 0, total = 0 ; i < nbun ; i++)
785 {
786 int temp = kugiri[i];
787 kugiri[i] = total;
788 total += temp;
789 }
790 return res;
791 }
792
793 DEFUN ("canna-henkan-next", Fcanna_henkan_next, 1, 1, 0, /*
794 Return the list of candidates.
795 */
796 (bunsetsu))
797 {
798 int i, slen, len;
799 unsigned char *p, RkBuf[RKBUFSIZE];
800 Lisp_Object res = Qnil;
801
802 CHECK_INT (bunsetsu);
803 if (confirmContext () == 0)
804 {
805 return Qnil;
806 }
807 RkGoTo (IRCP_context, XINT (bunsetsu));
808 len = RkGetKanjiList (IRCP_context, RkBuf, RKBUFSIZE);
809 p = RkBuf;
810 for (i = 0 ; i < len ; i++)
811 {
812 slen = strlen ((const char *) p);
813 if (NILP(res))
814 {
815 res = Fcons (make_string (p, slen), Qnil);
816 }
817 else
818 {
819 XCDR (res) = Fcons (make_string (p, slen), Qnil);
820 }
821 p += slen + 1;
822 }
823 return res;
824 }
825
826 DEFUN ("canna-bunsetu-henkou", Fcanna_bunsetu_henkou, 2, 2, 0, /*
827 Specify the length of a clause.
828 */
829 (bunsetsu, bunlen))
830 {
831 int nbun, len;
832
833 CHECK_INT (bunsetsu);
834 CHECK_INT (bunlen);
835
836 nbun = XINT (bunsetsu);
837 if (confirmContext () == 0)
838 {
839 return Qnil;
840 }
841 RkGoTo (IRCP_context, nbun);
842 len = byteLen (nbun, XINT (bunlen));
843 return kanjiYomiList (IRCP_context, RkResize (IRCP_context, len));
844 }
845
846 DEFUN ("canna-henkan-kakutei", Fcanna_henkan_kakutei, 2, 2, 0, /*
847 Select a candidate.
848 */
849 (bun, kouho))
850 {
851 int nbun, nkouho;
852
853 if (confirmContext () == 0)
854 {
855 return Qnil;
856 }
857 nbun = XINT(bun);
858 RkGoTo (IRCP_context, nbun);
859
860 nkouho = XINT(kouho);
861 RkXfer (IRCP_context, nkouho);
862 return Qt;
863 }
864
865 DEFUN ("canna-henkan-end", Fcanna_henkan_end, 0, 0, 0, /*
866 End conversion.
867 */
868 ())
869 {
870 if (confirmContext () == 0)
871 {
872 return Qnil;
873 }
874 RkEndBun (IRCP_context, 1); /* 学習はいつでも行って良いものなのか？
875 (is it OK to invoke learning function
876 at arbitrary times?) */
877 return Qt;
878 }
879
880 DEFUN ("canna-henkan-quit", Fcanna_henkan_quit, 0, 0, 0, /*
881 Quit conversion.
882 */
883 ())
884 {
885 if (confirmContext () == 0)
886 {
887 return Qnil;
888 }
889 RkEndBun (IRCP_context, 0);
890 return Qt;
891 }
892
893 /* variables below this line is constants of Canna */
894
895 static Fixnum canna_mode_AlphaMode;
896 static Fixnum canna_mode_EmptyMode;
897 static Fixnum canna_mode_KigoMode;
898 static Fixnum canna_mode_YomiMode;
899 static Fixnum canna_mode_JishuMode;
900 static Fixnum canna_mode_TankouhoMode;
901 static Fixnum canna_mode_IchiranMode;
902 static Fixnum canna_mode_YesNoMode;
903 static Fixnum canna_mode_OnOffMode;
904 #ifdef CANNA_MODE_AdjustBunsetsuMode
905 static Fixnum canna_mode_AdjustBunsetsuMode;
906 #endif
907 #ifdef CANNA_MODE_ChikujiYomiMode
908 static Fixnum canna_mode_ChikujiYomiMode;
909 static Fixnum canna_mode_ChikujiTanMode;
910 #endif
911
912 static Fixnum canna_mode_HenkanMode;
913 #ifdef CANNA_MODE_HenkanNyuryokuMode
914 static Fixnum canna_mode_HenkanNyuryokuMode;
915 #endif
916 #ifdef CANNA_MODE_ZenHiraHenkanMode
917 static Fixnum canna_mode_ZenHiraHenkanMode;
918 #ifdef CANNA_MODE_HanHiraHenkanMode
919 static Fixnum canna_mode_HanHiraHenkanMode;
920 #endif
921 static Fixnum canna_mode_ZenKataHenkanMode;
922 static Fixnum canna_mode_HanKataHenkanMode;
923 static Fixnum canna_mode_ZenAlphaHenkanMode;
924 static Fixnum canna_mode_HanAlphaHenkanMode;
925 #endif
926 static Fixnum canna_mode_ZenHiraKakuteiMode;
927 #ifdef CANNA_MODE_HanHiraKakuteiMode
928 static Fixnum canna_mode_HanHiraKakuteiMode;
929 #endif
930 static Fixnum canna_mode_ZenKataKakuteiMode;
931 static Fixnum canna_mode_HanKataKakuteiMode;
932 static Fixnum canna_mode_ZenAlphaKakuteiMode;
933 static Fixnum canna_mode_HanAlphaKakuteiMode;
934 static Fixnum canna_mode_HexMode;
935 static Fixnum canna_mode_BushuMode;
936 static Fixnum canna_mode_ExtendMode;
937 static Fixnum canna_mode_RussianMode;
938 static Fixnum canna_mode_GreekMode;
939 static Fixnum canna_mode_LineMode;
940 static Fixnum canna_mode_ChangingServerMode;
941 static Fixnum canna_mode_HenkanMethodMode;
942 static Fixnum canna_mode_DeleteDicMode;
943 static Fixnum canna_mode_TourokuMode;
944 static Fixnum canna_mode_TourokuEmptyMode;
945 static Fixnum canna_mode_TourokuHinshiMode;
946 static Fixnum canna_mode_TourokuDicMode;
947 static Fixnum canna_mode_QuotedInsertMode;
948 static Fixnum canna_mode_BubunMuhenkanMode;
949 static Fixnum canna_mode_MountDicMode;
950
951 static Fixnum canna_fn_SelfInsert;
952 static Fixnum canna_fn_FunctionalInsert;
953 static Fixnum canna_fn_QuotedInsert;
954 static Fixnum canna_fn_JapaneseMode;
955 static Fixnum canna_fn_AlphaMode;
956 static Fixnum canna_fn_HenkanNyuryokuMode;
957 static Fixnum canna_fn_Forward;
958 static Fixnum canna_fn_Backward;
959 static Fixnum canna_fn_Next;
960 static Fixnum canna_fn_Prev;
961 static Fixnum canna_fn_BeginningOfLine;
962 static Fixnum canna_fn_EndOfLine;
963 static Fixnum canna_fn_DeleteNext;
964 static Fixnum canna_fn_DeletePrevious;
965 static Fixnum canna_fn_KillToEndOfLine;
966 static Fixnum canna_fn_Henkan;
967 static Fixnum canna_fn_Kakutei;
968 static Fixnum canna_fn_Extend;
969 static Fixnum canna_fn_Shrink;
970 #ifdef CANNA_FN_AdjustBunsetsu
971 static Fixnum canna_fn_AdjustBunsetsu;
972 #endif
973 static Fixnum canna_fn_Quit;
974 static Fixnum canna_fn_ConvertAsHex;
975 static Fixnum canna_fn_ConvertAsBushu;
976 static Fixnum canna_fn_KouhoIchiran;
977 static Fixnum canna_fn_BubunMuhenkan;
978 static Fixnum canna_fn_Zenkaku;
979 static Fixnum canna_fn_Hankaku;
980 static Fixnum canna_fn_ToUpper;
981 static Fixnum canna_fn_Capitalize;
982 static Fixnum canna_fn_ToLower;
983 static Fixnum canna_fn_Hiragana;
984 static Fixnum canna_fn_Katakana;
985 static Fixnum canna_fn_Romaji;
986 #ifdef CANNA_FN_BaseHiragana
987 static Fixnum canna_fn_BaseHiragana;
988 static Fixnum canna_fn_BaseKatakana;
989 static Fixnum canna_fn_BaseEisu;
990 static Fixnum canna_fn_BaseZenkaku;
991 static Fixnum canna_fn_BaseHankaku;
992 static Fixnum canna_fn_BaseKana;
993 static Fixnum canna_fn_BaseKakutei;
994 static Fixnum canna_fn_BaseHenkan;
995 static Fixnum canna_fn_BaseHiraKataToggle;
996 static Fixnum canna_fn_BaseZenHanToggle;
997 static Fixnum canna_fn_BaseKanaEisuToggle;
998 static Fixnum canna_fn_BaseKakuteiHenkanToggle;
999 static Fixnum canna_fn_BaseRotateForward;
1000 static Fixnum canna_fn_BaseRotateBackward;
1001 #endif
1002 static Fixnum canna_fn_ExtendMode;
1003 static Fixnum canna_fn_Touroku;
1004 static Fixnum canna_fn_HexMode;
1005 static Fixnum canna_fn_BushuMode;
1006 static Fixnum canna_fn_KigouMode;
1007 #ifdef CANNA_FN_Mark
1008 static Fixnum canna_fn_Mark;
1009 #endif
1010 #ifdef CANNA_FN_TemporalMode
1011 static Fixnum canna_fn_TemporalMode;
1012 #endif
1013
1014 static Fixnum canna_key_Nfer;
1015 static Fixnum canna_key_Xfer;
1016 static Fixnum canna_key_Up;
1017 static Fixnum canna_key_Left;
1018 static Fixnum canna_key_Right;
1019 static Fixnum canna_key_Down;
1020 static Fixnum canna_key_Insert;
1021 static Fixnum canna_key_Rollup;
1022 static Fixnum canna_key_Rolldown;
1023 static Fixnum canna_key_Home;
1024 static Fixnum canna_key_Help;
1025 static Fixnum canna_key_KP_Key;
1026 static Fixnum canna_key_Shift_Nfer;
1027 static Fixnum canna_key_Shift_Xfer;
1028 static Fixnum canna_key_Shift_Up;
1029 static Fixnum canna_key_Shift_Left;
1030 static Fixnum canna_key_Shift_Right;
1031 static Fixnum canna_key_Shift_Down;
1032 static Fixnum canna_key_Cntrl_Nfer;
1033 static Fixnum canna_key_Cntrl_Xfer;
1034 static Fixnum canna_key_Cntrl_Up;
1035 static Fixnum canna_key_Cntrl_Left;
1036 static Fixnum canna_key_Cntrl_Right;
1037 static Fixnum canna_key_Cntrl_Down;
1038
1039 Lisp_Object VCANNA; /* by MORIOKA Tomohiko <morioka@jaist.ac.jp>
1040 1996/6/7 */
1041
1042 /*
1043 * Each dynamically loaded Emacs module is given a name at compile
1044 * time. This is a short name, and must be a valid part of a C
1045 * identifier. This name is used to construct the name of several
1046 * functions which must appear in the module source code.
1047 * The first such function, modules_of_XXXX, should load in any dependent
1048 * modules. This function is optional, and the module will still load if
1049 * it is not present in the module.
1050 *
1051 * The second function, which is NOT optional, is syms_of_XXXX, in which
1052 * all functions that the module will be provided are declared. This
1053 * function will contain calls to DEFSUBR().
1054 *
1055 * The third function, which is also NOT optional, is vars_of_XXXX, in
1056 * which you declare all variables that the module provides. This
1057 * function will contain calls to DEFVAR_LISP(), DEFVAR_BOOL() etc.
1058 *
1059 * When declaring functions and variables in the syms_of_XXXX and
1060 * vars_of_XXXX functions, you use the exact same syntax that you
1061 * would as if this module were being compiled into the pure Emacs.
1062 *
1063 * The fourth function, which is optional, is unload_XXXX, in which actions
1064 * that must be taken to unload the module are listed. XEmacs will unbind
1065 * functions and variables for you. Anything else that must be done should
1066 * appear in this function.
1067 *
1068 * All four of these functions are declared as void functions,
1069 * taking no parameters. Since this sample module is called 'sample',
1070 * the functions will be named 'modules_of_sample', 'syms_of_sample',
1071 * 'vars_of_sample', and 'unload_sample'.
1072 */
1073
1074 #if 0
1075 void
1076 modules_of_canna_api (void)
1077 {
1078 /*
1079 * This function isn't actually required as we will not be loading
1080 * in any dependent modules, but if we were, we would do something like:
1081 * emodules_load ("dependent.ell", "canna2", "1.0.0");
1082 */
1083 }
1084 #endif
1085
1086 void
1087 syms_of_canna_api (void)
1088 {
1089 DEFSUBR (Fcanna_key_proc);
1090 DEFSUBR (Fcanna_initialize);
1091 DEFSUBR (Fcanna_finalize);
1092 DEFSUBR (Fcanna_touroku_string);
1093 DEFSUBR (Fcanna_set_width);
1094 DEFSUBR (Fcanna_change_mode);
1095 DEFSUBR (Fcanna_store_yomi);
1096 DEFSUBR (Fcanna_do_function);
1097 DEFSUBR (Fcanna_parse);
1098 DEFSUBR (Fcanna_query_mode);
1099 DEFSUBR (Fcanna_set_bunsetsu);
1100
1101 DEFSUBR (Fcanna_henkan_begin);
1102 DEFSUBR (Fcanna_henkan_next);
1103 DEFSUBR (Fcanna_bunsetu_henkou);
1104 DEFSUBR (Fcanna_henkan_kakutei);
1105 DEFSUBR (Fcanna_henkan_end);
1106 DEFSUBR (Fcanna_henkan_quit);
1107 }
1108
1109 void
1110 vars_of_canna_api (void)
1111 {
1112 DEFVAR_LISP ("CANNA", &VCANNA); /* hir@nec, 1992.5.21 */
1113 VCANNA = Qt; /* hir@nec, 1992.5.21 */
1114
1115 DEFVAR_LISP ("canna-kakutei-string", &Vcanna_kakutei_string /*
1116
1117 */ );
1118 Vcanna_kakutei_string = Qnil;
1119
1120 DEFVAR_LISP ("canna-kakutei-yomi", &Vcanna_kakutei_yomi /*
1121
1122 */ );
1123 Vcanna_kakutei_yomi = Qnil;
1124
1125 DEFVAR_LISP ("canna-kakutei-romaji", &Vcanna_kakutei_romaji /*
1126
1127 */ );
1128 Vcanna_kakutei_romaji = Qnil;
1129
1130 DEFVAR_LISP ("canna-henkan-string", &Vcanna_henkan_string /*
1131
1132 */ );
1133 Vcanna_henkan_string = Qnil;
1134
1135 DEFVAR_INT ("canna-henkan-length", &canna_henkan_length /*
1136
1137 */ );
1138 canna_henkan_length = 0;
1139
1140 DEFVAR_INT ("canna-henkan-revpos", &canna_henkan_revPos /*
1141
1142 */ );
1143 canna_henkan_revPos = 0;
1144
1145 DEFVAR_INT ("canna-henkan-revlen", &canna_henkan_revLen /*
1146
1147 */ );
1148 canna_henkan_revLen = 0;
1149
1150 DEFVAR_LISP ("canna-ichiran-string", &Vcanna_ichiran_string /*
1151
1152 */ );
1153 Vcanna_ichiran_string = Qnil;
1154
1155 DEFVAR_INT ("canna-ichiran-length", &canna_ichiran_length /*
1156
1157 */ );
1158 canna_ichiran_length = 0;
1159
1160 DEFVAR_INT ("canna-ichiran-revpos", &canna_ichiran_revPos /*
1161
1162 */ );
1163 canna_ichiran_revPos = 0;
1164
1165 DEFVAR_INT ("canna-ichiran-revlen", &canna_ichiran_revLen /*
1166
1167 */ );
1168 canna_ichiran_revLen = 0;
1169
1170 DEFVAR_LISP ("canna-mode-string", &Vcanna_mode_string /*
1171
1172 */ );
1173 Vcanna_mode_string = Qnil;
1174
1175 DEFVAR_BOOL ("canna-empty-info", &canna_empty_info /*
1176 For canna
1177 */ );
1178 canna_empty_info = 0;
1179
1180 DEFVAR_BOOL ("canna-through-info", &canna_through_info /*
1181 For canna
1182 */ );
1183 canna_through_info = 0;
1184
1185 DEFVAR_BOOL ("canna-underline", &canna_underline /*
1186 For canna
1187 */ );
1188 canna_underline = 0;
1189
1190 DEFVAR_BOOL ("canna-inhibit-hankakukana", &canna_inhibit_hankakukana /*
1191 For canna
1192 */ );
1193 canna_inhibit_hankakukana = 0;
1194
1195 DEFVAR_INT ("canna-mode-alpha-mode", &canna_mode_AlphaMode /*
1196
1197 */ );
1198 canna_mode_AlphaMode = IROHA_MODE_AlphaMode;
1199
1200 DEFVAR_INT ("canna-mode-empty-mode", &canna_mode_EmptyMode /*
1201
1202 */ );
1203 canna_mode_EmptyMode = IROHA_MODE_EmptyMode;
1204
1205 DEFVAR_INT ("canna-mode-kigo-mode", &canna_mode_KigoMode /*
1206
1207 */ );
1208 canna_mode_KigoMode = IROHA_MODE_KigoMode;
1209
1210 DEFVAR_INT ("canna-mode-yomi-mode", &canna_mode_YomiMode /*
1211
1212 */ );
1213 canna_mode_YomiMode = IROHA_MODE_YomiMode;
1214
1215 DEFVAR_INT ("canna-mode-jishu-mode", &canna_mode_JishuMode /*
1216
1217 */ );
1218 canna_mode_JishuMode = IROHA_MODE_JishuMode;
1219
1220 DEFVAR_INT ("canna-mode-tankouho-mode", &canna_mode_TankouhoMode /*
1221
1222 */ );
1223 canna_mode_TankouhoMode = IROHA_MODE_TankouhoMode;
1224
1225 DEFVAR_INT ("canna-mode-ichiran-mode", &canna_mode_IchiranMode /*
1226
1227 */ );
1228 canna_mode_IchiranMode = IROHA_MODE_IchiranMode;
1229
1230 DEFVAR_INT ("canna-mode-yes-no-mode", &canna_mode_YesNoMode /*
1231
1232 */ );
1233 canna_mode_YesNoMode = IROHA_MODE_YesNoMode;
1234
1235 DEFVAR_INT ("canna-mode-on-off-mode", &canna_mode_OnOffMode /*
1236
1237 */ );
1238 canna_mode_OnOffMode = IROHA_MODE_OnOffMode;
1239
1240 #ifdef CANNA_MODE_AdjustBunsetsuMode
1241 DEFVAR_INT ("canna-mode-adjust-bunsetsu-mode",
1242 &canna_mode_AdjustBunsetsuMode /*
1243
1244 */ );
1245 canna_mode_AdjustBunsetsuMode = CANNA_MODE_AdjustBunsetsuMode;
1246 #endif
1247 #ifdef CANNA_MODE_ChikujiYomiMode
1248 DEFVAR_INT ("canna-mode-chikuji-yomi-mode", &canna_mode_ChikujiYomiMode /*
1249
1250 */ );
1251 canna_mode_ChikujiYomiMode = CANNA_MODE_ChikujiYomiMode;
1252
1253 DEFVAR_INT ("canna-mode-chikuji-bunsetsu-mode",
1254 &canna_mode_ChikujiTanMode /*
1255
1256 */ );
1257 canna_mode_ChikujiTanMode = CANNA_MODE_ChikujiTanMode;
1258 #endif
1259
1260 DEFVAR_INT ("canna-mode-henkan-mode", &canna_mode_HenkanMode /*
1261
1262 */ );
1263 canna_mode_HenkanMode = IROHA_MODE_HenkanMode;
1264
1265 #ifdef CANNA_MODE_HenkanNyuryokuMode
1266 DEFVAR_INT ("canna-mode-henkan-nyuuryoku-mode",
1267 &canna_mode_HenkanNyuryokuMode /*
1268
1269 */ );
1270 canna_mode_HenkanNyuryokuMode = CANNA_MODE_HenkanNyuryokuMode;
1271 #endif
1272 #ifdef CANNA_MODE_ZenHiraHenkanMode
1273 DEFVAR_INT ("canna-mode-zen-hira-henkan-mode",
1274 &canna_mode_ZenHiraHenkanMode /*
1275
1276 */ );
1277 canna_mode_ZenHiraHenkanMode = CANNA_MODE_ZenHiraHenkanMode;
1278 #ifdef CANNA_MODE_HanHiraHenkanMode
1279 DEFVAR_INT ("canna-mode-han-hira-henkan-mode",
1280 &canna_mode_HanHiraHenkanMode /*
1281
1282 */ );
1283 canna_mode_HanHiraHenkanMode = CANNA_MODE_HanHiraHenkanMode;
1284 #endif
1285 DEFVAR_INT ("canna-mode-zen-kata-henkan-mode",
1286 &canna_mode_ZenKataHenkanMode /*
1287
1288 */ );
1289 canna_mode_ZenKataHenkanMode = CANNA_MODE_ZenKataHenkanMode;
1290
1291 DEFVAR_INT ("canna-mode-han-kata-henkan-mode",
1292 &canna_mode_HanKataHenkanMode /*
1293
1294 */ );
1295 canna_mode_HanKataHenkanMode = CANNA_MODE_HanKataHenkanMode;
1296
1297 DEFVAR_INT ("canna-mode-zen-alpha-henkan-mode",
1298 &canna_mode_ZenAlphaHenkanMode /*
1299
1300 */ );
1301 canna_mode_ZenAlphaHenkanMode = CANNA_MODE_ZenAlphaHenkanMode;
1302
1303 DEFVAR_INT ("canna-mode-han-alpha-henkan-mode",
1304 &canna_mode_HanAlphaHenkanMode /*
1305
1306 */ );
1307 canna_mode_HanAlphaHenkanMode = CANNA_MODE_HanAlphaHenkanMode;
1308 #endif
1309 DEFVAR_INT ("canna-mode-zen-hira-kakutei-mode",
1310 &canna_mode_ZenHiraKakuteiMode /*
1311
1312 */ );
1313 canna_mode_ZenHiraKakuteiMode = IROHA_MODE_ZenHiraKakuteiMode;
1314 #ifdef CANNA_MODE_HanHiraKakuteiMode
1315 DEFVAR_INT ("canna-mode-han-hira-kakutei-mode",
1316 &canna_mode_HanHiraKakuteiMode /*
1317
1318 */ );
1319 canna_mode_HanHiraKakuteiMode = CANNA_MODE_HanHiraKakuteiMode;
1320 #endif
1321 DEFVAR_INT ("canna-mode-zen-kata-kakutei-mode",
1322 &canna_mode_ZenKataKakuteiMode /*
1323
1324 */ );
1325 canna_mode_ZenKataKakuteiMode = IROHA_MODE_ZenKataKakuteiMode;
1326
1327 DEFVAR_INT ("canna-mode-han-kata-kakutei-mode",
1328 &canna_mode_HanKataKakuteiMode /*
1329
1330 */ );
1331 canna_mode_HanKataKakuteiMode = IROHA_MODE_HanKataKakuteiMode;
1332
1333 DEFVAR_INT ("canna-mode-zen-alpha-kakutei-mode",
1334 &canna_mode_ZenAlphaKakuteiMode /*
1335
1336 */ );
1337 canna_mode_ZenAlphaKakuteiMode = IROHA_MODE_ZenAlphaKakuteiMode;
1338
1339 DEFVAR_INT ("canna-mode-han-alpha-kakutei-mode",
1340 &canna_mode_HanAlphaKakuteiMode /*
1341
1342 */ );
1343 canna_mode_HanAlphaKakuteiMode = IROHA_MODE_HanAlphaKakuteiMode;
1344
1345 DEFVAR_INT ("canna-mode-hex-mode", &canna_mode_HexMode /*
1346
1347 */ );
1348 canna_mode_HexMode = IROHA_MODE_HexMode;
1349
1350 DEFVAR_INT ("canna-mode-bushu-mode", &canna_mode_BushuMode /*
1351
1352 */ );
1353 canna_mode_BushuMode = IROHA_MODE_BushuMode;
1354
1355 DEFVAR_INT ("canna-mode-extend-mode", &canna_mode_ExtendMode /*
1356
1357 */ );
1358 canna_mode_ExtendMode = IROHA_MODE_ExtendMode;
1359
1360 DEFVAR_INT ("canna-mode-russian-mode", &canna_mode_RussianMode /*
1361
1362 */ );
1363 canna_mode_RussianMode = IROHA_MODE_RussianMode;
1364
1365 DEFVAR_INT ("canna-mode-greek-mode", &canna_mode_GreekMode /*
1366
1367 */ );
1368 canna_mode_GreekMode = IROHA_MODE_GreekMode;
1369
1370 DEFVAR_INT ("canna-mode-line-mode", &canna_mode_LineMode /*
1371
1372 */ );
1373 canna_mode_LineMode = IROHA_MODE_LineMode;
1374
1375 DEFVAR_INT ("canna-mode-changing-server-mode",
1376 &canna_mode_ChangingServerMode /*
1377
1378 */ );
1379 canna_mode_ChangingServerMode = IROHA_MODE_ChangingServerMode;
1380
1381 DEFVAR_INT ("canna-mode-henkan-method-mode",
1382 &canna_mode_HenkanMethodMode /*
1383
1384 */ );
1385 canna_mode_HenkanMethodMode = IROHA_MODE_HenkanMethodMode;
1386
1387 DEFVAR_INT ("canna-mode-delete-dic-mode", &canna_mode_DeleteDicMode /*
1388
1389 */ );
1390 canna_mode_DeleteDicMode = IROHA_MODE_DeleteDicMode;
1391
1392 DEFVAR_INT ("canna-mode-touroku-mode", &canna_mode_TourokuMode /*
1393
1394 */ );
1395 canna_mode_TourokuMode = IROHA_MODE_TourokuMode;
1396
1397 DEFVAR_INT ("canna-mode-touroku-empty-mode",
1398 &canna_mode_TourokuEmptyMode /*
1399
1400 */ );
1401 canna_mode_TourokuEmptyMode = IROHA_MODE_TourokuEmptyMode;
1402
1403 DEFVAR_INT ("canna-mode-touroku-hinshi-mode",
1404 &canna_mode_TourokuHinshiMode /*
1405
1406 */ );
1407 canna_mode_TourokuHinshiMode = IROHA_MODE_TourokuHinshiMode;
1408
1409 DEFVAR_INT ("canna-mode-touroku-dic-mode", &canna_mode_TourokuDicMode /*
1410
1411 */ );
1412 canna_mode_TourokuDicMode = IROHA_MODE_TourokuDicMode;
1413
1414 DEFVAR_INT ("canna-mode-quoted-insert-mode",
1415 &canna_mode_QuotedInsertMode /*
1416
1417 */ );
1418 canna_mode_QuotedInsertMode = IROHA_MODE_QuotedInsertMode;
1419
1420 DEFVAR_INT ("canna-mode-bubun-muhenkan-mode",
1421 &canna_mode_BubunMuhenkanMode /*
1422
1423 */ );
1424 canna_mode_BubunMuhenkanMode = IROHA_MODE_BubunMuhenkanMode;
1425
1426 DEFVAR_INT ("canna-mode-mount-dic-mode", &canna_mode_MountDicMode /*
1427
1428 */ );
1429 canna_mode_MountDicMode = IROHA_MODE_MountDicMode;
1430
1431 DEFVAR_INT ("canna-func-self-insert", &canna_fn_SelfInsert /*
1432
1433 */ );
1434 canna_fn_SelfInsert = IROHA_FN_SelfInsert;
1435
1436 DEFVAR_INT ("canna-func-functional-insert", &canna_fn_FunctionalInsert /*
1437
1438 */ );
1439 canna_fn_FunctionalInsert = IROHA_FN_FunctionalInsert;
1440
1441 DEFVAR_INT ("canna-func-quoted-insert", &canna_fn_QuotedInsert /*
1442
1443 */ );
1444 canna_fn_QuotedInsert = IROHA_FN_QuotedInsert;
1445
1446 DEFVAR_INT ("canna-func-japanese-mode", &canna_fn_JapaneseMode /*
1447
1448 */ );
1449 canna_fn_JapaneseMode = IROHA_FN_JapaneseMode;
1450
1451 DEFVAR_INT ("canna-func-alpha-mode", &canna_fn_AlphaMode /*
1452
1453 */ );
1454 canna_fn_AlphaMode = IROHA_FN_AlphaMode;
1455
1456 DEFVAR_INT ("canna-func-henkan-nyuryoku-mode",
1457 &canna_fn_HenkanNyuryokuMode /*
1458
1459 */ );
1460 canna_fn_HenkanNyuryokuMode = IROHA_FN_HenkanNyuryokuMode;
1461
1462 DEFVAR_INT ("canna-func-forward", &canna_fn_Forward /*
1463
1464 */ );
1465 canna_fn_Forward = IROHA_FN_Forward;
1466
1467 DEFVAR_INT ("canna-func-backward", &canna_fn_Backward /*
1468
1469 */ );
1470 canna_fn_Backward = IROHA_FN_Backward;
1471
1472 DEFVAR_INT ("canna-func-next", &canna_fn_Next /*
1473
1474 */ );
1475 canna_fn_Next = IROHA_FN_Next;
1476
1477 DEFVAR_INT ("canna-func-previous", &canna_fn_Prev /*
1478
1479 */ );
1480 canna_fn_Prev = IROHA_FN_Prev;
1481
1482 DEFVAR_INT ("canna-func-beginning-of-line", &canna_fn_BeginningOfLine /*
1483
1484 */ );
1485 canna_fn_BeginningOfLine = IROHA_FN_BeginningOfLine;
1486
1487 DEFVAR_INT ("canna-func-end-of-line", &canna_fn_EndOfLine /*
1488
1489 */ );
1490 canna_fn_EndOfLine = IROHA_FN_EndOfLine;
1491
1492 DEFVAR_INT ("canna-func-delete-next", &canna_fn_DeleteNext /*
1493
1494 */ );
1495 canna_fn_DeleteNext = IROHA_FN_DeleteNext;
1496
1497 DEFVAR_INT ("canna-func-delete-previous", &canna_fn_DeletePrevious /*
1498
1499 */ );
1500 canna_fn_DeletePrevious = IROHA_FN_DeletePrevious;
1501
1502 DEFVAR_INT ("canna-func-kill-to-end-of-line", &canna_fn_KillToEndOfLine /*
1503
1504 */ );
1505 canna_fn_KillToEndOfLine = IROHA_FN_KillToEndOfLine;
1506
1507 DEFVAR_INT ("canna-func-henkan", &canna_fn_Henkan /*
1508
1509 */ );
1510 canna_fn_Henkan = IROHA_FN_Henkan;
1511
1512 DEFVAR_INT ("canna-func-kakutei", &canna_fn_Kakutei /*
1513
1514 */ );
1515 canna_fn_Kakutei = IROHA_FN_Kakutei;
1516
1517 DEFVAR_INT ("canna-func-extend", &canna_fn_Extend /*
1518
1519 */ );
1520 canna_fn_Extend = IROHA_FN_Extend;
1521
1522 DEFVAR_INT ("canna-func-shrink", &canna_fn_Shrink /*
1523
1524 */ );
1525 canna_fn_Shrink = IROHA_FN_Shrink;
1526
1527 #ifdef CANNA_FN_AdjustBunsetsu
1528 DEFVAR_INT ("canna-func-adjust-bunsetsu", &canna_fn_AdjustBunsetsu /*
1529
1530 */ );
1531 canna_fn_AdjustBunsetsu = CANNA_FN_AdjustBunsetsu;
1532 #endif
1533 DEFVAR_INT ("canna-func-quit", &canna_fn_Quit /*
1534
1535 */ );
1536 canna_fn_Quit = IROHA_FN_Quit;
1537
1538 DEFVAR_INT ("canna-func-convert-as-hex", &canna_fn_ConvertAsHex /*
1539
1540 */ );
1541 canna_fn_ConvertAsHex = IROHA_FN_ConvertAsHex;
1542
1543 DEFVAR_INT ("canna-func-convert-as-bushu", &canna_fn_ConvertAsBushu /*
1544
1545 */ );
1546 canna_fn_ConvertAsBushu = IROHA_FN_ConvertAsBushu;
1547
1548 DEFVAR_INT ("canna-func-kouho-ichiran", &canna_fn_KouhoIchiran /*
1549
1550 */ );
1551 canna_fn_KouhoIchiran = IROHA_FN_KouhoIchiran;
1552
1553 DEFVAR_INT ("canna-func-bubun-muhenkan", &canna_fn_BubunMuhenkan /*
1554
1555 */ );
1556 canna_fn_BubunMuhenkan = IROHA_FN_BubunMuhenkan;
1557
1558 DEFVAR_INT ("canna-func-zenkaku", &canna_fn_Zenkaku /*
1559
1560 */ );
1561 canna_fn_Zenkaku = IROHA_FN_Zenkaku;
1562
1563 DEFVAR_INT ("canna-func-hankaku", &canna_fn_Hankaku /*
1564
1565 */ );
1566 canna_fn_Hankaku = IROHA_FN_Hankaku;
1567
1568 DEFVAR_INT ("canna-func-to-upper", &canna_fn_ToUpper /*
1569
1570 */ );
1571 canna_fn_ToUpper = IROHA_FN_ToUpper;
1572
1573 DEFVAR_INT ("canna-func-capitalize", &canna_fn_Capitalize /*
1574
1575 */ );
1576 canna_fn_Capitalize = IROHA_FN_Capitalize;
1577
1578 DEFVAR_INT ("canna-func-to-lower", &canna_fn_ToLower /*
1579
1580 */ );
1581 canna_fn_ToLower = IROHA_FN_ToLower;
1582
1583 DEFVAR_INT ("canna-func-hiragana", &canna_fn_Hiragana /*
1584
1585 */ );
1586 canna_fn_Hiragana = IROHA_FN_Hiragana;
1587
1588 DEFVAR_INT ("canna-func-katakana", &canna_fn_Katakana /*
1589
1590 */ );
1591 canna_fn_Katakana = IROHA_FN_Katakana;
1592
1593 DEFVAR_INT ("canna-func-romaji", &canna_fn_Romaji /*
1594
1595 */ );
1596 canna_fn_Romaji = IROHA_FN_Romaji;
1597
1598 #ifdef CANNA_FN_BaseHiragana
1599 DEFVAR_INT ("canna-func-base-hiragana", &canna_fn_BaseHiragana /*
1600
1601 */ );
1602 canna_fn_BaseHiragana = CANNA_FN_BaseHiragana;
1603
1604 DEFVAR_INT ("canna-func-base-katakana", &canna_fn_BaseKatakana /*
1605
1606 */ );
1607 canna_fn_BaseKatakana = CANNA_FN_BaseKatakana;
1608
1609 DEFVAR_INT ("canna-func-base-eisu", &canna_fn_BaseEisu /*
1610
1611 */ );
1612 canna_fn_BaseEisu = CANNA_FN_BaseEisu;
1613
1614 DEFVAR_INT ("canna-func-base-zenkaku", &canna_fn_BaseZenkaku /*
1615
1616 */ );
1617 canna_fn_BaseZenkaku = CANNA_FN_BaseZenkaku;
1618
1619 DEFVAR_INT ("canna-func-base-hankaku", &canna_fn_BaseHankaku /*
1620
1621 */ );
1622 canna_fn_BaseHankaku = CANNA_FN_BaseHankaku;
1623
1624 DEFVAR_INT ("canna-func-base-kana", &canna_fn_BaseKana /*
1625
1626 */ );
1627 canna_fn_BaseKana = CANNA_FN_BaseKana;
1628
1629 DEFVAR_INT ("canna-func-base-kakutei", &canna_fn_BaseKakutei /*
1630
1631 */ );
1632 canna_fn_BaseKakutei = CANNA_FN_BaseKakutei;
1633
1634 DEFVAR_INT ("canna-func-base-henkan", &canna_fn_BaseHenkan /*
1635
1636 */ );
1637 canna_fn_BaseHenkan = CANNA_FN_BaseHenkan;
1638
1639 DEFVAR_INT ("canna-func-base-hiragana-katakana-toggle",
1640 &canna_fn_BaseHiraKataToggle /*
1641
1642 */ );
1643 canna_fn_BaseHiraKataToggle = CANNA_FN_BaseHiraKataToggle;
1644
1645 DEFVAR_INT ("canna-func-base-zenkaku-hankaku-toggle",
1646 &canna_fn_BaseZenHanToggle /*
1647
1648 */ );
1649 canna_fn_BaseZenHanToggle = CANNA_FN_BaseZenHanToggle;
1650
1651 DEFVAR_INT ("canna-func-base-kana-eisu-toggle",
1652 &canna_fn_BaseKanaEisuToggle /*
1653
1654 */ );
1655 canna_fn_BaseKanaEisuToggle = CANNA_FN_BaseKanaEisuToggle;
1656
1657 DEFVAR_INT ("canna-func-base-kakutei-henkan-toggle",
1658 &canna_fn_BaseKakuteiHenkanToggle /*
1659
1660 */ );
1661 canna_fn_BaseKakuteiHenkanToggle = CANNA_FN_BaseKakuteiHenkanToggle;
1662
1663 DEFVAR_INT ("canna-func-base-rotate-forward",
1664 &canna_fn_BaseRotateForward /*
1665
1666 */ );
1667 canna_fn_BaseRotateForward = CANNA_FN_BaseRotateForward;
1668
1669 DEFVAR_INT ("canna-func-base-rotate-backward",
1670 &canna_fn_BaseRotateBackward /*
1671
1672 */ );
1673 canna_fn_BaseRotateBackward = CANNA_FN_BaseRotateBackward;
1674
1675 #endif
1676 DEFVAR_INT ("canna-func-extend-mode", &canna_fn_ExtendMode /*
1677
1678 */ );
1679 canna_fn_ExtendMode = IROHA_FN_ExtendMode;
1680
1681 DEFVAR_INT ("canna-func-touroku", &canna_fn_Touroku /*
1682
1683 */ );
1684 canna_fn_Touroku = IROHA_FN_Touroku;
1685
1686 DEFVAR_INT ("canna-func-hex-mode", &canna_fn_HexMode /*
1687
1688 */ );
1689 canna_fn_HexMode = IROHA_FN_HexMode;
1690
1691 DEFVAR_INT ("canna-func-bushu-mode", &canna_fn_BushuMode /*
1692
1693 */ );
1694 canna_fn_BushuMode = IROHA_FN_BushuMode;
1695
1696 DEFVAR_INT ("canna-func-kigo-mode", &canna_fn_KigouMode /*
1697
1698 */ );
1699 canna_fn_KigouMode = IROHA_FN_KigouMode;
1700
1701 #ifdef CANNA_FN_Mark
1702 DEFVAR_INT ("canna-func-mark", &canna_fn_Mark /*
1703
1704 */ );
1705 canna_fn_Mark = CANNA_FN_Mark;
1706 #endif
1707 #ifdef CANNA_FN_TemporalMode
1708 DEFVAR_INT ("canna-func-temporal-mode", &canna_fn_TemporalMode /*
1709
1710 */ );
1711 canna_fn_TemporalMode = CANNA_FN_TemporalMode;
1712 #endif
1713
1714 DEFVAR_INT ("canna-key-nfer", &canna_key_Nfer /*
1715
1716 */ );
1717 canna_key_Nfer = IROHA_KEY_Nfer;
1718
1719 DEFVAR_INT ("canna-key-xfer", &canna_key_Xfer /*
1720
1721 */ );
1722 canna_key_Xfer = IROHA_KEY_Xfer;
1723
1724 DEFVAR_INT ("canna-key-up", &canna_key_Up /*
1725
1726 */ );
1727 canna_key_Up = IROHA_KEY_Up;
1728
1729 DEFVAR_INT ("canna-key-left", &canna_key_Left /*
1730
1731 */ );
1732 canna_key_Left = IROHA_KEY_Left;
1733
1734 DEFVAR_INT ("canna-key-right", &canna_key_Right /*
1735
1736 */ );
1737 canna_key_Right = IROHA_KEY_Right;
1738
1739 DEFVAR_INT ("canna-key-down", &canna_key_Down /*
1740
1741 */ );
1742 canna_key_Down = IROHA_KEY_Down;
1743
1744 DEFVAR_INT ("canna-key-insert", &canna_key_Insert /*
1745
1746 */ );
1747 canna_key_Insert = IROHA_KEY_Insert;
1748
1749 DEFVAR_INT ("canna-key-rollup", &canna_key_Rollup /*
1750
1751 */ );
1752 canna_key_Rollup = IROHA_KEY_Rollup;
1753
1754 DEFVAR_INT ("canna-key-rolldown", &canna_key_Rolldown /*
1755
1756 */ );
1757 canna_key_Rolldown = IROHA_KEY_Rolldown;
1758
1759 DEFVAR_INT ("canna-key-home", &canna_key_Home /*
1760
1761 */ );
1762 canna_key_Home = IROHA_KEY_Home;
1763
1764 DEFVAR_INT ("canna-key-help", &canna_key_Help /*
1765
1766 */ );
1767 canna_key_Help = IROHA_KEY_Help;
1768
1769 DEFVAR_INT ("canna-key-kp-key", &canna_key_KP_Key /*
1770
1771 */ );
1772 canna_key_KP_Key = IROHA_KEY_KP_Key;
1773
1774 DEFVAR_INT ("canna-key-shift-nfer", &canna_key_Shift_Nfer /*
1775
1776 */ );
1777 canna_key_Shift_Nfer = IROHA_KEY_Shift_Nfer;
1778
1779 DEFVAR_INT ("canna-key-shift-xfer", &canna_key_Shift_Xfer /*
1780
1781 */ );
1782 canna_key_Shift_Xfer = IROHA_KEY_Shift_Xfer;
1783
1784 DEFVAR_INT ("canna-key-shift-up", &canna_key_Shift_Up /*
1785
1786 */ );
1787 canna_key_Shift_Up = IROHA_KEY_Shift_Up;
1788
1789 DEFVAR_INT ("canna-key-shift-left", &canna_key_Shift_Left /*
1790
1791 */ );
1792 canna_key_Shift_Left = IROHA_KEY_Shift_Left;
1793
1794 DEFVAR_INT ("canna-key-shift-right", &canna_key_Shift_Right /*
1795
1796 */ );
1797 canna_key_Shift_Right = IROHA_KEY_Shift_Right;
1798
1799 DEFVAR_INT ("canna-key-shift-down", &canna_key_Shift_Down /*
1800
1801 */ );
1802 canna_key_Shift_Down = IROHA_KEY_Shift_Down;
1803
1804 DEFVAR_INT ("canna-key-control-nfer", &canna_key_Cntrl_Nfer /*
1805
1806 */ );
1807 canna_key_Cntrl_Nfer = IROHA_KEY_Cntrl_Nfer;
1808
1809 DEFVAR_INT ("canna-key-control-xfer", &canna_key_Cntrl_Xfer /*
1810
1811 */ );
1812 canna_key_Cntrl_Xfer = IROHA_KEY_Cntrl_Xfer;
1813
1814 DEFVAR_INT ("canna-key-control-up", &canna_key_Cntrl_Up /*
1815
1816 */ );
1817 canna_key_Cntrl_Up = IROHA_KEY_Cntrl_Up;
1818
1819 DEFVAR_INT ("canna-key-control-left", &canna_key_Cntrl_Left /*
1820
1821 */ );
1822 canna_key_Cntrl_Left = IROHA_KEY_Cntrl_Left;
1823
1824 DEFVAR_INT ("canna-key-control-right", &canna_key_Cntrl_Right /*
1825
1826 */ );
1827 canna_key_Cntrl_Right = IROHA_KEY_Cntrl_Right;
1828
1829 DEFVAR_INT ("canna-key-control-down", &canna_key_Cntrl_Down /*
1830
1831 */ );
1832 canna_key_Cntrl_Down = IROHA_KEY_Cntrl_Down;
1833
1834 Fprovide (intern ("CANNA"));
1835 }
1836
1837 #if 0
1838 #ifdef HAVE_SHLIB
1839 void unload_canna_api (void);
1840 void
1841 unload_canna_api (void)
1842 {
1843 /* We don't need to do anything here in the sample case. However, if you
1844 create any new types with INIT_LRECORD_IMPLEMENTATION (sample_type), then
1845 UNDEF_LRECORD_IMPLEMENTATION (sample_type) must appear here. Also, any
1846 symbols declared with DEFSYMBOL (Qsample_var), or one of its variants,
1847 must have a corresponding unstaticpro_nodump (&Qsample_var) here. */
1848 }
1849 #endif
1850 #endif
1851
1852 #ifdef CANNA_MULE
1853 /* To handle MULE internal code and EUC.
1854 I assume CANNA can handle only Japanese EUC. */
1855
1856 /* EUC multibyte string to MULE internal string */
1857
1858 static void
1859 c2mu (unsigned char *cp, int l, unsigned char *mp)
1860 {
1861 unsigned char ch, *ep = cp+l;
1862
1863 while ((cp < ep) && (ch = *cp))
1864 {
1865 if ((unsigned char) ch == ISO_CODE_SS2)
1866 {
1867 *mp++ = LEADING_BYTE_KATAKANA_JISX0201;
1868 cp++;
1869 }
1870 else if ((unsigned char) ch == ISO_CODE_SS3)
1871 {
1872 *mp++ = LEADING_BYTE_JAPANESE_JISX0212;
1873 cp++;
1874 *mp++ = *cp++;
1875 }
1876 else if (ch & 0x80)
1877 {
1878 *mp++ = LEADING_BYTE_JAPANESE_JISX0208;
1879 *mp++ = *cp++;
1880 }
1881 *mp++ = *cp++;
1882 }
1883 *mp = 0;
1884 }
1885
1886 /* MULE internal string to EUC multibyte string */
1887
1888 static void
1889 m2c (unsigned char *mp, int l, unsigned char *cp)
1890 {
1891 unsigned char ch, *ep = mp + l;
1892
1893 while ((mp < ep) && (ch = *mp++))
1894 {
1895 switch (ch)
1896 {
1897 case LEADING_BYTE_KATAKANA_JISX0201:
1898 *cp++ = ISO_CODE_SS2;
1899 *cp++ = *mp++;
1900 break;
1901 case LEADING_BYTE_JAPANESE_JISX0212:
1902 *cp++ = ISO_CODE_SS3;
1903 case LEADING_BYTE_JAPANESE_JISX0208:
1904 *cp++ = *mp++;
1905 *cp++ = *mp++;
1906 break;
1907 default:
1908 *cp++ = ch;
1909 break;
1910 }
1911 }
1912 *cp = 0;
1913 }
1914
1915 #undef make_string
1916
1917 /* make_string after converting EUC string to MULE internal string */
1918 static Lisp_Object
1919 mule_make_string (unsigned char *p, int l)
1920 {
1921 unsigned char cbuf[4096];
1922
1923 c2mu (p,l,cbuf);
1924 return (make_string (cbuf, strlen ((const char *) cbuf)));
1925 }
1926
1927 /* return the MULE internal string length of EUC string */
1928 /* Modified by sb to return a character count not byte count. */
1929 static int
1930 mule_strlen (unsigned char *p, int l)
1931 {
1932 unsigned char ch, *cp = p;
1933 int len = 0;
1934
1935 while ((cp < p + l) && (ch = *cp))
1936 {
1937 if ((unsigned char) ch == ISO_CODE_SS2)
1938 {
1939 len++;
1940 cp += 2;
1941 }
1942 else if ((unsigned char) ch == ISO_CODE_SS3)
1943 {
1944 len++;
1945 cp += 3;
1946 }
1947 else if (ch & 0x80)
1948 {
1949 len++;
1950 cp += 2;
1951 }
1952 else
1953 {
1954 len++;
1955 cp++;
1956 }
1957 }
1958 return (len);
1959 }
1960
1961 /* count number of characters */
1962 static void
1963 count_char (unsigned char *p, int len, int pos, int rev,
1964 Fixnum *clen, Fixnum *cpos, Fixnum *crev)
1965 {
1966 unsigned char *q = p;
1967
1968 *clen = *cpos = *crev = 0;
1969 if (len == 0) return;
1970 while (q < p + pos)
1971 {
1972 (*clen)++;
1973 (*cpos)++;
1974 if (*q++ & 0x80) q++;
1975 }
1976 while (q < p + pos + rev)
1977 {
1978 (*clen)++;
1979 (*crev)++;
1980 if (*q++ & 0x80) q++;
1981 }
1982 while (q < p + len)
1983 {
1984 (*clen)++;
1985 if (*q++ & 0x80) q++;
1986 }
1987 }
1988 #endif /* CANNA_MULE */