From d4ea746dbf0241e86d9f140d8570816bd0992426 Mon Sep 17 00:00:00 2001 From: morioka Date: Thu, 6 Mar 1997 12:41:59 +0000 Subject: [PATCH 1/1] *** empty log message *** --- canna.c | 1337 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1337 insertions(+) create mode 100644 canna.c diff --git a/canna.c b/canna.c new file mode 100644 index 0000000..b41f45d --- /dev/null +++ b/canna.c @@ -0,0 +1,1337 @@ +/* + CANNA interface for NEmacs + + This file is a part of Canna on Nemacs. + + Canna on Nemacs is distributed in the forms of patches + to Nemacs under the terms of the GNU EMACS GENERAL + PUBLIC LICENSE which is distributed along with GNU Emacs + by the Free Software Foundation. + + Canna on Nemacs is distributed in the hope that it will + be useful, but WITHOUT ANY WARRANTY; without even the + implied warranty of MERCHANTABILITY or FITNESS FOR A + PARTICULAR PURPOSE. See the GNU EMACS GENERAL PUBLIC + LICENSE for more details. + + You should have received a copy of the GNU EMACS GENERAL + PUBLIC LICENSE along with Nemacs; see the file COPYING. + If not, write to the Free Software Foundation, 675 Mass + Ave, Cambridge, MA 02139, USA. + + Authors: Akira Kon (kon@d1.bs2.mt.nec.co.jp) + Ichiro Hirakura (hirakura@uxp.bs2.mt.nec.co.jp) + + Functions defined in this file are + + (canna-key-proc key) + key: single STRING + RETURNS: + Length of converted string if no error occurs. + Error string if error occurs. + DESCRIPTION: + Convert a key input to a set of strings. The + strings contain both well-formed string and a + intermediate result to show the translation + information to a user. converted strings are + stored in specific variables. + + (canna-initialize) + RETURNS: + List of the following things: + - list of keys to toggle Japanese-mode + - error message + - list of warning messages + DESCRIPTION: + Initialize ``canna'', which is a kana-to-kanji + converter for GNU Emacs. The first arg + specifies if inserting space character between + BUNSETSU when candidates are displayed. The + second arg specifies server. The third arg + specifies a file which will be used as a + customization description. If nil is + specified for each arg, the default value will + be used. + + (canna-finalize) + RETURNS: + list of warning messages + DESCRIPTION: + finalize ``canna'', which is a kana-to-kanji + converter for GNU Emacs. This cause to write + miscellaneous informations to kana-to-kanji + dictionary. + + (canna-touroku-string string) + string: + String to register to a dictionary. + RETURNS: + The same thing returns as canna-key-proc does. + DESCRIPTION: + Register Kanji words into kana-to-kanji + conversion dictionary. + + (canna-set-width width) + width: + Column width of the place where the candidates + of kana-to-kanji conversion will be shown. + RETURNS: + nil + DESCRIPTION: + Set status-line width information, which is + used to display kanji candidates. + + (canna-change-mode num) + num: + The mode number of Canna. + RETURNS: + The same thing returns as canna-key-proc does. + DESCRIPTION: + Change Japanese pre-edit mode. + + (canna-store-yomi yomi roma) + yomi: + ``Yomi'' to be stored. + roma: + ``Romaji'' which corresponds to the ``Yomi''. + RETURNS: + The same thing returns as canna-key-proc does. + DESCRIPTION: + Store yomi characters as a YOMI of + kana-to-kanji conversion. + + (canna-do-function num ch) + num: + A function number to be called. + ch: + A character will be specified in order to feed + the character to the function if the function + needs a input character. + RETURNS: + The same thing returns as canna-key-proc does. + DESCRIPTION: + Do specified function at current mode. + + (canna-parse string) + string: + To be parsed. + RETURNS: + List of warning messages. + DESCRIPTION: + Parse customize string. + + (canna-query-mode) + RETURNS: + A string which indicate the current mode. + DESCRIPTION: + Get current mode string. + + Functions below are used for KKCP compatible library. These + functions provides a base kana-to-kanji conversion system for EGG. + These functions may be used when users want to change the engine + from Wnn to Canna without changing user interface of Japanese input. + + (canna-henkan-begin) + (canna-henkan-next) + (canna-bunsetu-henkou) + (canna-henkan-kakutei) + (canna-henkan-end) + (canna-henkan-quit) + + */ + +#ifndef lint +static char rcs_id[] = "$Id: canna.c,v 1.35 1997-03-06 12:41:59 morioka Exp $"; +#endif + +#include + +#include "config.h" +#include "lisp.h" +#include "buffer.h" +#ifdef CANNA_MULE +#include "charset.h" +#endif + +#ifdef CANNA2 +#define IROHA_BC +#include "canna/jrkanji.h" +#include "canna/RK.h" +#else /* !CANNA2 */ +#include "iroha/jrkanji.h" +#include "iroha/RK.h" +#endif /* !CANNA2 */ +extern char *jrKanjiError; + +#define KEYTOSTRSIZE 2048 +static unsigned char buf[KEYTOSTRSIZE]; +static char **warning; + +static int Vcanna_empty_info, Vcanna_through_info; +static int Vcanna_underline; +static int Vcanna_inhibit_hankakukana; /* hir, 1994.12.5 */ + +static Lisp_Object Vcanna_kakutei_string; +static Lisp_Object Vcanna_kakutei_yomi; +static Lisp_Object Vcanna_kakutei_romaji; +static Lisp_Object Vcanna_henkan_string; +static int Vcanna_henkan_length; +static int Vcanna_henkan_revPos; +static int Vcanna_henkan_revLen; +static Lisp_Object Vcanna_ichiran_string; +static int Vcanna_ichiran_length; +static int Vcanna_ichiran_revPos; +static int Vcanna_ichiran_revLen; +static Lisp_Object Vcanna_mode_string; + +static int IRCP_context; + +#if __STDC__ +static Lisp_Object storeResults(unsigned char *, int, jrKanjiStatus *); +static Lisp_Object kanjiYomiList(int, int); +#else +static Lisp_Object storeResults(); +static Lisp_Object kanjiYomiList(); +#endif + +#ifdef CANNA_MULE +#if __STDC__ +static m2c(unsigned char *, int, unsigned char *); +static Lisp_Object mule_make_string(unsigned char *, int); +static mule_strlen(unsigned char *, int); +static count_char(unsigned char *,int, int, int, int *, int *, int *); +#else +static m2c(); +static Lisp_Object mule_make_string(); +static mule_strlen(); +static count_char(); +#endif +#define make_string mule_make_string +#endif + +/* Lisp functions definition */ + +DEFUN ("canna-key-proc", Fcanna_key_proc, Scanna_key_proc, + 1, 1, 0, +"Translate a key input to a set of strings. The strings contain both\n\ +well-formed string and intermediate result to show the translation\n\ +information to a user. Converted strings are stored in specific\n\ +variables.") + (ch) +Lisp_Object ch; +{ + jrKanjiStatus ks; + int len; + + CHECK_NUMBER (ch, 0); + len = jrKanjiString(0, XINT (ch), buf, KEYTOSTRSIZE, &ks); + return storeResults(buf, len, &ks); +} + +static +Lisp_Object +storeResults(buf, len, ks) +unsigned char *buf; +int len; +jrKanjiStatus *ks; +{ + Lisp_Object val = Qnil; + + if (len < 0) { /* Error detected */ + val = make_string((unsigned char*)jrKanjiError, strlen(jrKanjiError)); + } + else { + /* ³ÎÄꤷ¤¿Ê¸»úÎó */ + Vcanna_kakutei_string = make_string(buf, len); + val = make_number(len); + /* ³ÎÄꤷ¤¿Ê¸»úÎó¤ÎÆɤߤξðÊó... */ + Vcanna_kakutei_yomi = Vcanna_kakutei_romaji = Qnil; + if (ks->info & KanjiYomiInfo) { + unsigned char *p = buf + len + 1; + int yomilen = strlen(p); + + if (len + yomilen + 1 < KEYTOSTRSIZE) { + int yomilen2; + + Vcanna_kakutei_yomi = make_string(p, yomilen); /* ÆÉ¤ß */ + p += yomilen + 1; + yomilen2 = strlen(p); + if (len + yomilen + yomilen2 + 2 < KEYTOSTRSIZE) { + Vcanna_kakutei_romaji = make_string(p, yomilen2); /* ¥í¡¼¥Þ»ú */ + } + } + } + + + /* ¸õÊäɽ¼¨¤Îʸ»úÎó¤Ç¤¹¡£*/ + Vcanna_henkan_string = Qnil; + if (ks->length >= 0) { + Vcanna_henkan_string = make_string(ks->echoStr, ks->length); +#ifndef CANNA_MULE + Vcanna_henkan_length = ks->length; + Vcanna_henkan_revPos = ks->revPos; + Vcanna_henkan_revLen = ks->revLen; +#else /* CANNA_MULE */ + if (Vcanna_underline) { + Vcanna_henkan_length = mule_strlen(ks->echoStr,ks->length); + Vcanna_henkan_revPos = mule_strlen(ks->echoStr,ks->revPos); + Vcanna_henkan_revLen = mule_strlen(ks->echoStr+ks->revPos,ks->revLen); + } + else { + count_char(ks->echoStr, ks->length, ks->revPos, ks->revLen, + &Vcanna_henkan_length, &Vcanna_henkan_revPos, + &Vcanna_henkan_revLen); + } +#endif /* CANNA_MULE */ + } + + /* °ìÍ÷¤Î¾ðÊó */ + Vcanna_ichiran_string = Qnil; + if (ks->info & KanjiGLineInfo && ks->gline.length >= 0) { + Vcanna_ichiran_string = make_string(ks->gline.line, ks->gline.length); +#ifndef CANNA_MULE + Vcanna_ichiran_length = ks->gline.length; + Vcanna_ichiran_revPos = ks->gline.revPos; + Vcanna_ichiran_revLen = ks->gline.revLen; +#else /* CANNA_MULE */ + count_char(ks->gline.line, ks->gline.length, + ks->gline.revPos, ks->gline.revLen, &Vcanna_ichiran_length, + &Vcanna_ichiran_revPos, &Vcanna_ichiran_revLen); +#endif /* CANNA_MULE */ + } + + /* ¥â¡¼¥É¤Î¾ðÊó */ + Vcanna_mode_string = Qnil; + if (ks->info & KanjiModeInfo) { + Vcanna_mode_string = make_string(ks->mode, strlen(ks->mode)); + } + + /* ¤½¤Î¾¤Î¾ðÊó */ + Vcanna_empty_info = (ks->info & KanjiEmptyInfo) ? 1 : 0; + Vcanna_through_info = (ks->info & KanjiThroughInfo) ? 1 : 0; + } + + return val; +} + +DEFUN ("canna-set-bunsetsu-kugiri", Fcanna_set_bunsetsu, Scanna_set_bunsetsu, + 0, 1, 0, +"This function sets the clause separator.\n\ +If non-nil value is specified, the white space separator will be used.\n\ +No separator will be used otherwise.") +(num) +Lisp_Object num; +{ + int kugiri; /* ʸÀá¶èÀÚ¤ê¤ò¤¹¤ë¤«¡© */ + + kugiri = NILP(num) ? 0 : 1; + + jrKanjiControl(0, KC_SETBUNSETSUKUGIRI, (char *)kugiri); +} + +DEFUN ("canna-initialize", Fcanna_initialize, Scanna_initialize, 0, 3, 0, +"Initialize ``canna'', which is a kana-to-kanji converter for GNU Emacs.\n\ +The first arg specifies if inserting space character between BUNSETSU when\n\ +candidates are displayed.\n\ +The second arg specifies server.\n\ +The third arg specifies a file which will be used as a customization\n\ +description.\n\ +If nil is specified for each arg, the default value will be used.") +(num, server, rcfile) +Lisp_Object num, server, rcfile; +{ + Lisp_Object val; + int res; + unsigned char **p, **q; + + int kugiri; /* ʸÀá¶èÀÚ¤ê¤ò¤¹¤ë¤«¡© */ + + IRCP_context = -1; + + if (NILP(num)) { + kugiri = 1; + } + else { + CHECK_NUMBER(num, 0); + kugiri = XINT(num); + kugiri = (kugiri == 1) ? 1 : 0; + } + + if (NILP(server)) { + jrKanjiControl(0, KC_SETSERVERNAME, (char *)0); + } + else { + char servername[256]; + + CHECK_STRING(server, 0); + strncpy(servername, XSTRING(server)->data, XSTRING(server)->size); + servername[XSTRING(server)->size] = '\0'; + jrKanjiControl(0, KC_SETSERVERNAME, servername); + } + + if (NILP(rcfile)) { + jrKanjiControl(0, KC_SETINITFILENAME, (char *)0); + } + else { + char rcname[256]; + + CHECK_STRING(rcfile, 0); + strncpy(rcname, XSTRING(rcfile)->data, XSTRING(rcfile)->size); + rcname[XSTRING(rcfile)->size] = '\0'; + jrKanjiControl(0, KC_SETINITFILENAME, rcname); + } + + warning = (char **)0; +#ifdef nec_ews_svr4 /* hir, 1994.2.24 */ + stop_polling (); +#endif /* nec_ews_svr4 */ + res = jrKanjiControl(0, KC_INITIALIZE, (char *)&warning); +#ifdef nec_ews_svr4 /* hir, 1994.2.24 */ + start_polling (); +#endif /* nec_ews_svr4 */ + val = Qnil; + if (warning) { + for (p = q = (unsigned char **)warning ; *q ; q++) + ; + while (p < q) { + q--; + val = Fcons(make_string(*q, strlen(*q)), val); + } + } + val = Fcons(val, Qnil); + + if (res == -1) { + val = Fcons(make_string((unsigned char*)jrKanjiError, + strlen(jrKanjiError)), val); + /* ¥¤¥Ë¥·¥ã¥é¥¤¥º¤Ç¼ºÇÔ¤·¤¿¾ì¹ç¡£ */ + return Fcons(Qnil, val); + } + else { + extern (*jrBeepFunc)(); + Lisp_Object Fding(), CANNA_mode_keys(); + + jrBeepFunc = Fding; + +#ifdef KC_SETAPPNAME +#ifndef CANNA_MULE + wcKanjiControl(0, KC_SETAPPNAME, "nemacs"); +#else /* CANNA_MULE */ + wcKanjiControl(0, KC_SETAPPNAME, "mule"); +#endif /* CANNA_MULE */ +#endif /* KC_SETAPPNAME */ + + jrKanjiControl(0, KC_SETBUNSETSUKUGIRI, (char *)kugiri); + jrKanjiControl(0, KC_SETWIDTH, (char *)78); +#ifndef CANNA_MULE + jrKanjiControl(0, KC_INHIBITHANKAKUKANA, (char *)1); +#else /* hir, 1994.12.5 */ + /* mule ¤À¤Ã¤¿¤éȾ³Ñ¥«¥¿¥«¥Ê¤â»È¤¨¤ë */ + if (Vcanna_inhibit_hankakukana) + jrKanjiControl(0, KC_INHIBITHANKAKUKANA, (char *)1); +#endif + jrKanjiControl(0, KC_YOMIINFO, (char *)2); /* ¢¨£²: ¥í¡¼¥Þ»ú¤Þ¤ÇÊÖ¤¹ */ + val = Fcons(Qnil, val); + return Fcons(CANNA_mode_keys(), val); + } +} + +DEFUN ("canna-finalize", Fcanna_finalize, Scanna_finalize, 0, 0, 0, +"finalize ``canna'', which is a kana-to-kanji converter for GNU Emacs.\n\ +This cause to write miscellaneous informations to kana-to-kanji dictionary.") +() +{ + Lisp_Object val; + unsigned char **p; + + jrKanjiControl(0, KC_FINALIZE, (char *)&warning); + + val = Qnil; + if (warning) { + for (p = (unsigned char**)warning ; *p ; p++) { + val = Fcons(make_string(*p, strlen(*p)), val); + } + } + val = Fcons(val, Qnil); + IRCP_context = -1; + return val; +} + +DEFUN ("canna-touroku-string", Fcanna_touroku_string, + Scanna_touroku_string, 1, 1, 0, +"Register Kanji words into kana-to-kanji conversion dictionary.") + (str) +Lisp_Object str; +{ + jrKanjiStatusWithValue ksv; + jrKanjiStatus ks; + int len; + Lisp_Object val; +#ifdef CANNA_MULE + unsigned char cbuf[4096]; +#endif + + CHECK_STRING(str, 0); + ksv.buffer = (unsigned char *)buf; + ksv.bytes_buffer = KEYTOSTRSIZE; +#ifndef CANNA_MULE + ks.echoStr = XSTRING (str)->data; + ks.length = XSTRING (str)->size; +#else /* CANNA_MULE */ + m2c(XSTRING (str)->data, XSTRING (str)->size, cbuf); + ks.echoStr = cbuf; + ks.length = strlen(cbuf); +#endif /* CANNA_MULE */ + ksv.ks = &ks; + len = jrKanjiControl(0, KC_DEFINEKANJI, (char *)&ksv); + val = storeResults(buf, ksv.val, ksv.ks); + return val; +} + +DEFUN ("canna-set-width", Fcanna_set_width, + Scanna_set_width, 1, 1, 0, +"Set status-line width information, which is used to display \n\ +kanji candidates.") + (num) +Lisp_Object num; +{ + CHECK_NUMBER(num, 0); + + jrKanjiControl(0, KC_SETWIDTH, (char *)XINT (num)); + return Qnil; +} + +DEFUN ("canna-change-mode", Fcanna_change_mode, + Scanna_change_mode, 1, 1, 0, +"Change Japanese pre-edit mode.") + (num) +Lisp_Object num; +{ + jrKanjiStatusWithValue ksv; + jrKanjiStatus ks; + Lisp_Object val; + + CHECK_NUMBER(num, 0); + + ksv.buffer = (unsigned char *)buf; + ksv.bytes_buffer = KEYTOSTRSIZE; + ksv.ks = &ks; + ksv.val = XINT (num); + jrKanjiControl(0, KC_CHANGEMODE, (char *)&ksv); + val = storeResults(buf, ksv.val, ksv.ks); + return val; +} + +Lisp_Object +CANNA_mode_keys() +{ +#define CANNAWORKBUFSIZE 32 + char xxx[CANNAWORKBUFSIZE]; + Lisp_Object val; + int i, n; + + n = jrKanjiControl(0, KC_MODEKEYS, xxx); + val = Qnil; + for (i = n ; i > 0 ;) { + --i; + val = Fcons(make_number((int)(0xFF & (unsigned char)xxx[i])), val); + } + return val; +} + +DEFUN ("canna-store-yomi", Fcanna_store_yomi, Scanna_store_yomi, + 1, 2, 0, +"Store yomi characters as a YOMI of kana-to-kanji conversion.") + (yomi, roma) +Lisp_Object yomi, roma; +{ + jrKanjiStatusWithValue ksv; + jrKanjiStatus ks; + + CHECK_STRING(yomi, 0); +#ifndef CANNA_MULE + strncpy(buf, XSTRING(yomi)->data, XSTRING(yomi)->size); + ks.length = XSTRING (yomi)->size; + buf[ks.length] = '\0'; +#else /* CANNA_MULE */ + m2c(XSTRING(yomi)->data, XSTRING(yomi)->size, buf); + ks.length = strlen(buf); +#endif /* CANNA_MULE */ + + if (NILP(roma)) { + ks.mode = 0; + } + else { + CHECK_STRING(roma, 0); + +#ifndef CANNA_MULE + strncpy(buf + XSTRING(yomi)->size + 1, XSTRING(roma)->data, + XSTRING(roma)->size); + buf[XSTRING(yomi)->size + 1 + XSTRING(roma)->size] = '\0'; + ks.mode = (unsigned char *)(buf + XSTRING(yomi)->size + 1); +#else /* CANNA_MULE */ + ks.mode = (unsigned char *)(buf + ks.length + 1); + m2c(XSTRING(roma)->data, XSTRING(roma)->size, ks.mode); +#endif /* CANNA_MULE */ + } + + ks.echoStr = (unsigned char *)buf; + ksv.buffer = (unsigned char *)buf; /* ÊÖÃÍÍÑ */ + ksv.bytes_buffer = KEYTOSTRSIZE; + ksv.ks = &ks; + + jrKanjiControl(0, KC_STOREYOMI, (char *)&ksv); + + return storeResults(buf, ksv.val, ksv.ks); +} + +DEFUN ("canna-do-function", Fcanna_do_function, Scanna_do_function, + 1, 2, 0, +"Do specified function at current mode.") + (num, ch) +Lisp_Object num, ch; +{ + jrKanjiStatusWithValue ksv; + jrKanjiStatus ks; + Lisp_Object val; + + CHECK_NUMBER(num, 0); + + if (NILP(ch)) { + *buf = '@'; + } + else { + CHECK_NUMBER(ch, 0); + *buf = XINT (ch); + } + + ksv.buffer = (unsigned char *)buf; + ksv.bytes_buffer = KEYTOSTRSIZE; + ksv.ks = &ks; + ksv.val = XINT (num); + jrKanjiControl(0, KC_DO, (char *)&ksv); + val = storeResults(buf, ksv.val, ksv.ks); + return val; +} + +DEFUN ("canna-parse", Fcanna_parse, Scanna_parse, + 1, 1, 0, +"Parse customize string.") + (str) +Lisp_Object str; +{ + jrKanjiStatusWithValue ksv; + jrKanjiStatus ks; + Lisp_Object val; + unsigned char **p; + int n; + + CHECK_STRING(str, 0); + +#ifndef CANNA_MULE + strncpy(buf, XSTRING(str)->data, XSTRING(str)->size); + buf[XSTRING(str)->size] = '\0'; +#else /* CANNA_MULE */ + m2c(XSTRING(str)->data, XSTRING(str)->size, buf); +#endif /* CANNA_MULE */ + p = (unsigned char**)buf; + n = jrKanjiControl(0, KC_PARSE, (char *)&p); + val = Qnil; + while (n > 0) { + n--; + val = Fcons(make_string(p[n], strlen(p[n])), val); + } + return val; +} + +DEFUN ("canna-query-mode", Fcanna_query_mode, Scanna_query_mode, + 0, 0, 0, +"Get current mode string.") + () +{ + unsigned char buf[256]; + + jrKanjiControl(0, KC_QUERYMODE, buf); + return make_string(buf, strlen(buf)); +} + +/* + * Functions following this line are for KKCP interface compatible + * library. These functions may be used by MILK system. + */ + +#define RKBUFSIZE 1024 + +static unsigned char yomibuf[RKBUFSIZE]; +static short kugiri[RKBUFSIZE / 2]; + +static confirmContext() +{ + if (IRCP_context < 0) { + int context; + + if ((context = jrKanjiControl(0, KC_GETCONTEXT, (char *)0)) == -1) { + return 0; + } + IRCP_context = context; + } + return 1; +} + +static byteLen(bun, len) +int bun, len; +{ + int i = 0, offset = 0, ch; + + if (0 <= bun && bun < RKBUFSIZE) { + offset = kugiri[bun]; + } + + while (len-- > 0 && (ch = (int)yomibuf[offset + i])) { + i++; + if (ch & 0x80) { + i++; + } + } + return i; +} + +DEFUN ("canna-henkan-begin", Fcanna_henkan_begin, Scanna_henkan_begin, + 1, 1, 0, +"¤«¤Ê´Á»úÊÑ´¹¤·¤¿·ë²Ì¤òÊÖ´Ô¤¹¤ë¡£Ê¸ÀáÀڤ꤬¤·¤Æ¤¢¤ë¡£") + (yomi) + Lisp_Object yomi; +{ + int nbun; + Lisp_Object res; + + CHECK_STRING(yomi, 0); + if (confirmContext() == 0) { + return Qnil; + } +#ifndef CANNA_MULE + strncpy(yomibuf, XSTRING(yomi)->data, XSTRING(yomi)->size); + yomibuf[XSTRING(yomi)->size] = '\0'; + nbun = RkBgnBun(IRCP_context, XSTRING(yomi)->data, XSTRING(yomi)->size, + (RK_XFER << RK_XFERBITS) | RK_KFER); +#else /* CANNA_MULE */ + m2c(XSTRING(yomi)->data, XSTRING(yomi)->size, yomibuf); + nbun = RkBgnBun(IRCP_context, (char *)yomibuf, strlen(yomibuf), + (RK_XFER << RK_XFERBITS) | RK_KFER); +#endif /* CANNA_MULE */ + + return kanjiYomiList(IRCP_context, nbun); +} + +static Lisp_Object kanjiYomiList(context, nbun) +int context, nbun; +{ + Lisp_Object val, res = Qnil; + unsigned char RkBuf[RKBUFSIZE]; + int len, i, total; + + for (i = nbun ; i > 0 ; ) { + i--; + RkGoTo(context, i); + len = RkGetKanji(context, RkBuf, RKBUFSIZE); + val = make_string(RkBuf, len); + len = RkGetYomi(context, RkBuf, RKBUFSIZE); + res = Fcons(Fcons(val, make_string(RkBuf, len)), res); + if (i < RKBUFSIZE / 2) { + kugiri[i] = len; + } + } + for (i = 0, total = 0 ; i < nbun ; i++) { + int temp = kugiri[i]; + kugiri[i] = total; + total += temp; + } + return res; +} + +DEFUN ("canna-henkan-next", Fcanna_henkan_next, Scanna_henkan_next, + 1, 1, 0, +"¸õÊä°ìÍ÷¤òµá¤á¤ë¡£") + (bunsetsu) + Lisp_Object bunsetsu; +{ + int i, nbun, slen, len; + unsigned char *p, RkBuf[RKBUFSIZE]; + Lisp_Object res = Qnil, endp; + + CHECK_NUMBER(bunsetsu, 0); + if (confirmContext() == 0) { + return Qnil; + } + RkGoTo(IRCP_context, XINT (bunsetsu)); + len = RkGetKanjiList(IRCP_context, RkBuf, RKBUFSIZE); + p = RkBuf; + for (i = 0 ; i < len ; i++) { + slen = strlen(p); + if (res == Qnil) { + endp = res = Fcons(make_string(p, slen), Qnil); + } + else { + endp = XCONS (endp)->cdr = Fcons(make_string(p, slen), Qnil); + } + p += slen + 1; + } + return res; +} + +DEFUN ("canna-bunsetu-henkou", Fcanna_bunsetu_henkou, Scanna_bunsetu_henkou, + 2, 2, 0, +"ʸÀá¤ÎŤµ¤ò»ØÄꤹ¤ë¡£") + (bunsetsu, bunlen) + Lisp_Object bunsetsu, bunlen; +{ + int nbun, len; + + CHECK_NUMBER(bunsetsu, 0); + CHECK_NUMBER(bunlen, 0); + + nbun = XINT (bunsetsu); + if (confirmContext() == 0) { + return Qnil; + } + RkGoTo(IRCP_context, nbun); + len = byteLen(nbun, XINT(bunlen)); + return kanjiYomiList(IRCP_context, RkResize(IRCP_context, len)); +} + +DEFUN ("canna-henkan-kakutei", Fcanna_henkan_kakutei, Scanna_henkan_kakutei, + 2, 2, 0, +"¸õÊäÁªÂò¡£") + (bun, kouho) +register Lisp_Object bun, kouho; +{ + if (confirmContext() == 0) { + return Qnil; + } + RkGoTo(IRCP_context, bun); + RkXfer(IRCP_context, kouho); + return Qt; +} + +DEFUN ("canna-henkan-end", Fcanna_henkan_end, Scanna_henkan_end, + 0, 0, 0, +"ÊÑ´¹½ªÎ»¡£") + () +{ + if (confirmContext() == 0) { + return Qnil; + } + RkEndBun(IRCP_context, 1); /* ³Ø½¬¤Ï¤¤¤Ä¤Ç¤â¹Ô¤Ã¤ÆÎɤ¤¤â¤Î¤Ê¤Î¤«¡© */ + return Qt; +} + +DEFUN ("canna-henkan-quit", Fcanna_henkan_quit, Scanna_henkan_quit, + 0, 0, 0, +"ÊÑ´¹½ªÎ»¡£") + () +{ + if (confirmContext() == 0) { + return Qnil; + } + RkEndBun(IRCP_context, 0); + return Qt; +} + +/* variables below this line is constants of Canna */ + +static int Vcanna_mode_AlphaMode = IROHA_MODE_AlphaMode; +static int Vcanna_mode_EmptyMode = IROHA_MODE_EmptyMode; +static int Vcanna_mode_KigoMode = IROHA_MODE_KigoMode; +static int Vcanna_mode_YomiMode = IROHA_MODE_YomiMode; +static int Vcanna_mode_JishuMode = IROHA_MODE_JishuMode; +static int Vcanna_mode_TankouhoMode = IROHA_MODE_TankouhoMode; +static int Vcanna_mode_IchiranMode = IROHA_MODE_IchiranMode; +static int Vcanna_mode_YesNoMode = IROHA_MODE_YesNoMode; +static int Vcanna_mode_OnOffMode = IROHA_MODE_OnOffMode; +#ifdef CANNA_MODE_AdjustBunsetsuMode +static int Vcanna_mode_AdjustBunsetsuMode = CANNA_MODE_AdjustBunsetsuMode; +#endif +#ifdef CANNA_MODE_ChikujiYomiMode +static int Vcanna_mode_ChikujiYomiMode = CANNA_MODE_ChikujiYomiMode; +static int Vcanna_mode_ChikujiTanMode = CANNA_MODE_ChikujiTanMode; +#endif + +static int Vcanna_mode_HenkanMode = IROHA_MODE_HenkanMode; +#ifdef CANNA_MODE_HenkanNyuryokuMode +static int Vcanna_mode_HenkanNyuryokuMode = CANNA_MODE_HenkanNyuryokuMode; +#endif +#ifdef CANNA_MODE_ZenHiraHenkanMode +static int Vcanna_mode_ZenHiraHenkanMode = CANNA_MODE_ZenHiraHenkanMode; +#ifdef CANNA_MODE_HanHiraHenkanMode +static int Vcanna_mode_HanHiraHenkanMode = CANNA_MODE_HanHiraHenkanMode; +#endif +static int Vcanna_mode_ZenKataHenkanMode = CANNA_MODE_ZenKataHenkanMode; +static int Vcanna_mode_HanKataHenkanMode = CANNA_MODE_HanKataHenkanMode; +static int Vcanna_mode_ZenAlphaHenkanMode = CANNA_MODE_ZenAlphaHenkanMode; +static int Vcanna_mode_HanAlphaHenkanMode = CANNA_MODE_HanAlphaHenkanMode; +#endif +static int Vcanna_mode_ZenHiraKakuteiMode = IROHA_MODE_ZenHiraKakuteiMode; +#ifdef CANNA_MODE_HanHiraKakuteiMode +static int Vcanna_mode_HanHiraKakuteiMode = CANNA_MODE_HanHiraKakuteiMode; +#endif +static int Vcanna_mode_ZenKataKakuteiMode = IROHA_MODE_ZenKataKakuteiMode; +static int Vcanna_mode_HanKataKakuteiMode = IROHA_MODE_HanKataKakuteiMode; +static int Vcanna_mode_ZenAlphaKakuteiMode = IROHA_MODE_ZenAlphaKakuteiMode; +static int Vcanna_mode_HanAlphaKakuteiMode = IROHA_MODE_HanAlphaKakuteiMode; +static int Vcanna_mode_HexMode = IROHA_MODE_HexMode; +static int Vcanna_mode_BushuMode = IROHA_MODE_BushuMode; +static int Vcanna_mode_ExtendMode = IROHA_MODE_ExtendMode; +static int Vcanna_mode_RussianMode = IROHA_MODE_RussianMode; +static int Vcanna_mode_GreekMode = IROHA_MODE_GreekMode; +static int Vcanna_mode_LineMode = IROHA_MODE_LineMode; +static int Vcanna_mode_ChangingServerMode = IROHA_MODE_ChangingServerMode; +static int Vcanna_mode_HenkanMethodMode = IROHA_MODE_HenkanMethodMode; +static int Vcanna_mode_DeleteDicMode = IROHA_MODE_DeleteDicMode; +static int Vcanna_mode_TourokuMode = IROHA_MODE_TourokuMode; +static int Vcanna_mode_TourokuEmptyMode = IROHA_MODE_TourokuEmptyMode; +static int Vcanna_mode_TourokuHinshiMode = IROHA_MODE_TourokuHinshiMode; +static int Vcanna_mode_TourokuDicMode = IROHA_MODE_TourokuDicMode; +static int Vcanna_mode_QuotedInsertMode = IROHA_MODE_QuotedInsertMode; +static int Vcanna_mode_BubunMuhenkanMode = IROHA_MODE_BubunMuhenkanMode; +static int Vcanna_mode_MountDicMode = IROHA_MODE_MountDicMode; + +static int Vcanna_fn_SelfInsert = IROHA_FN_SelfInsert; +static int Vcanna_fn_FunctionalInsert = IROHA_FN_FunctionalInsert; +static int Vcanna_fn_QuotedInsert = IROHA_FN_QuotedInsert; +static int Vcanna_fn_JapaneseMode = IROHA_FN_JapaneseMode; +static int Vcanna_fn_AlphaMode = IROHA_FN_AlphaMode; +static int Vcanna_fn_HenkanNyuryokuMode = IROHA_FN_HenkanNyuryokuMode; +static int Vcanna_fn_Forward = IROHA_FN_Forward; +static int Vcanna_fn_Backward = IROHA_FN_Backward; +static int Vcanna_fn_Next = IROHA_FN_Next; +static int Vcanna_fn_Prev = IROHA_FN_Prev; +static int Vcanna_fn_BeginningOfLine = IROHA_FN_BeginningOfLine; +static int Vcanna_fn_EndOfLine = IROHA_FN_EndOfLine; +static int Vcanna_fn_DeleteNext = IROHA_FN_DeleteNext; +static int Vcanna_fn_DeletePrevious = IROHA_FN_DeletePrevious; +static int Vcanna_fn_KillToEndOfLine = IROHA_FN_KillToEndOfLine; +static int Vcanna_fn_Henkan = IROHA_FN_Henkan; +static int Vcanna_fn_Kakutei = IROHA_FN_Kakutei; +static int Vcanna_fn_Extend = IROHA_FN_Extend; +static int Vcanna_fn_Shrink = IROHA_FN_Shrink; +#ifdef CANNA_FN_AdjustBunsetsu +static int Vcanna_fn_AdjustBunsetsu = CANNA_FN_AdjustBunsetsu; +#endif +static int Vcanna_fn_Quit = IROHA_FN_Quit; +static int Vcanna_fn_ConvertAsHex = IROHA_FN_ConvertAsHex; +static int Vcanna_fn_ConvertAsBushu = IROHA_FN_ConvertAsBushu; +static int Vcanna_fn_KouhoIchiran = IROHA_FN_KouhoIchiran; +static int Vcanna_fn_BubunMuhenkan = IROHA_FN_BubunMuhenkan; +static int Vcanna_fn_Zenkaku = IROHA_FN_Zenkaku; +static int Vcanna_fn_Hankaku = IROHA_FN_Hankaku; +static int Vcanna_fn_ToUpper = IROHA_FN_ToUpper; +static int Vcanna_fn_Capitalize = IROHA_FN_Capitalize; +static int Vcanna_fn_ToLower = IROHA_FN_ToLower; +static int Vcanna_fn_Hiragana = IROHA_FN_Hiragana; +static int Vcanna_fn_Katakana = IROHA_FN_Katakana; +static int Vcanna_fn_Romaji = IROHA_FN_Romaji; +#ifdef CANNA_FN_BaseHiragana +static int Vcanna_fn_BaseHiragana = CANNA_FN_BaseHiragana; +static int Vcanna_fn_BaseKatakana = CANNA_FN_BaseKatakana; +static int Vcanna_fn_BaseEisu = CANNA_FN_BaseEisu; +static int Vcanna_fn_BaseZenkaku = CANNA_FN_BaseZenkaku; +static int Vcanna_fn_BaseHankaku = CANNA_FN_BaseHankaku; +static int Vcanna_fn_BaseKana = CANNA_FN_BaseKana; +static int Vcanna_fn_BaseKakutei = CANNA_FN_BaseKakutei; +static int Vcanna_fn_BaseHenkan = CANNA_FN_BaseHenkan; +static int Vcanna_fn_BaseHiraKataToggle = CANNA_FN_BaseHiraKataToggle; +static int Vcanna_fn_BaseZenHanToggle = CANNA_FN_BaseZenHanToggle; +static int Vcanna_fn_BaseKanaEisuToggle = CANNA_FN_BaseKanaEisuToggle; +static int Vcanna_fn_BaseKakuteiHenkanToggle = + CANNA_FN_BaseKakuteiHenkanToggle; +static int Vcanna_fn_BaseRotateForward = CANNA_FN_BaseRotateForward; +static int Vcanna_fn_BaseRotateBackward = CANNA_FN_BaseRotateBackward; +#endif +static int Vcanna_fn_ExtendMode = IROHA_FN_ExtendMode; +static int Vcanna_fn_Touroku = IROHA_FN_Touroku; +static int Vcanna_fn_HexMode = IROHA_FN_HexMode; +static int Vcanna_fn_BushuMode = IROHA_FN_BushuMode; +static int Vcanna_fn_KigouMode = IROHA_FN_KigouMode; +#ifdef CANNA_FN_Mark +static int Vcanna_fn_Mark = CANNA_FN_Mark; +#endif +#ifdef CANNA_FN_TemporalMode +static int Vcanna_fn_TemporalMode = CANNA_FN_TemporalMode; +#endif + +static int Vcanna_key_Nfer = IROHA_KEY_Nfer; +static int Vcanna_key_Xfer = IROHA_KEY_Xfer; +static int Vcanna_key_Up = IROHA_KEY_Up; +static int Vcanna_key_Left = IROHA_KEY_Left; +static int Vcanna_key_Right = IROHA_KEY_Right; +static int Vcanna_key_Down = IROHA_KEY_Down; +static int Vcanna_key_Insert = IROHA_KEY_Insert; +static int Vcanna_key_Rollup = IROHA_KEY_Rollup; +static int Vcanna_key_Rolldown = IROHA_KEY_Rolldown; +static int Vcanna_key_Home = IROHA_KEY_Home; +static int Vcanna_key_Help = IROHA_KEY_Help; +static int Vcanna_key_KP_Key = IROHA_KEY_KP_Key; +static int Vcanna_key_Shift_Nfer = IROHA_KEY_Shift_Nfer; +static int Vcanna_key_Shift_Xfer = IROHA_KEY_Shift_Xfer; +static int Vcanna_key_Shift_Up = IROHA_KEY_Shift_Up; +static int Vcanna_key_Shift_Left = IROHA_KEY_Shift_Left; +static int Vcanna_key_Shift_Right = IROHA_KEY_Shift_Right; +static int Vcanna_key_Shift_Down = IROHA_KEY_Shift_Down; +static int Vcanna_key_Cntrl_Nfer = IROHA_KEY_Cntrl_Nfer; +static int Vcanna_key_Cntrl_Xfer = IROHA_KEY_Cntrl_Xfer; +static int Vcanna_key_Cntrl_Up = IROHA_KEY_Cntrl_Up; +static int Vcanna_key_Cntrl_Left = IROHA_KEY_Cntrl_Left; +static int Vcanna_key_Cntrl_Right = IROHA_KEY_Cntrl_Right; +static int Vcanna_key_Cntrl_Down = IROHA_KEY_Cntrl_Down; + +static Lisp_Object VCANNA; /* hir@nec, 1992.5.21 */ + +syms_of_canna () +{ + DEFVAR_LISP ("CANNA", &VCANNA, ""); /* hir@nec, 1992.5.21 */ + VCANNA = Qt; /* hir@nec, 1992.5.21 */ + + defsubr (&Scanna_key_proc); + defsubr (&Scanna_initialize); + defsubr (&Scanna_finalize); + defsubr (&Scanna_touroku_string); + defsubr (&Scanna_set_width); + defsubr (&Scanna_change_mode); + defsubr (&Scanna_store_yomi); + defsubr (&Scanna_do_function); + defsubr (&Scanna_parse); + defsubr (&Scanna_query_mode); + defsubr (&Scanna_set_bunsetsu); + + DEFVAR_LISP("canna-kakutei-string", &Vcanna_kakutei_string, ""); + DEFVAR_LISP("canna-kakutei-yomi", &Vcanna_kakutei_yomi, ""); + DEFVAR_LISP("canna-kakutei-romaji", &Vcanna_kakutei_romaji, ""); + DEFVAR_LISP("canna-henkan-string", &Vcanna_henkan_string, ""); + DEFVAR_INT ("canna-henkan-length", &Vcanna_henkan_length, ""); + DEFVAR_INT ("canna-henkan-revpos", &Vcanna_henkan_revPos, ""); + DEFVAR_INT ("canna-henkan-revlen", &Vcanna_henkan_revLen, ""); + DEFVAR_LISP("canna-ichiran-string", &Vcanna_ichiran_string, ""); + DEFVAR_INT ("canna-ichiran-length", &Vcanna_ichiran_length, ""); + DEFVAR_INT ("canna-ichiran-revpos", &Vcanna_ichiran_revPos, ""); + DEFVAR_INT ("canna-ichiran-revlen", &Vcanna_ichiran_revLen, ""); + DEFVAR_LISP("canna-mode-string", &Vcanna_mode_string, ""); + + DEFVAR_BOOL ("canna-empty-info", &Vcanna_empty_info, "For canna"); + DEFVAR_BOOL ("canna-through-info", &Vcanna_through_info, "For canna"); + DEFVAR_BOOL ("canna-underline", &Vcanna_underline, "For canna"); + DEFVAR_BOOL ("canna-inhibit-hankakukana", &Vcanna_inhibit_hankakukana, + "For canna"); /* hir, 1994.12.5 */ + + defsubr (&Scanna_henkan_begin); + defsubr (&Scanna_henkan_next); + defsubr (&Scanna_bunsetu_henkou); + defsubr (&Scanna_henkan_kakutei); + defsubr (&Scanna_henkan_end); + defsubr (&Scanna_henkan_quit); + + DEFVAR_INT ("canna-mode-alpha-mode", &Vcanna_mode_AlphaMode, ""); + DEFVAR_INT ("canna-mode-empty-mode", &Vcanna_mode_EmptyMode, ""); + DEFVAR_INT ("canna-mode-kigo-mode", &Vcanna_mode_KigoMode, ""); + DEFVAR_INT ("canna-mode-yomi-mode", &Vcanna_mode_YomiMode, ""); + DEFVAR_INT ("canna-mode-jishu-mode", &Vcanna_mode_JishuMode, ""); + DEFVAR_INT ("canna-mode-tankouho-mode", &Vcanna_mode_TankouhoMode, ""); + DEFVAR_INT ("canna-mode-ichiran-mode", &Vcanna_mode_IchiranMode, ""); + DEFVAR_INT ("canna-mode-yes-no-mode", &Vcanna_mode_YesNoMode, ""); + DEFVAR_INT ("canna-mode-on-off-mode", &Vcanna_mode_OnOffMode, ""); +#ifdef CANNA_MODE_AdjustBunsetsuMode + DEFVAR_INT ("canna-mode-adjust-bunsetsu-mode", + &Vcanna_mode_AdjustBunsetsuMode, ""); +#endif +#ifdef CANNA_MODE_ChikujiYomiMode + DEFVAR_INT ("canna-mode-chikuji-yomi-mode", &Vcanna_mode_ChikujiYomiMode,""); + DEFVAR_INT ("canna-mode-chikuji-bunsetsu-mode", + &Vcanna_mode_ChikujiTanMode, ""); +#endif + + DEFVAR_INT ("canna-mode-henkan-mode", &Vcanna_mode_HenkanMode, ""); +#ifdef CANNA_MODE_HenkanNyuryokuMode + DEFVAR_INT ("canna-mode-henkan-nyuuryoku-mode", + &Vcanna_mode_HenkanNyuryokuMode, 0); +#endif +#ifdef CANNA_MODE_ZenHiraHenkanMode + DEFVAR_INT ("canna-mode-zen-hira-henkan-mode", + &Vcanna_mode_ZenHiraHenkanMode, ""); +#ifdef CANNA_MODE_HanHiraHenkanMode + DEFVAR_INT ("canna-mode-han-hira-henkan-mode", + &Vcanna_mode_HanHiraHenkanMode, ""); +#endif + DEFVAR_INT ("canna-mode-zen-kata-henkan-mode", + &Vcanna_mode_ZenKataHenkanMode, ""); + DEFVAR_INT ("canna-mode-han-kata-henkan-mode", + &Vcanna_mode_HanKataHenkanMode, ""); + DEFVAR_INT ("canna-mode-zen-alpha-henkan-mode", + &Vcanna_mode_ZenAlphaHenkanMode, ""); + DEFVAR_INT ("canna-mode-han-alpha-henkan-mode", + &Vcanna_mode_HanAlphaHenkanMode, ""); +#endif + DEFVAR_INT ("canna-mode-zen-hira-kakutei-mode", + &Vcanna_mode_ZenHiraKakuteiMode, ""); +#ifdef CANNA_MODE_HanHiraKakuteiMode + DEFVAR_INT ("canna-mode-han-hira-kakutei-mode", + &Vcanna_mode_HanHiraKakuteiMode, ""); +#endif + DEFVAR_INT ("canna-mode-zen-kata-kakutei-mode", + &Vcanna_mode_ZenKataKakuteiMode, ""); + DEFVAR_INT ("canna-mode-han-kata-kakutei-mode", + &Vcanna_mode_HanKataKakuteiMode, ""); + DEFVAR_INT ("canna-mode-zen-alpha-kakutei-mode", + &Vcanna_mode_ZenAlphaKakuteiMode, ""); + DEFVAR_INT ("canna-mode-han-alpha-kakutei-mode", + &Vcanna_mode_HanAlphaKakuteiMode, ""); + DEFVAR_INT ("canna-mode-hex-mode", &Vcanna_mode_HexMode, ""); + DEFVAR_INT ("canna-mode-bushu-mode", &Vcanna_mode_BushuMode, ""); + DEFVAR_INT ("canna-mode-extend-mode", &Vcanna_mode_ExtendMode, ""); + DEFVAR_INT ("canna-mode-russian-mode", &Vcanna_mode_RussianMode, ""); + DEFVAR_INT ("canna-mode-greek-mode", &Vcanna_mode_GreekMode, ""); + DEFVAR_INT ("canna-mode-line-mode", &Vcanna_mode_LineMode, ""); + DEFVAR_INT ("canna-mode-changing-server-mode", + &Vcanna_mode_ChangingServerMode, ""); + DEFVAR_INT ("canna-mode-henkan-method-mode", + &Vcanna_mode_HenkanMethodMode, ""); + DEFVAR_INT ("canna-mode-delete-dic-mode", &Vcanna_mode_DeleteDicMode, ""); + DEFVAR_INT ("canna-mode-touroku-mode", &Vcanna_mode_TourokuMode, ""); + DEFVAR_INT ("canna-mode-touroku-empty-mode", + &Vcanna_mode_TourokuEmptyMode, ""); + DEFVAR_INT ("canna-mode-touroku-hinshi-mode", + &Vcanna_mode_TourokuHinshiMode, ""); + DEFVAR_INT ("canna-mode-touroku-dic-mode", &Vcanna_mode_TourokuDicMode, ""); + DEFVAR_INT ("canna-mode-quoted-insert-mode", + &Vcanna_mode_QuotedInsertMode, ""); + DEFVAR_INT ("canna-mode-bubun-muhenkan-mode", + &Vcanna_mode_BubunMuhenkanMode, ""); + DEFVAR_INT ("canna-mode-mount-dic-mode", &Vcanna_mode_MountDicMode, ""); + + DEFVAR_INT ("canna-func-self-insert", &Vcanna_fn_SelfInsert ,""); + DEFVAR_INT ("canna-func-functional-insert", &Vcanna_fn_FunctionalInsert ,""); + DEFVAR_INT ("canna-func-quoted-insert", &Vcanna_fn_QuotedInsert ,""); + DEFVAR_INT ("canna-func-japanese-mode", &Vcanna_fn_JapaneseMode ,""); + DEFVAR_INT ("canna-func-alpha-mode", &Vcanna_fn_AlphaMode ,""); + DEFVAR_INT ("canna-func-henkan-nyuryoku-mode", + &Vcanna_fn_HenkanNyuryokuMode ,""); + DEFVAR_INT ("canna-func-forward", &Vcanna_fn_Forward ,""); + DEFVAR_INT ("canna-func-backward", &Vcanna_fn_Backward ,""); + DEFVAR_INT ("canna-func-next", &Vcanna_fn_Next ,""); + DEFVAR_INT ("canna-func-previous", &Vcanna_fn_Prev ,""); + DEFVAR_INT ("canna-func-beginning-of-line", &Vcanna_fn_BeginningOfLine ,""); + DEFVAR_INT ("canna-func-end-of-line", &Vcanna_fn_EndOfLine ,""); + DEFVAR_INT ("canna-func-delete-next", &Vcanna_fn_DeleteNext ,""); + DEFVAR_INT ("canna-func-delete_previous", &Vcanna_fn_DeletePrevious ,""); + DEFVAR_INT ("canna-func-kill-to-end-of-line", &Vcanna_fn_KillToEndOfLine,""); + DEFVAR_INT ("canna-func-henkan", &Vcanna_fn_Henkan ,""); + DEFVAR_INT ("canna-func-kakutei", &Vcanna_fn_Kakutei ,""); + DEFVAR_INT ("canna-func-extend", &Vcanna_fn_Extend ,""); + DEFVAR_INT ("canna-func-shrink", &Vcanna_fn_Shrink ,""); +#ifdef CANNA_FN_AdjustBunsetsu + DEFVAR_INT ("canna-func-adjust-bunsetsu", &Vcanna_fn_AdjustBunsetsu ,""); +#endif + DEFVAR_INT ("canna-func-quit", &Vcanna_fn_Quit ,""); + DEFVAR_INT ("canna-func-convert-as-hex", &Vcanna_fn_ConvertAsHex ,""); + DEFVAR_INT ("canna-func-convert-as-bushu", &Vcanna_fn_ConvertAsBushu ,""); + DEFVAR_INT ("canna-func-kouho-ichiran", &Vcanna_fn_KouhoIchiran ,""); + DEFVAR_INT ("canna-func-bubun-muhenkan", &Vcanna_fn_BubunMuhenkan ,""); + DEFVAR_INT ("canna-func-zenkaku", &Vcanna_fn_Zenkaku ,""); + DEFVAR_INT ("canna-func-hankaku", &Vcanna_fn_Hankaku ,""); + DEFVAR_INT ("canna-func-to-upper", &Vcanna_fn_ToUpper ,""); + DEFVAR_INT ("canna-func-capitalize", &Vcanna_fn_Capitalize ,""); + DEFVAR_INT ("canna-func-to-lower", &Vcanna_fn_ToLower ,""); + DEFVAR_INT ("canna-func-hiragana", &Vcanna_fn_Hiragana ,""); + DEFVAR_INT ("canna-func-katakana", &Vcanna_fn_Katakana ,""); + DEFVAR_INT ("canna-func-romaji", &Vcanna_fn_Romaji ,""); +#ifdef CANNA_FN_BaseHiragana + DEFVAR_INT ("canna-func-base-hiragana", &Vcanna_fn_BaseHiragana ,""); + DEFVAR_INT ("canna-func-base-katakana", &Vcanna_fn_BaseKatakana ,""); + DEFVAR_INT ("canna-func-base-eisu", &Vcanna_fn_BaseEisu ,""); + DEFVAR_INT ("canna-func-base-zenkaku", &Vcanna_fn_BaseZenkaku ,""); + DEFVAR_INT ("canna-func-base-hankaku", &Vcanna_fn_BaseHankaku ,""); + DEFVAR_INT ("canna-func-base-kana", &Vcanna_fn_BaseKana ,""); + DEFVAR_INT ("canna-func-base-kakutei", &Vcanna_fn_BaseKakutei ,""); + DEFVAR_INT ("canna-func-base-henkan", &Vcanna_fn_BaseHenkan ,""); + DEFVAR_INT ("canna-func-base-hiragana-katakana-toggle", + &Vcanna_fn_BaseHiraKataToggle ,""); + DEFVAR_INT ("canna-func-base-zenkaku-hankaku-toggle", + &Vcanna_fn_BaseZenHanToggle ,""); + DEFVAR_INT ("canna-func-base-kana-eisu-toggle", + &Vcanna_fn_BaseKanaEisuToggle ,""); + DEFVAR_INT ("canna-func-base-kakutei-henkan-toggle", + &Vcanna_fn_BaseKakuteiHenkanToggle ,""); + DEFVAR_INT ("canna-func-base-rotate-forward", + &Vcanna_fn_BaseRotateForward ,""); + DEFVAR_INT ("canna-func-base-rotate-backward", + &Vcanna_fn_BaseRotateBackward ,""); +#endif + DEFVAR_INT ("canna-func-extend-mode", &Vcanna_fn_ExtendMode ,""); + DEFVAR_INT ("canna-func-touroku", &Vcanna_fn_Touroku ,""); + DEFVAR_INT ("canna-func-hex-mode", &Vcanna_fn_HexMode ,""); + DEFVAR_INT ("canna-func-bushu-mode", &Vcanna_fn_BushuMode ,""); + DEFVAR_INT ("canna-func-kigo-mode", &Vcanna_fn_KigouMode ,""); +#ifdef CANNA_FN_Mark + DEFVAR_INT ("canna-func-mark", &Vcanna_fn_Mark ,""); +#endif +#ifdef CANNA_FN_TemporalMode + DEFVAR_INT ("canna-func-temporal-mode", &Vcanna_fn_TemporalMode ,""); +#endif + + DEFVAR_INT ("canna-key-nfer", &Vcanna_key_Nfer, ""); + DEFVAR_INT ("canna-key-xfer", &Vcanna_key_Xfer, ""); + DEFVAR_INT ("canna-key-up", &Vcanna_key_Up, ""); + DEFVAR_INT ("canna-key-left", &Vcanna_key_Left, ""); + DEFVAR_INT ("canna-key-right", &Vcanna_key_Right, ""); + DEFVAR_INT ("canna-key-down", &Vcanna_key_Down, ""); + DEFVAR_INT ("canna-key-insert", &Vcanna_key_Insert, ""); + DEFVAR_INT ("canna-key-rollup", &Vcanna_key_Rollup, ""); + DEFVAR_INT ("canna-key-rolldown", &Vcanna_key_Rolldown, ""); + DEFVAR_INT ("canna-key-home", &Vcanna_key_Home, ""); + DEFVAR_INT ("canna-key-help", &Vcanna_key_Help, ""); + DEFVAR_INT ("canna-key-kp-key", &Vcanna_key_KP_Key, ""); + DEFVAR_INT ("canna-key-shift-nfer", &Vcanna_key_Shift_Nfer, ""); + DEFVAR_INT ("canna-key-shift-xfer", &Vcanna_key_Shift_Xfer, ""); + DEFVAR_INT ("canna-key-shift-up", &Vcanna_key_Shift_Up, ""); + DEFVAR_INT ("canna-key-shift-left", &Vcanna_key_Shift_Left, ""); + DEFVAR_INT ("canna-key-shift-right", &Vcanna_key_Shift_Right, ""); + DEFVAR_INT ("canna-key-shift-down", &Vcanna_key_Shift_Down, ""); + DEFVAR_INT ("canna-key-control-nfer", &Vcanna_key_Cntrl_Nfer, ""); + DEFVAR_INT ("canna-key-control-xfer", &Vcanna_key_Cntrl_Xfer, ""); + DEFVAR_INT ("canna-key-control-up", &Vcanna_key_Cntrl_Up, ""); + DEFVAR_INT ("canna-key-control-left", &Vcanna_key_Cntrl_Left, ""); + DEFVAR_INT ("canna-key-control-right", &Vcanna_key_Cntrl_Right, ""); + DEFVAR_INT ("canna-key-control-down", &Vcanna_key_Cntrl_Down, ""); +} + +#ifdef CANNA_MULE +/* To handle MULE internal code and EUC. + I assume CANNA can handle only Japanese EUC. */ + +/* EUC multibyte string to MULE internal string */ + +static +c2mu(cp, l, mp) +char *cp; +int l; +char *mp; +{ + char ch, *ep = cp+l; + + while((cp < ep) && (ch = *cp)) { + if ((unsigned char)ch == SS2) { + *mp++ = LCKANA; + cp++; + } + else if ((unsigned char)ch == SS3) { + *mp++ = LCJP2; + cp++; + *mp++ = *cp++; + } + else if(ch & 0x80) { + *mp++ = LCJP; + *mp++ = *cp++; + } + *mp++ = *cp++; + } + *mp = 0; +} + +/* MULE internal string to EUC multibyte string */ + +static +m2c(mp, l, cp) +unsigned char *mp; +int l; +unsigned char *cp; +{ + unsigned char ch, *ep = mp + l;; + + while((mp < ep) && (ch = *mp++)) { + switch (ch) { + case LCKANA: + *cp++ = SS2; + *cp++ = *mp++; + break; + case LCJP2: + *cp++ = SS3; + case LCJP: + *cp++ = *mp++; + *cp++ = *mp++; + break; + default: + *cp++ = ch; + break; + } + } + *cp = 0; +} + +#undef make_string + +/* make_string after converting EUC string to MULE internal string */ +static +Lisp_Object +mule_make_string(p,l) +unsigned char *p; +int l; +{ + unsigned char cbuf[4096]; + + c2mu(p,l,cbuf); + return (make_string(cbuf,strlen(cbuf))); +} + +/* return the MULE internal string length of EUC string */ +static +mule_strlen(p,l) +unsigned char *p; +int l; +{ + unsigned char ch, *cp = p; + int len = 0; + + while((cp < p + l) && (ch = *cp)) { + if ((unsigned char)ch == SS2) { + len += 2; + cp += 2; + } + else if ((unsigned char)ch == SS3) { + len += 3; + cp += 3; + } + else if(ch & 0x80) { + len += 3; + cp += 2; + } + else { + len++; + cp++; + } + } + return(len); +} + +/* count number of characters */ +static +count_char(p,len,pos,rev,clen,cpos,crev) +unsigned char *p; +int len,pos,rev,*clen,*cpos,*crev; +{ + unsigned char *q = p; + + *clen = *cpos = *crev = 0; + if (len == 0) return; + while (q < p + pos) { + (*clen)++; + (*cpos)++; + if (*q++ & 0x80) q++; + } + while (q < p + pos + rev) { + (*clen)++; + (*crev)++; + if (*q++ & 0x80) q++; + } + while (q < p + len) { + (*clen)++; + if (*q++ & 0x80) q++; + } +} +#endif /* CANNA_MULE */ -- 1.7.10.4