cgit.sxemacs.org Git - sxemacs/blob - src/mule/mule-wnnfns.c

   1 /* -*- coding: iso-2022-jp -*-
   2    Copyright (C) 1995 Free Software Foundation, Inc.
   3    Copyright (C) 1995 Sun Microsystems, Inc.
   4
   5 This file is part of SXEmacs
   6
   7 SXEmacs is free software: you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation, either version 3 of the License, or
  10 (at your option) any later version.
  11
  12 SXEmacs is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  19
  20
  21 /* Synched up with: Mule 2.3.  Not in FSF. */
  22
  23 /*      Jserver Interface for Mule
  24         Coded by Yutaka Ishikawa at ETL (yisikawa@etl.go.jp)
  25                  Satoru Tomura   at ETL (tomura@etl.go.jp)
  26         Modified for Wnn4 library by
  27                  Toshiaki Shingu (shingu@cpr.canon.co.jp)
  28                  Hiroshi Kuribayashi (kuri@nff.ncl.omron.co.jp) */
  29
  30 /*
  31  *      Functions defined in this file are
  32  *         (wnn-server-open wnn-host-name login-name)
  33  *              wnn-host-name: STRING or NIL
  34  *              login-name: STRING
  35  *              RETURNS: BOOLEAN
  36  *              DESCRIPTION:
  37  *              jserver \e$B$H@\B3$7!"%5!<%P!<FbIt$K@5JQ49!?5UJQ49#2$D$N4D6-$r\e(B
  38  *              \e$B:n$k!#%(%i!<$N;~$O\e(B nil \e$B$rJV$9!#\e(B
  39  *
  40  *         (wnn-server-close)
  41  *              RETURNS: BOOLEAN
  42  *              DESCRIPTION:
  43  *              jserver \e$B$H$N@\B3$r@Z$k!#<-=q!"IQEY$O%;!<%V$5$l$J$$!#\e(B
  44  *
  45  *         (wnn-server-dict-add dict-file-name hindo-file-name priority
  46  *              dict-file-mode hindo-file-mode pw1 pw2)
  47  *              dict-file-name: STRING
  48  *              hindo-file-name: STRING or NULL-STRING
  49  *              priority: INTEGER
  50  *              dict-file-mode: BOOLEAN
  51  *              hindo-file-mode: BOOLEAN
  52  *              pw1: STRING or NIL
  53  *              pw2: STRING or NIL
  54  *              DESCRIPTION:
  55  *              \e$B<-=q%U%!%$%kL>!"IQEY%U%!%$%kL>!"M%@hEY!"<-=q%U%!%$%k%b!<%I\e(B
  56  *              \e$BIQEY%U%!%$%k%b!<%I$G;XDj$7$?<-=q$r%P%C%U%!$KDI2C$9$k!#\e(B
  57  *              pw1, pw2 \e$B$O<-=q%U%!%$%k!"IQEY%U%!%$%k$N%Q%9%o!<%I!#\e(B
  58  *
  59  *         (wnn-server-dict-delete dic-no)
  60  *              dic-no: INTEGER
  61  *              RETURNS: \e$B%(%i!<$N;~\e(B nil
  62  *              DESCRIPTION: dic-no \e$B$N<-=qHV9f$N<-=q$r!"%P%C%U%!$+$i\e(B
  63  *              \e$B:o=|$9$k!#\e(B
  64  *
  65  *         (wnn-server-dict-list)
  66  *              RETURNS: ((dic-no1 file-name1 comment1 word-no1 nice1)
  67  *                        (dic-no2 file-name2 comment2 word-no2 nice2)...)
  68  *              DESCRIPTION: \e$B%P%C%U%!>e$N<-=q$N%j%9%H$rF@$k!#\e(B
  69  *
  70  *         (wnn-server-dict-comment dic-no comment)
  71  *              RETURNS: \e$B%(%i!<$N;~\e(B nil
  72  *              DESCRIPTION: dic-no \e$B$N<-=q$K%3%a%s%H$r$D$1$k!#\e(B
  73  *
  74  *         (wnn-server-set-rev rev)
  75  *              rev: BOOLEAN
  76  *              rev \e$B$,\e(B nil \e$B$N;~$O@5JQ49!"$=$l0J30$N;~$O5UJQ49\e(B
  77  *
  78  *         (wnn-server-henkan-begin henkan-string)
  79  *              henkan-string: STRING
  80  *              RETURNS: bunsetu-suu
  81  *              DESCRIPTION:
  82  *              \e$B2>L>4A;zJQ49$r$7!"Bh0l8uJd$NJ8@a?t$rJV$9!#\e(B
  83  *
  84  *         (wnn-server-zenkouho bunsetu-no dai)
  85  *              bunsetu-no: INTEGER
  86  *              dai: BOOLEAN
  87  *              RETURNS: offset
  88  *              DESCRIPTION:
  89  *              \e$BJ8@aHV9f$G;XDj$5$l$?J8@a$NA48uJd$r$H$j$@$7\e(B
  90  *              \e$B!"8=:_$N%*%U%;%C%H$rJV$9!#\e(B
  91  *
  92  *         (wnn-server-get-zenkouho offset)
  93  *              bunsetu-no: INTEGER
  94  *              dai: BOOLEAN
  95  *              RETURNS: list of zenkouho
  96  *              DESCRIPTION:
  97  *              \e$B%*%U%;%C%H$G;XDj$5$l$?8uJd$rF@$k!#\e(B
  98  *
  99  *         (wnn-server-zenkouho-bun)
 100  *              RETURNS: INTEGER
 101  *              DESCRIPTION:
 102  *              \e$BA48uJd$rI=<($7$F$$$kJ8@aHV9f$rF@$k!#\e(B
 103  *
 104  *         (wnn-server-zenkouho-suu)
 105  *              RETURNS: INTEGER
 106  *              DESCRIPTION:
 107  *              \e$BA48uJd$rI=<($7$F$$$kJ8@a$NA48uJd?t$rF@$k!#\e(B
 108  *
 109  *         (wnn-server-dai-top bun-no)
 110  *              bun-no: INTEGER
 111  *              RETURNS: BOOLEAN
 112  *              DESCRIPTION:
 113  *              \e$BJ8@a$,BgJ8@a$N@hF,$J$i\e(B t
 114  *
 115  *         (wnn-server-dai-end bun-no)
 116  *              bun-no: INTEGER
 117  *              RETURNS: INTEGER
 118  *              DESCRIPTION:
 119  *              \e$B<!$NBgJ8@a$NJ8@aHV9f$rF@$k!#\e(B
 120  *
 121  *         (wnn-server-henkan-kakutei kouho-no dai)
 122  *              kouho-no: INTEGER
 123  *              dai: BOOLEAN
 124  *              RETURNS: BOOLEAN
 125  *              DESCRIPTION:
 126  *              \e$B8uJdHV9f$G<($5$l$?8uJd$rA*Br$9$k!#\e(B
 127  *              (wnn-server-zenkouho) \e$B$r8F$s$F$+$i$G$J$$$H$$$1$J$$!#\e(B
 128  *
 129  *         (wnn-server-bunsetu-henkou bunsetu-no bunsetu-length dai)
 130  *              bunsetu-no: INTEGER
 131  *              bunsetu-length: INTEGER
 132  *              dai: BOOLEAN
 133  *              RETURNS:
 134  *              DESCRIPTION:
 135  *              \e$BJ8@a$ND9$5$rJQ99$9$k!#\e(B
 136  *
 137  *         (wnn-bunsetu-kouho-inspect bunsetu-no)
 138  *              bunsetu-no: INTEGER
 139  *              RETURNS: (kanji yomi jisho-no serial-no hinsi hindo
 140  *              ima hyoka daihyoka kangovect)
 141  *              DESCRIPTION:
 142  *              \e$BJ8@a$N?'!9$J>pJs$rJQ49%P%C%U%!$+$i$H$j=P$9!#\e(B
 143  *
 144  *         (wnn-server-henkan-quit)
 145  *              RETURNS: BOOLEAN
 146  *              DESCRIPTION:
 147  *              \e$B2?$b$7$J$$!#\e(B
 148  *
 149  *         (wnn-server-bunsetu-kanji bun-no)
 150  *              RETURNS: (bunsetu-kanji length)
 151  *              DESCRIPTION:
 152  *
 153  *         (wnn-server-bunsetu-yomi bun-no)
 154  *              RETURNS: (bunsetu-yomi length)
 155  *              DESCRIPTION:
 156  *
 157  *         (wnn-server-bunsetu-suu)
 158  *              RETURNS: bunsetu-suu
 159  *              DESCRIPTION:
 160  *
 161  *         (wnn-server-hindo-update &optional bunsetu-no)
 162  *              bunsetu-no: INTEGER
 163  *              RETURNS: BOOLEAN
 164  *              DESCRIPTION:
 165  *              \e$BIQEY>pJs$r99?7$9$k!#\e(B
 166  *
 167  *         (wnn-server-word-add dic-no tango yomi comment hinsi)
 168  *              dic-no: INTEGER
 169  *              tango: STRING
 170  *              yoni: STRING
 171  *              comment: STRING
 172  *              hinsi: INTEGER
 173  *              RETURNS: BOOLEAN
 174  *              DESCRIPTION:
 175  *              \e$B<-=q$KC18l$rEPO?$9$k!#\e(B
 176  *
 177  *         (wnn-server-word-delete dic-no entry)
 178  *              dic-no: INTEGER
 179  *              entry: INTEGER
 180  *              RETURNS: BOOLEAN
 181  *              DESCRIPTION:
 182  *              \e$B<-=q$+$i%(%s%H%jHV9f$G<($5$l$kC18l$r:o=|$9$k!#\e(B
 183  *
 184  *         (wnn-server-word-use dic-no entry)
 185  *              dic-no: INTEGER
 186  *              entry: INTEGER
 187  *              RETURNS: BOOLEAN
 188  *              DESCRIPTION:
 189  *              \e$B<-=q$+$i%(%s%H%jHV9f$G<($5$l$kC18l$NM-8z!?L58z$r%H%0%k$9$k!#\e(B
 190   *
 191  *         (wnn-server-word-info dic-no entry)
 192  *              dic-no: INTEGER
 193  *              entry: INTEGER
 194  *              RETURNS: (yomi kanji comment hindo hinsi)
 195  *              DESCRIPTION:
 196  *              \e$B<-=q$+$i%(%s%H%jHV9f$G<($5$l$kC18l$N>pJs$rF@$k!#\e(B
 197  *
 198  *         (wnn-server-word-hindo-set dic-no entry hindo)
 199  *              dic-no: INTEGER
 200  *              entry: INTEGER
 201  *              hindo: INTEGER
 202  *              RETURNS: BOOLEAN
 203  *              DESCRIPTION:
 204  *              \e$B<-=q$+$i%(%s%H%jHV9f$G<($5$l$kC18l$NIQEY$r@_Dj$9$k!#\e(B
 205  *
 206  *         (wnn-server-word-search yomi)
 207  *              yomi: STRING
 208  *              RETURNS: a LIST of dict-joho
 209  *              DESCRIPTION:
 210  *              \e$BA4$F$N<-=q$+$iC18l8!:w$r9T$J$&!#\e(B
 211  *
 212  *         (wnn-server-dict-save)
 213  *              RETURNS: BOOLEAN
 214  *              DESCRIPTION:
 215  *              \e$BA4$F$N<-=q$HIQEY%U%!%$%k$r%;!<%V$9$k!#\e(B
 216  *
 217  *         (wnn-server-get-param)
 218  *              RETURNS: (n nsho p1 p2 p3 ... p15)
 219  *              DESCRIPTION: \e$BJQ49%Q%i%a!<%?$rF@$k!#\e(B
 220  *
 221  *         (wnn-server-set-param n sho p1 ... p15)
 222  *              RETURNS: \e$B%(%i!<$N;~\e(B nil
 223  *              DESCRIPTION: \e$BJQ49%Q%i%a!<%?$r@_Dj$9$k!#\e(B
 224  *
 225  *         (wnn-server-get-msg error-no)
 226  *              RETURNS: \e$B%(%i!<%a225;!<%8\e(B
 227  *              DESCRIPTION: \e$B%(%i!<HV9f$+$i%a%C%;!<%8$rF@$k!#\e(B
 228  *
 229  *         (wnn-server-fuzokugo-set fname)
 230  *              RETURNS: \e$B%(%i!<$N;~\e(B nil
 231  *              DESCRIPTION: \e$B%P%C%U%!$KImB08l%U%!%$%k$rFI$_9~$`!#\e(B
 232  *
 233  *         (wnn-server-fuzokugo-get)
 234  *              RETURNS: \e$B%U%!%$%kL>\e(B
 235  *              DESCRIPTION: \e$B%P%C%U%!$NImB08l%U%!%$%kL>$rF@$k!#\e(B
 236  *
 237  *         (wnn-server-isconnect)
 238  *              RETURNS: \e$B%3%M%/%H$7$F$l$P\e(B t, \e$B$7$F$J$1$l$P\e(B nil
 239  *              DESCRIPTION: \e$B%5!<%P$H7Q$C$F$$$k$+D4$Y$k!#\e(B
 240  *
 241  *         (wnn-server-hinsi-dicts hinsi-no)
 242  *              RETURNS: (dic-no1 dic-no2 ...)
 243  *              DESCRIPTION: hinsi-no \e$B$NIJ;l$,EPO?$G$-$k<-=q$N%j%9%H$rF@$k!#\e(B
 244  *              hinsi-no = -1 \e$B$N$H$-$K$O!"EPO?2DG=$JA4<-=q$rF@$k!#\e(B
 245  *
 246  *         (wnn-server-hinsi-list dic-no name)
 247  *              RETURNS: (name1 name2 ... )
 248  *              DESCRIPTION: dic-no \e$B$N<-=q$G!"IJ;l%N!<%I$KB0$9$k\e(B
 249  *              \e$BIJ;l%N!<%I!JL>!K$N%j%9%H$rF@$k!#\e(B
 250  *              \e$BIJ;lL>$rM?$($?;~$O!"#0$rJV$9!#\e(B
 251  *
 252  *         (wnn-server-hinsi-name hinsi-no)
 253  *              RETURNS: hinsi-name
 254  *              DESCRIPTION: \e$BIJ;lHV9f$+$iL>A0$r<h$k!#\e(B
 255  *
 256  *         (wnn-server-hinsi-number hinsi-name)
 257  *              RETURNS: hinsi-no
 258  *              DESCRIPTION: \e$BIJ;lL>$rIJ;lHV9f$KJQ49$9$k!#\e(B
 259  *
 260  *         (wnn-server-version)
 261  *              RETURNS: version ID(int)
 262  *
 263  */
 264
 265 #include <config.h>
 266 #include "lisp.h"
 267
 268 #include "buffer.h"
 269 #include "ui/window.h"
 270 #include "sysdep.h"
 271
 272 #include "wnn/commonhd.h"
 273 #include "mule-charset.h"
 274 #include "wnn/jllib.h"
 275 #include "wnn/cplib.h"
 276
 277 /* UCHAR \e$B$,Fs=EDj5A$5$l$k$N$G\e(B */
 278 #define _UCHAR_T
 279
 280 #define EGG_TIMEOUT 5
 281 #define NSERVER 4
 282 #define WNNSERVER_J 0
 283 #define WNNSERVER_C 1
 284 #define WNNSERVER_T 2
 285 #define WNNSERVER_K 3
 286
 287 int check_wnn_server_type(void);
 288 void w2m(w_char * wp, unsigned char *mp, unsigned char lb);
 289 void m2w(unsigned char *mp, w_char * wp);
 290 void w2y(w_char * w);
 291 void c2m(unsigned char *cp, unsigned char *mp, unsigned char lb);
 292 static void puts2(char *s);
 293 static int dai_end(int no, int server);
 294 static int yes_or_no(unsigned char *s);
 295
 296  /* Why doesn't wnn have a prototype for these? */
 297 typedef unsigned int letter;
 298 int cwnn_yincod_pzy(w_char *, w_char, int);
 299 int cwnn_pzy_yincod(letter *, letter *, int);
 300
 301 static struct wnn_buf *wnnfns_buf[NSERVER];
 302 static struct wnn_env *wnnfns_env_norm[NSERVER];
 303 static struct wnn_env *wnnfns_env_rev[NSERVER];
 304 static int wnnfns_norm;
 305 static unsigned char lb_wnn_server_type[NSERVER] =
 306     { LEADING_BYTE_JAPANESE_JISX0208, LEADING_BYTE_CHINESE_GB2312,
 307 LEADING_BYTE_THAI_TIS620, LEADING_BYTE_KOREAN_KSC5601 };
 308
 309 /* Lisp Variables and Constants Definition */
 310 Lisp_Object Qjserver;
 311 Lisp_Object Qcserver;
 312 /*Lisp_Object   Qtserver;*/
 313 Lisp_Object Qkserver;
 314 Lisp_Object Qwnn_no_uniq;
 315 Lisp_Object Qwnn_uniq;
 316 Lisp_Object Qwnn_uniq_kanji;
 317 Lisp_Object Qwnn_n, Qwnn_nsho, Qwnn_hindo, Qwnn_len, Qwnn_jiri, Qwnn_flag;
 318 Lisp_Object Qwnn_jisho, Qwnn_sbn, Qwnn_dbn_len, Qwnn_sbn_cnt, Qwnn_suuji;
 319 Lisp_Object Qwnn_kana, Qwnn_eisuu, Qwnn_kigou, Qwnn_toji_kakko, Qwnn_fuzokogo,
 320     Qwnn_kaikakko;
 321 Lisp_Object Vwnn_server_type;
 322 Lisp_Object Vcwnn_zhuyin;
 323 Lisp_Object Vwnnenv_sticky;
 324 Lisp_Object Vwnn_uniq_level;
 325 Fixnum lb_sisheng;
 326
 327 /* Lisp functions definition */
 328
 329 DEFUN("wnn-server-open", Fwnn_open, 2, 2, 0,    /*
 330 Connect to jserver of host HNAME, make an environment with
 331 login name LNAME in the server.
 332 Return nil if error occurs.
 333 */
 334       (hname, lname))
 335 {
 336         char *envname;
 337         char *langname;
 338         char *hostname;
 339         int snum;
 340         int size;
 341         CHECK_STRING(lname);
 342
 343         snum = check_wnn_server_type();
 344         switch (snum) {
 345         case WNNSERVER_J:
 346                 langname = "ja_JP";
 347                 break;
 348         case WNNSERVER_C:
 349                 langname = "zh_CN";
 350                 break;
 351 /*
 352     case WNNSERVER_T:
 353     strcpy (langname, "zh_TW");
 354     break;
 355     */
 356         case WNNSERVER_K:
 357                 langname = "ko_KR";
 358                 break;
 359         case -1:
 360         default:
 361                 return Qnil;
 362         }
 363         size = XSTRING_LENGTH(lname) > 1024 ? 1026 : XSTRING_LENGTH(lname) + 2;
 364         envname = alloca(size);
 365         strncpy(envname, (char *)XSTRING_DATA(lname), size - 2);
 366         envname[size - 2] = '\0';
 367         if (NILP(hname))
 368                 hostname = "";
 369         else {
 370                 CHECK_STRING(hname);
 371                 size =
 372                     XSTRING_LENGTH(hname) >
 373                     1024 ? 1025 : XSTRING_LENGTH(hname) + 1;
 374
 375                 hostname = alloca(size);
 376                 strncpy(hostname, (char *)XSTRING_DATA(hname), size - 1);
 377                 hostname[size - 1] = '\0';
 378         }
 379         CHECK_STRING(lname);
 380         /* 97/4/16 jhod@po.iijnet.or.jp
 381          * libwnn uses SIGALRM, so we need to stop and start interrupts.
 382          */
 383         stop_interrupts();
 384         if (!(wnnfns_buf[snum] = jl_open_lang(envname, hostname, langname,
 385                                               0, 0, 0, EGG_TIMEOUT))) {
 386                 start_interrupts();
 387                 return Qnil;
 388         }
 389         if (!jl_isconnect(wnnfns_buf[snum])) {
 390                 start_interrupts();
 391                 return Qnil;
 392         }
 393         wnnfns_env_norm[snum] = jl_env_get(wnnfns_buf[snum]);
 394 /*  if (Vwnnenv_sticky == Qt) jl_env_sticky_e (wnnfns_env_norm[snum]);
 395     else jl_env_un_sticky_e (wnnfns_env_norm[snum]);*/
 396         strcat(envname, "R");
 397         if (!
 398             (wnnfns_env_rev[snum] =
 399              jl_connect_lang(envname, hostname, langname, 0, 0, 0,
 400                              EGG_TIMEOUT))) {
 401                 start_interrupts();
 402                 return Qnil;
 403         }
 404 /*  if (Vwnnenv_sticky == Qt) jl_env_sticky_e (wnnfns_env_rev[snum]);
 405     else jl_env_un_sticky_e (wnnfns_env_rev[snum]);*/
 406         start_interrupts();
 407         return Qt;
 408 }
 409
 410 DEFUN("wnn-server-close", Fwnn_close, 0, 0, 0,  /*
 411 Close the connection to jserver, Dictionary and frequency files
 412 are not saved.
 413 */
 414       ())
 415 {
 416         int snum;
 417         if ((snum = check_wnn_server_type()) == -1)
 418                 return Qnil;
 419         if (!wnnfns_buf[snum])
 420                 return Qnil;
 421         if (wnnfns_env_norm[snum]) {
 422                 if (NILP(Vwnnenv_sticky))
 423                         jl_env_un_sticky_e(wnnfns_env_norm[snum]);
 424                 else
 425                         jl_env_sticky_e(wnnfns_env_norm[snum]);
 426                 jl_disconnect(wnnfns_env_norm[snum]);
 427         }
 428         if (wnnfns_env_rev[snum]) {
 429                 if (NILP(Vwnnenv_sticky))
 430                         jl_env_un_sticky_e(wnnfns_env_rev[snum]);
 431                 else
 432                         jl_env_sticky_e(wnnfns_env_rev[snum]);
 433                 jl_disconnect(wnnfns_env_rev[snum]);
 434         }
 435         jl_env_set(wnnfns_buf[snum], 0);
 436         jl_close(wnnfns_buf[snum]);
 437         wnnfns_buf[snum] = (struct wnn_buf *)0;
 438         wnnfns_env_norm[snum] = wnnfns_env_rev[snum] = (struct wnn_env *)0;
 439         return Qt;
 440 }
 441
 442 DEFUN("wnn-server-dict-add", Fwnn_dict_add, 5, MANY, 0, /*
 443 Add dictionary specified by DICT-FILE-NAME, FREQ-FILE-NAME,
 444 PRIORITY, DICT-FILE-MODE, FREQ-FILE-MODE.
 445 Specify password files of dictionary and frequency, PW1 and PW2, if needed.
 446 */
 447       (int nargs, Lisp_Object * args))
 448 {
 449         struct gcpro gcpro1;
 450         int snum;
 451         CHECK_STRING(args[0]);
 452         CHECK_STRING(args[1]);
 453         CHECK_INT(args[2]);
 454         if (!NILP(args[5]))
 455                 CHECK_STRING(args[5]);
 456         if (!NILP(args[6]))
 457                 CHECK_STRING(args[6]);
 458         if ((snum = check_wnn_server_type()) == -1)
 459                 return Qnil;
 460         if (!wnnfns_buf[snum])
 461                 return Qnil;
 462         GCPRO1(*args);
 463         gcpro1.nvars = nargs;
 464         if (jl_dic_add(wnnfns_buf[snum],
 465                        XSTRING_DATA(args[0]),
 466                        XSTRING_DATA(args[1]),
 467                        wnnfns_norm ? WNN_DIC_ADD_NOR : WNN_DIC_ADD_REV,
 468                        XINT(args[2]),
 469                        NILP(args[3]) ? WNN_DIC_RDONLY : WNN_DIC_RW,
 470                        NILP(args[4]) ? WNN_DIC_RDONLY : WNN_DIC_RW,
 471                        NILP(args[5]) ? 0 : XSTRING_DATA(args[5]),
 472                        NILP(args[6]) ? 0 : XSTRING_DATA(args[6]),
 473                        yes_or_no, puts2) < 0) {
 474                 UNGCPRO;
 475                 return Qnil;
 476         }
 477         UNGCPRO;
 478         return Qt;
 479 }
 480
 481 DEFUN("wnn-server-dict-delete", Fwnn_dict_delete, 1, 1, 0,      /*
 482 Remove dictionary specified by DIC-NUMBER from buffer.
 483 */
 484       (dicno))
 485 {
 486         int no;
 487         int snum;
 488         CHECK_INT(dicno);
 489         if ((snum = check_wnn_server_type()) == -1)
 490                 return Qnil;
 491         no = XINT(dicno);
 492         if (!wnnfns_buf[snum])
 493                 return Qnil;
 494         if (jl_dic_delete(wnnfns_buf[snum], no) < 0)
 495                 return Qnil;
 496         return Qt;
 497 }
 498
 499 DEFUN("wnn-server-dict-list", Fwnn_dict_list, 0, 0, 0,  /*
 500 Return information of dictionaries.
 501 */
 502       ())
 503 {
 504         WNN_DIC_INFO *dicinfo;
 505         int cnt, i;
 506         unsigned char comment[1024];
 507         Lisp_Object val;
 508         int snum;
 509         unsigned char lb;
 510
 511         if ((snum = check_wnn_server_type()) == -1)
 512                 return Qnil;
 513         lb = lb_wnn_server_type[snum];
 514         if (!wnnfns_buf[snum])
 515                 return Qnil;
 516 #ifdef  WNN6
 517         if ((cnt = jl_fi_dic_list(wnnfns_buf[snum], 0x3f, &dicinfo)) < 0)
 518                 return Qnil;
 519 #else
 520         if ((cnt = jl_dic_list(wnnfns_buf[snum], &dicinfo)) < 0)
 521                 return Qnil;
 522 #endif
 523         val = Qnil;
 524         for (i = 0, dicinfo += cnt; i < cnt; i++) {
 525                 dicinfo--;
 526                 w2m(dicinfo->comment, comment, lb);
 527                 /* #### The following has not been Mule-ized!!
 528                    fname and comment must be ASCII strings! */
 529                 val =
 530                     Fcons(Fcons(make_int(dicinfo->dic_no),
 531                                 list4(make_string((Bufbyte *) (dicinfo->fname),
 532                                                   strlen(dicinfo->fname)),
 533                                       make_string(comment,
 534                                                   strlen((char *)comment)),
 535                                       make_int(dicinfo->gosuu),
 536                                       make_int(dicinfo->nice))), val);
 537         }
 538         return val;
 539 }
 540
 541 DEFUN("wnn-server-dict-comment", Fwnn_dict_comment, 2, 2, 0,    /*
 542 Set comment to dictionary specified by DIC-NUMBER.
 543 Comment string COMMENT.
 544 */
 545       (dicno, comment))
 546 {
 547         w_char wbuf[512];
 548         int snum;
 549         CHECK_INT(dicno);
 550         CHECK_STRING(comment);
 551         if ((snum = check_wnn_server_type()) == -1)
 552                 return Qnil;
 553         if (!wnnfns_buf[snum])
 554                 return Qnil;
 555         m2w(XSTRING_DATA(comment), wbuf);
 556         if (jl_dic_comment_set(wnnfns_buf[snum], XINT(dicno), wbuf) < 0)
 557                 return Qnil;
 558         return Qt;
 559 }
 560
 561 DEFUN("wnn-server-set-rev", Fwnn_set_rev, 1, 1, 0,      /*
 562 Switch the translation mode to normal if T, or reverse if NIL.
 563 */
 564       (rev))
 565 {
 566         int snum;
 567         if ((snum = check_wnn_server_type()) == -1)
 568                 return Qnil;
 569         if (NILP(rev)) {
 570                 if ((!wnnfns_buf[snum]) || (!wnnfns_env_norm[snum]))
 571                         return Qnil;
 572                 jl_env_set(wnnfns_buf[snum], wnnfns_env_norm[snum]);
 573                 wnnfns_norm = 1;
 574         } else {
 575                 if ((!wnnfns_buf[snum]) || (!wnnfns_env_rev[snum]))
 576                         return Qnil;
 577                 jl_env_set(wnnfns_buf[snum], wnnfns_env_rev[snum]);
 578                 wnnfns_norm = 0;
 579         }
 580         return Qt;
 581 }
 582
 583 DEFUN("wnn-server-henkan-begin", Fwnn_begin_henkan, 1, 1, 0,    /*
 584 Translate YOMI string to kanji. Retuen the number of bunsetsu.
 585 */
 586       (hstring))
 587 {
 588         int cnt;
 589         w_char wbuf[5000];
 590         int snum;
 591         CHECK_STRING(hstring);
 592         if ((snum = check_wnn_server_type()) == -1)
 593                 return Qnil;
 594         if (!wnnfns_buf[snum])
 595                 return Qnil;
 596         m2w(XSTRING_DATA(hstring), wbuf);
 597         if (snum == WNNSERVER_C)
 598                 w2y(wbuf);
 599
 600 #ifdef  WNN6
 601         if ((cnt =
 602              jl_fi_ren_conv(wnnfns_buf[snum], wbuf, 0, -1, WNN_USE_MAE)) < 0)
 603                 return Qnil;
 604 #else
 605         if ((cnt = jl_ren_conv(wnnfns_buf[snum], wbuf, 0, -1, WNN_USE_MAE)) < 0)
 606                 return Qnil;
 607 #endif
 608         return make_int(cnt);
 609 }
 610
 611 DEFUN("wnn-server-zenkouho", Fwnn_zenkouho, 2, 2, 0,    /*
 612 Get zenkouho at BUNSETSU-NUMBER. Second argument DAI is t.
 613 if dai-bunsetsu, NIL if sho-bunsetsu. Return the current offset of zenkouho.
 614 */
 615       (bunNo, dai))
 616 {
 617         int no, offset;
 618         int snum;
 619         int uniq_level;
 620         CHECK_INT(bunNo);
 621         if ((snum = check_wnn_server_type()) == -1)
 622                 return Qnil;
 623         if (!wnnfns_buf[snum])
 624                 return Qnil;
 625         no = XINT(bunNo);
 626         if (EQ(Vwnn_uniq_level, Qwnn_no_uniq))
 627                 uniq_level = WNN_NO_UNIQ;
 628         else if (EQ(Vwnn_uniq_level, Qwnn_uniq))
 629                 uniq_level = WNN_UNIQ;
 630         else
 631                 uniq_level = WNN_UNIQ_KNJ;
 632         if (NILP(dai)) {
 633                 if ((offset = jl_zenkouho(wnnfns_buf[snum], no, WNN_USE_MAE,
 634                                           uniq_level)) < 0)
 635                         return Qnil;
 636         } else {
 637                 if ((offset =
 638                      jl_zenkouho_dai(wnnfns_buf[snum], no, dai_end(no, snum),
 639                                      WNN_USE_MAE, uniq_level)) < 0)
 640                         return Qnil;
 641         }
 642         return make_int(offset);
 643 }
 644
 645 DEFUN("wnn-server-get-zenkouho", Fwnn_get_zenkouho, 1, 1, 0,    /*
 646 Get kanji string of KOUHO-NUMBER.
 647 */
 648       (kouhoNo))
 649 {
 650         unsigned char kanji_buf[256];
 651         w_char wbuf[256];
 652         int snum;
 653         unsigned char lb;
 654         CHECK_INT(kouhoNo);
 655         if ((snum = check_wnn_server_type()) == -1)
 656                 return Qnil;
 657         lb = lb_wnn_server_type[snum];
 658         if (!wnnfns_buf[snum])
 659                 return Qnil;
 660         jl_get_zenkouho_kanji(wnnfns_buf[snum], XINT(kouhoNo), wbuf);
 661         w2m(wbuf, kanji_buf, lb);
 662         return make_string(kanji_buf, strlen((char *)kanji_buf));
 663 }
 664
 665 DEFUN("wnn-server-zenkouho-bun", Fwnn_zenkouho_bun, 0, 0, 0,    /*
 666 For Wnn.
 667 */
 668       ())
 669 {
 670         int snum;
 671         if ((snum = check_wnn_server_type()) == -1)
 672                 return Qnil;
 673         return make_int(jl_zenkouho_bun(wnnfns_buf[snum]));
 674 }
 675
 676 DEFUN("wnn-server-zenkouho-suu", Fwnn_zenkouho_suu, 0, 0, 0,    /*
 677 Return the number of zen kouho.
 678 */
 679       ())
 680 {
 681         int snum;
 682         if ((snum = check_wnn_server_type()) == -1)
 683                 return Qnil;
 684         return make_int(jl_zenkouho_suu(wnnfns_buf[snum]));
 685 }
 686
 687 DEFUN("wnn-server-dai-top", Fwnn_dai_top, 1, 1, 0,      /*
 688 Return t if bunsetsu BUN-NUMBER is dai-bunsetsu.
 689 */
 690       (bunNo))
 691 {
 692         int snum;
 693         CHECK_INT(bunNo);
 694         if ((snum = check_wnn_server_type()) == -1)
 695                 return Qnil;
 696         if (!wnnfns_buf[snum])
 697                 return Qnil;
 698         if (jl_dai_top(wnnfns_buf[snum], XINT(bunNo)) == 1)
 699                 return Qt;
 700         else
 701                 return Qnil;
 702 }
 703
 704 DEFUN("wnn-server-dai-end", Fwnn_dai_end, 1, 1, 0,      /*
 705 Return the bunsetu number of the next dai-bunsetsu after BUN-NUMBER.
 706 */
 707       (bunNo))
 708 {
 709         int snum;
 710         CHECK_INT(bunNo);
 711         if ((snum = check_wnn_server_type()) == -1)
 712                 return Qnil;
 713         if (!wnnfns_buf[snum])
 714                 return Qnil;
 715         return make_int(dai_end(XINT(bunNo), snum));
 716 }
 717
 718 DEFUN("wnn-server-henkan-kakutei", Fwnn_kakutei, 2, 2, 0,       /*
 719 Set candidate with OFFSET, DAI. DAI is T if dai-bunsetsu.
 720 */
 721       (offset, dai))
 722 {
 723         int snum;
 724         CHECK_INT(offset);
 725         if ((snum = check_wnn_server_type()) == -1)
 726                 return Qnil;
 727         if (!wnnfns_buf[snum])
 728                 return Qnil;
 729         if (NILP(dai)) {
 730                 if (jl_set_jikouho(wnnfns_buf[snum], XINT(offset)) < 0)
 731                         return Qnil;
 732         } else {
 733                 if (jl_set_jikouho_dai(wnnfns_buf[snum], XINT(offset)) < 0)
 734                         return Qnil;
 735         }
 736         return Qt;
 737 }
 738
 739 DEFUN("wnn-server-bunsetu-henkou", Fwnn_bunsetu_henkou, 3, 3, 0,        /*
 740 Change length of BUN-NUMBER bunsetu to LEN. DAI is T if dai-bunsetsu.
 741 */
 742       (bunNo, len, dai))
 743 {
 744         int cnt, no;
 745         int snum;
 746         CHECK_INT(bunNo);
 747         CHECK_INT(len);
 748         if ((snum = check_wnn_server_type()) == -1)
 749                 return Qnil;
 750         if (!wnnfns_buf[snum])
 751                 return Qnil;
 752         no = XINT(bunNo);
 753 #ifdef  WNN6
 754         if ((cnt =
 755              jl_fi_nobi_conv(wnnfns_buf[snum], no, XINT(len), -1, WNN_USE_MAE,
 756                              NILP(dai) ? WNN_SHO : WNN_DAI)) < 0)
 757                 return Qnil;
 758 #else
 759         if ((cnt =
 760              jl_nobi_conv(wnnfns_buf[snum], no, XINT(len), -1, WNN_USE_MAE,
 761                           NILP(dai) ? WNN_SHO : WNN_DAI)) < 0)
 762                 return Qnil;
 763 #endif
 764         return make_int(cnt);
 765 }
 766
 767 DEFUN("wnn-server-inspect", Fwnn_inspect, 1, 1, 0,      /*
 768 Get bunsetsu information specified by BUN-NUMBER.
 769 */
 770       (bunNo))
 771 {
 772         Lisp_Object val;
 773         unsigned char cbuf[512];
 774         w_char wbuf[256];
 775         int bun_no, yomilen, jirilen, i;
 776         int snum;
 777         unsigned char lb;
 778         CHECK_INT(bunNo);
 779         if ((snum = check_wnn_server_type()) == -1)
 780                 return Qnil;
 781         lb = lb_wnn_server_type[snum];
 782         if (!wnnfns_buf[snum])
 783                 return Qnil;
 784         bun_no = XINT(bunNo);
 785         val = Qnil;
 786         val = Fcons(make_int(wnnfns_buf[snum]->bun[bun_no]->kangovect), val);
 787         val = Fcons(make_int(wnnfns_buf[snum]->bun[bun_no]->daihyoka), val);
 788         val = Fcons(make_int(wnnfns_buf[snum]->bun[bun_no]->hyoka), val);
 789         val = Fcons(make_int(wnnfns_buf[snum]->bun[bun_no]->ima), val);
 790         val = Fcons(make_int(wnnfns_buf[snum]->bun[bun_no]->hindo), val);
 791         val = Fcons(make_int(wnnfns_buf[snum]->bun[bun_no]->hinsi), val);
 792         val = Fcons(make_int(wnnfns_buf[snum]->bun[bun_no]->entry), val);
 793         val = Fcons(make_int(wnnfns_buf[snum]->bun[bun_no]->dic_no), val);
 794         yomilen = jl_get_yomi(wnnfns_buf[snum], bun_no, bun_no + 1, wbuf);
 795         jirilen = wnnfns_buf[snum]->bun[bun_no]->jirilen;
 796         for (i = yomilen; i >= jirilen; i--)
 797                 wbuf[i + 1] = wbuf[i];
 798         wbuf[jirilen] = '+';
 799         w2m(wbuf, cbuf, lb);
 800         val = Fcons(make_string(cbuf, strlen((char *)cbuf)), val);
 801         jl_get_kanji(wnnfns_buf[snum], bun_no, bun_no + 1, wbuf);
 802         w2m(wbuf, cbuf, lb);
 803         val = Fcons(make_string(cbuf, strlen((char *)cbuf)), val);
 804         return val;
 805 }
 806
 807 DEFUN("wnn-server-henkan-quit", Fwnn_quit_henkan, 0, 0, 0,      /*
 808 do nothing.
 809 */
 810       ())
 811 {
 812         int snum;
 813         if ((snum = check_wnn_server_type()) == -1)
 814                 return Qnil;
 815         if (!wnnfns_buf[snum])
 816                 return Qnil;
 817         return Qt;
 818 }
 819
 820 DEFUN("wnn-server-bunsetu-kanji", Fwnn_bunsetu_kanji, 1, 1, 0,  /*
 821 Get the pair of kanji and length of bunsetsu specified by BUN-NUMBER.
 822 */
 823       (bunNo))
 824 {
 825         int no;
 826         unsigned char kanji_buf[256];
 827         w_char wbuf[256];
 828         int kanji_len;
 829         int snum;
 830         unsigned char lb;
 831         CHECK_INT(bunNo);
 832         if ((snum = check_wnn_server_type()) == -1)
 833                 return Qnil;
 834         lb = lb_wnn_server_type[snum];
 835         if (!wnnfns_buf[snum])
 836                 return Qnil;
 837         no = XINT(bunNo);
 838         kanji_len = jl_get_kanji(wnnfns_buf[snum], no, no + 1, wbuf);
 839         w2m(wbuf, kanji_buf, lb);
 840         return Fcons(make_string(kanji_buf, strlen((char *)kanji_buf)),
 841                      make_int(kanji_len));
 842 }
 843
 844 DEFUN("wnn-server-bunsetu-yomi", Fwnn_bunsetu_yomi, 1, 1, 0,    /*
 845 Get the pair of yomi and length of bunsetsu specified by BUN-NUMBER.
 846 */
 847       (bunNo))
 848 {
 849         int no;
 850         unsigned char yomi_buf[256];
 851         w_char wbuf[256];
 852         int yomi_len;
 853         int snum;
 854         unsigned char lb;
 855         CHECK_INT(bunNo);
 856         if ((snum = check_wnn_server_type()) == -1)
 857                 return Qnil;
 858         lb = lb_wnn_server_type[snum];
 859         if (!wnnfns_buf[snum])
 860                 return Qnil;
 861         no = XINT(bunNo);
 862         yomi_len = jl_get_yomi(wnnfns_buf[snum], no, no + 1, wbuf);
 863         w2m(wbuf, yomi_buf, lb);
 864         return Fcons(make_string(yomi_buf, strlen((char *)yomi_buf)),
 865                      make_int(yomi_len));
 866 }
 867
 868 DEFUN("wnn-server-bunsetu-suu", Fwnn_bunsetu_suu, 0, 0, 0,      /*
 869 Get the number of bunsetsu.
 870 */
 871       ())
 872 {
 873         int snum;
 874         if ((snum = check_wnn_server_type()) == -1)
 875                 return Qnil;
 876         if (!wnnfns_buf[snum])
 877                 return Qnil;
 878         return make_int(jl_bun_suu(wnnfns_buf[snum]));
 879 }
 880
 881 DEFUN("wnn-server-hindo-update", Fwnn_hindo_update, 0, 1, 0,    /*
 882 Update frequency of bunsetsu specified by NUM-NUMBER.
 883 */
 884       (bunNo))
 885 {
 886         int no;
 887         int snum;
 888         if ((snum = check_wnn_server_type()) == -1)
 889                 return Qnil;
 890         if (NILP(bunNo))
 891                 no = -1;
 892         else {
 893                 CHECK_INT(bunNo);
 894                 no = XINT(bunNo);
 895         }
 896         if (!wnnfns_buf[snum])
 897                 return Qnil;
 898 #ifdef  WNN6
 899         if (jl_optimize_fi(wnnfns_buf[snum], 0, no) < 0)
 900                 return Qnil;
 901 #else
 902         if (jl_update_hindo(wnnfns_buf[snum], 0, no) < 0)
 903                 return Qnil;
 904 #endif
 905         return Qt;
 906 }
 907
 908 DEFUN("wnn-server-word-add", Fwnn_word_toroku, 5, 5, 0, /*
 909 Add a word to dictionary. Arguments are
 910 DIC-NUMBER, KANJI, YOMI, COMMENT, HINSI-NUMBER.
 911 */
 912       (dicno, kanji, yomi, comment, hinsi))
 913 {
 914         w_char yomi_buf[256], kanji_buf[256], comment_buf[256];
 915         int snum;
 916         CHECK_INT(dicno);
 917         CHECK_STRING(kanji);
 918         CHECK_STRING(yomi);
 919         CHECK_STRING(comment);
 920         CHECK_INT(hinsi);
 921         if ((snum = check_wnn_server_type()) == -1)
 922                 return Qnil;
 923         if (!wnnfns_buf[snum])
 924                 return Qnil;
 925         m2w(XSTRING_DATA(yomi), yomi_buf);
 926         if (snum == WNNSERVER_C)
 927                 w2y(yomi_buf);
 928         m2w(XSTRING_DATA(kanji), kanji_buf);
 929         m2w(XSTRING_DATA(comment), comment_buf);
 930         if (jl_word_add(wnnfns_buf[snum], XINT(dicno), yomi_buf, kanji_buf,
 931                         comment_buf, XINT(hinsi), 0) < 0)
 932                 return Qnil;
 933         else
 934                 return Qt;
 935 }
 936
 937 DEFUN("wnn-server-word-delete", Fwnn_word_sakujo, 2, 2, 0,      /*
 938 Delete a word from dictionary, specified by DIC-NUMBER, SERIAL-NUMBER.
 939 */
 940       (no, serial))
 941 {
 942         int snum;
 943         CHECK_INT(no);
 944         CHECK_INT(serial);
 945         if ((snum = check_wnn_server_type()) == -1)
 946                 return Qnil;
 947         if (!wnnfns_buf[snum])
 948                 return Qnil;
 949         if (jl_word_delete(wnnfns_buf[snum], XINT(no), XINT(serial)) < 0)
 950                 return Qnil;
 951         else
 952                 return Qt;
 953 }
 954
 955 DEFUN("wnn-server-word-use", Fwnn_word_use, 2, 2, 0,    /*
 956 Toggle on/off word, specified by DIC-NUMBER and SERIAL-NUMBER.
 957 */
 958       (no, serial))
 959 {
 960         int snum;
 961         CHECK_INT(no);
 962         CHECK_INT(serial);
 963         if ((snum = check_wnn_server_type()) == -1)
 964                 return Qnil;
 965         if (!wnnfns_buf[snum])
 966                 return Qnil;
 967         if (jl_word_use(wnnfns_buf[snum], XINT(no), XINT(serial)) < 0)
 968                 return Qnil;
 969         else
 970                 return Qt;
 971 }
 972
 973 DEFUN("wnn-server-word-info", Fwnn_word_info, 2, 2, 0,  /*
 974 Return list of yomi, kanji, comment, hindo, hinshi.
 975 */
 976       (no, serial))
 977 {
 978         Lisp_Object val;
 979         struct wnn_jdata *info_buf;
 980         unsigned char cbuf[512];
 981         int snum;
 982         unsigned char lb;
 983         CHECK_INT(no);
 984         CHECK_INT(serial);
 985         if ((snum = check_wnn_server_type()) == -1)
 986                 return Qnil;
 987         lb = lb_wnn_server_type[snum];
 988         if (!wnnfns_buf[snum])
 989                 return Qnil;
 990         if ((info_buf = jl_word_info(wnnfns_buf[snum],
 991                                      XINT(no), XINT(serial))) != NULL) {
 992                 return Qnil;
 993         } else {
 994                 val = Qnil;
 995                 val = Fcons(make_int(info_buf->hinshi), val);
 996                 val = Fcons(make_int(info_buf->hindo), val);
 997                 w2m(info_buf->com, cbuf, lb);
 998                 val = Fcons(make_string(cbuf, strlen((char *)cbuf)), val);
 999                 w2m(info_buf->kanji, cbuf, lb);
1000                 val = Fcons(make_string(cbuf, strlen((char *)cbuf)), val);
1001                 w2m(info_buf->yomi, cbuf, lb);
1002                 val = Fcons(make_string(cbuf, strlen((char *)cbuf)), val);
1003                 return val;
1004         }
1005 }
1006
1007 DEFUN("wnn-server-word-hindo-set", Fwnn_hindo_set, 3, 3, 0,     /*
1008 Set frequency to arbitrary value. Specified by DIC-NUMBER,
1009 SERIAL-NUMBER, FREQUENCY.
1010 */
1011       (no, serial, hindo))
1012 {
1013         int snum;
1014         CHECK_INT(no);
1015         CHECK_INT(serial);
1016         CHECK_INT(hindo);
1017         if ((snum = check_wnn_server_type()) == -1)
1018                 return Qnil;
1019         if (!wnnfns_buf[snum])
1020                 return Qnil;
1021         if (js_hindo_set(jl_env_get(wnnfns_buf[snum]),
1022                          XINT(no),
1023                          XINT(serial), WNN_HINDO_NOP, XINT(hindo)) < 0)
1024                 return Qnil;
1025         else
1026                 return Qt;
1027 }
1028
1029 DEFUN("wnn-server-word-search", Fwnn_dict_search, 1, 1, 0,      /*
1030 Search a word YOMI from buffer.
1031 Return list of (kanji hinshi freq dic_no serial).
1032 */
1033       (yomi))
1034 {
1035         Lisp_Object val;
1036         struct wnn_jdata *wordinfo;
1037         int i, count;
1038         w_char wbuf[256];
1039         unsigned char kanji_buf[256];
1040         int snum;
1041         unsigned char lb;
1042         CHECK_STRING(yomi);
1043         if ((snum = check_wnn_server_type()) == -1)
1044                 return Qnil;
1045         lb = lb_wnn_server_type[snum];
1046         if (!wnnfns_buf[snum])
1047                 return Qnil;
1048         m2w(XSTRING_DATA(yomi), wbuf);
1049         if (snum == WNNSERVER_C)
1050                 w2y(wbuf);
1051         if ((count = jl_word_search_by_env(wnnfns_buf[snum],
1052                                            wbuf, &wordinfo)) < 0)
1053                 return Qnil;
1054         val = Qnil;
1055         for (i = 0, wordinfo += count; i < count; i++) {
1056                 wordinfo--;
1057                 w2m(wordinfo->kanji, kanji_buf, lb);
1058                 val =
1059                     Fcons(Fcons
1060                           (make_string(kanji_buf, strlen((char *)kanji_buf)),
1061                            list4(make_int(wordinfo->hinshi),
1062                                  make_int(wordinfo->hindo),
1063                                  make_int(wordinfo->dic_no),
1064                                  make_int(wordinfo->serial))), val);
1065         }
1066         return val;
1067 }
1068
1069 DEFUN("wnn-server-dict-save", Fwnn_dict_save, 0, 0, 0,  /*
1070 Save all dictionaries and frequency files.
1071 */
1072       ())
1073 {
1074         int snum;
1075         if ((snum = check_wnn_server_type()) == -1)
1076                 return Qnil;
1077         if (!wnnfns_buf[snum])
1078                 return Qnil;
1079         if (jl_dic_save_all(wnnfns_buf[snum]) < 0)
1080                 return Qnil;
1081         else
1082                 return Qt;
1083 }
1084
1085 DEFUN("wnn-server-get-param", Fwnn_get_param, 0, 0, 0,  /*
1086 Returns (n nsho hindo len jiri flag jisho sbn dbn_len sbn_cnt
1087 suuji kana eisuu kigou toji_kakko fuzokogo kaikakko)
1088 */
1089       ())
1090 {
1091         struct wnn_param param;
1092         int snum;
1093         if ((snum = check_wnn_server_type()) == -1)
1094                 return Qnil;
1095         if (!wnnfns_buf[snum])
1096                 return Qnil;
1097         if (jl_param_get(wnnfns_buf[snum], &param) < 0)
1098                 return Qnil;
1099         return Fcons(make_int(param.n),
1100                      Fcons(make_int(param.nsho),
1101                            Fcons(make_int(param.p1),
1102                                  Fcons(make_int(param.p2),
1103                                        Fcons(make_int(param.p3),
1104                                              Fcons(make_int(param.p4),
1105                                                    Fcons(make_int(param.p5),
1106                                                          Fcons(make_int
1107                                                                (param.p6),
1108                                                                Fcons(make_int
1109                                                                      (param.p7),
1110                                                                      Fcons
1111                                                                      (make_int
1112                                                                       (param.
1113                                                                        p8),
1114                                                                       Fcons
1115                                                                       (make_int
1116                                                                        (param.
1117                                                                         p9),
1118                                                                        Fcons
1119                                                                        (make_int
1120                                                                         (param.
1121                                                                          p10),
1122                                                                         Fcons
1123                                                                         (make_int
1124                                                                          (param.
1125                                                                           p11),
1126                                                                          Fcons
1127                                                                          (make_int
1128                                                                           (param.
1129                                                                            p12),
1130                                                                           Fcons
1131                                                                           (make_int
1132                                                                            (param.
1133                                                                             p13),
1134                                                                            Fcons
1135                                                                            (make_int
1136                                                                             (param.
1137                                                                              p14),
1138                                                                             Fcons
1139                                                                             (make_int
1140                                                                              (param.
1141                                                                               p15),
1142                                                                              Qnil)))))))))))))))));
1143 }
1144
1145 DEFUN("wnn-server-set-param", Fwnn_set_param, 1, 1, 0,  /*
1146 Set parameters using an alist, where the CAR contains one of
1147 wnn_n, wnn_nsho, wnn_hindo, wnn_len, wnn_jiri, wnn_flag,
1148 wnn_jisho, wnn_sbn, wnn_dbn_len, wnn_sbn_cnt, wnn_suuji,
1149 wnn_kana, wnn_eisuu, wnn_kigou, wnn_toji_kakko, wnn_fuzokogo,
1150 or wnn_kaikakko and the CDR contains the value.
1151 */
1152       (Vsetvalues_alist))
1153 {
1154         int rc;
1155         struct wnn_param param;
1156         int snum;
1157
1158         if ((snum = check_wnn_server_type()) == -1)
1159                 return Qnil;
1160         if (!wnnfns_buf[snum])
1161                 return Qnil;
1162         rc = jl_param_get(wnnfns_buf[snum], &param);
1163         if (rc < 0)
1164                 return Qnil;
1165
1166         {
1167                 EXTERNAL_PROPERTY_LIST_LOOP_3(key, val, Vsetvalues_alist) {
1168                         int setval;
1169                         CHECK_INT(val);
1170                         setval = XINT(val);
1171                         if (EQ(key, Qwnn_n))
1172                                 param.n = setval;
1173                         else if (EQ(key, Qwnn_nsho))
1174                                 param.nsho = setval;
1175                         else if (EQ(key, Qwnn_hindo))
1176                                 param.p1 = setval;
1177                         else if (EQ(key, Qwnn_len))
1178                                 param.p2 = setval;
1179                         else if (EQ(key, Qwnn_jiri))
1180                                 param.p3 = setval;
1181                         else if (EQ(key, Qwnn_flag))
1182                                 param.p4 = setval;
1183                         else if (EQ(key, Qwnn_jisho))
1184                                 param.p5 = setval;
1185                         else if (EQ(key, Qwnn_sbn))
1186                                 param.p6 = setval;
1187                         else if (EQ(key, Qwnn_dbn_len))
1188                                 param.p7 = setval;
1189                         else if (EQ(key, Qwnn_sbn_cnt))
1190                                 param.p8 = setval;
1191                         else if (EQ(key, Qwnn_suuji))
1192                                 param.p9 = setval;
1193                         else if (EQ(key, Qwnn_kana))
1194                                 param.p10 = setval;
1195                         else if (EQ(key, Qwnn_eisuu))
1196                                 param.p11 = setval;
1197                         else if (EQ(key, Qwnn_kigou))
1198                                 param.p12 = setval;
1199                         else if (EQ(key, Qwnn_toji_kakko))
1200                                 param.p13 = setval;
1201                         else if (EQ(key, Qwnn_fuzokogo))
1202                                 param.p14 = setval;
1203                         else if (EQ(key, Qwnn_kaikakko))
1204                                 param.p15 = setval;
1205                         else {
1206                                 signal_simple_error("Invalid wnn keyword", key);
1207                                 return Qnil;
1208                         }
1209                 }
1210         }
1211
1212 #if 0
1213         printf("wnn_n = %d\n", param.n);
1214         printf("wnn_nsho = %d\n", param.nsho);
1215         printf("wnn_hindo = %d\n", param.p1);
1216         printf("wnn_len = %d\n", param.p2);
1217         printf("wnn_jiri = %d\n", param.p3);
1218         printf("wnn_flag = %d\n", param.p4);
1219         printf("wnn_jisho = %d\n", param.p5);
1220         printf("wnn_sbn = %d\n", param.p6);
1221         printf("wnn_dbn_len = %d\n", param.p7);
1222         printf("wnn_sbn_cnt = %d\n", param.p8);
1223         printf("wnn_suuji = %d\n", param.p9);
1224         printf("wnn_kana = %d\n", param.p10);
1225         printf("wnn_eisuu = %d\n", param.p11);
1226         printf("wnn_kigou = %d\n", param.p12);
1227         printf("wnn_toji_kakko = %d\n", param.p13);
1228         printf("wnn_fuzokogo = %d\n", param.p14);
1229         printf("wnn_kaikakko = %d\n", param.p15);
1230 #endif
1231
1232         rc = jl_param_set(wnnfns_buf[snum], &param);
1233         if (rc < 0)
1234                 return Qnil;
1235         return Qt;
1236 }
1237
1238 DEFUN("wnn-server-get-msg", Fwnn_get_msg, 0, 0, 0,      /*
1239 Get message string from wnn_perror.
1240 */
1241       ())
1242 {
1243         unsigned char mbuf[256];
1244         char *msgp;
1245         int snum;
1246         unsigned char lb;
1247         char langname[32];
1248 /*  CHECK_INT (errno);*/
1249         if ((snum = check_wnn_server_type()) == -1)
1250                 return Qnil;
1251         lb = lb_wnn_server_type[snum];
1252         switch (snum) {
1253         case WNNSERVER_J:
1254                 strcpy(langname, "ja_JP");
1255                 break;
1256         case WNNSERVER_C:
1257                 strcpy(langname, "zh_CN");
1258                 break;
1259 /*
1260   case WNNSERVER_T:
1261   strcpy (langname, "zh_TW");
1262   break;
1263   */
1264         case WNNSERVER_K:
1265                 strcpy(langname, "ko_KR");
1266                 break;
1267         }
1268         if (!wnnfns_buf[snum])
1269                 return Qnil;
1270 /*  msgp = msg_get (wnn_msg_cat, XINT (errno), 0, 0);*/
1271         msgp = wnn_perror_lang(langname);
1272         c2m((unsigned char *)msgp, mbuf, lb);
1273         return make_string(mbuf, strlen((char *)mbuf));
1274 }
1275
1276 DEFUN("wnn-server-fuzokugo-set", Fwnn_fuzokugo_set, 1, 1, 0,    /*
1277 For Wnn.
1278 */
1279       (file))
1280 {
1281         int snum;
1282         CHECK_STRING(file);
1283         if ((snum = check_wnn_server_type()) == -1)
1284                 return Qnil;
1285         if (!wnnfns_buf[snum])
1286                 return Qnil;
1287         if (jl_fuzokugo_set(wnnfns_buf[snum], XSTRING_DATA(file)) < 0)
1288                 return Qnil;
1289         return Qt;
1290 }
1291
1292 DEFUN("wnn-server-fuzokugo-get", Fwnn_fuzokugo_get, 0, 0, 0,    /*
1293 For Wnn.
1294 */
1295       ())
1296 {
1297         char fname[256];
1298         int snum;
1299         if ((snum = check_wnn_server_type()) == -1)
1300                 return Qnil;
1301         if (!wnnfns_buf[snum])
1302                 return Qnil;
1303         if (jl_fuzokugo_get(wnnfns_buf[snum], fname) < 0)
1304                 return Qnil;
1305         return make_string((Bufbyte *) fname, strlen(fname));
1306 }
1307
1308 DEFUN("wnn-server-isconnect", Fwnn_isconnect, 0, 0, 0,  /*
1309 For Wnn.
1310 */
1311       ())
1312 {
1313         int snum;
1314         if ((snum = check_wnn_server_type()) == -1)
1315                 return Qnil;
1316         if (!wnnfns_buf[snum])
1317                 return Qnil;
1318         if (jl_isconnect(wnnfns_buf[snum]))
1319                 return Qt;
1320         else
1321                 return Qnil;
1322 }
1323
1324 DEFUN("wnn-server-hinsi-dicts", Fwnn_hinsi_dicts, 1, 1, 0,      /*
1325 For Wnn.
1326 */
1327       (hinsi))
1328 {
1329         int *area;
1330         int cnt;
1331         Lisp_Object val;
1332         int snum;
1333         CHECK_INT(hinsi);
1334         if ((snum = check_wnn_server_type()) == -1)
1335                 return Qnil;
1336         if (!wnnfns_buf[snum])
1337                 return Qnil;
1338         if ((cnt = jl_hinsi_dicts(wnnfns_buf[snum], XINT(hinsi), &area)) < 0)
1339                 return Qnil;
1340         val = Qnil;
1341         for (area += cnt; cnt > 0; cnt--) {
1342                 area--;
1343                 val = Fcons(make_int(*area), val);
1344         }
1345         return val;
1346 }
1347
1348 DEFUN("wnn-server-hinsi-list", Fwnn_hinsi_list, 2, 2, 0,        /*
1349 For Wnn.
1350 */
1351       (dicno, name))
1352 {
1353         int cnt;
1354         Lisp_Object val;
1355         w_char wbuf[256];
1356         w_char **area;
1357         unsigned char cbuf[512];
1358         int snum;
1359         unsigned char lb;
1360         CHECK_INT(dicno);
1361         CHECK_STRING(name);
1362         if ((snum = check_wnn_server_type()) == -1)
1363                 return Qnil;
1364         lb = lb_wnn_server_type[snum];
1365         if (!wnnfns_buf[snum])
1366                 return Qnil;
1367         m2w(XSTRING_DATA(name), wbuf);
1368         if ((cnt =
1369              jl_hinsi_list(wnnfns_buf[snum], XINT(dicno), wbuf, &area)) < 0)
1370                 return Qnil;
1371         if (cnt == 0)
1372                 return make_int(0);
1373         val = Qnil;
1374         for (area += cnt; cnt > 0; cnt--) {
1375                 area--;
1376                 w2m(*area, cbuf, lb);
1377                 val = Fcons(make_string(cbuf, strlen((char *)cbuf)), val);
1378         }
1379         return val;
1380 }
1381
1382 DEFUN("wnn-server-hinsi-name", Fwnn_hinsi_name, 1, 1, 0,        /*
1383 For Wnn.
1384 */
1385       (no))
1386 {
1387         unsigned char name[256];
1388         w_char *wname;
1389         int snum;
1390         unsigned char lb;
1391         CHECK_INT(no);
1392         if ((snum = check_wnn_server_type()) == -1)
1393                 return Qnil;
1394         lb = lb_wnn_server_type[snum];
1395         if (!wnnfns_buf[snum])
1396                 return Qnil;
1397         if ((wname = jl_hinsi_name(wnnfns_buf[snum], XINT(no))) == 0)
1398                 return Qnil;
1399         w2m(wname, name, lb);
1400         return make_string(name, strlen((char *)name));
1401 }
1402
1403 #ifdef  WNN6
1404 DEFUN("wnn-server-fisys-dict-add", Fwnn_fisys_dict_add, 3, MANY, 0,     /*
1405 Add dictionary specified by FISYS-DICT-FILE-NAME, FISYS-FREQ-FILE-NAME,
1406 FISYS-FREQ-FILE-MODE.
1407 Specify password files of dictionary and frequency, PW1 and PW2, if needed.
1408 */
1409       (int nargs, Lisp_Object * args))
1410 {
1411         struct gcpro gcpro1;
1412         int snum;
1413         CHECK_STRING(args[0]);
1414         CHECK_STRING(args[1]);
1415         if (!NILP(args[3]))
1416                 CHECK_STRING(args[3]);
1417         if ((snum = check_wnn_server_type()) == -1)
1418                 return Qnil;
1419         if (!wnnfns_buf[snum])
1420                 return Qnil;
1421         GCPRO1(*args);
1422         gcpro1.nvars = nargs;
1423         if (jl_fi_dic_add(wnnfns_buf[snum],
1424                           XSTRING_DATA(args[0]),
1425                           XSTRING_DATA(args[1]),
1426                           WNN_FI_SYSTEM_DICT,
1427                           WNN_DIC_RDONLY,
1428                           NILP(args[2]) ? WNN_DIC_RDONLY : WNN_DIC_RW,
1429                           0,
1430                           NILP(args[3]) ? 0 : XSTRING_DATA(args[3]),
1431                           yes_or_no, puts2) < 0) {
1432                 UNGCPRO;
1433                 return Qnil;
1434         }
1435         UNGCPRO;
1436         return Qt;
1437 }
1438
1439 DEFUN("wnn-server-fiusr-dict-add", Fwnn_fiusr_dict_add, 4, MANY, 0,     /*
1440 Add dictionary specified by FIUSR-DICT-FILE-NAME, FIUSR-FREQ-FILE-NAME,
1441 FIUSR-DICT-FILE-MODE, FIUSR-FREQ-FILE-MODE.
1442 Specify password files of dictionary and frequency, PW1 and PW2, if needed.
1443 */
1444       (int nargs, Lisp_Object * args))
1445 {
1446         struct gcpro gcpro1;
1447         int snum;
1448         CHECK_STRING(args[0]);
1449         CHECK_STRING(args[1]);
1450         if (!NILP(args[4]))
1451                 CHECK_STRING(args[4]);
1452         if (!NILP(args[5]))
1453                 CHECK_STRING(args[5]);
1454         if ((snum = check_wnn_server_type()) == -1)
1455                 return Qnil;
1456         if (!wnnfns_buf[snum])
1457                 return Qnil;
1458         GCPRO1(*args);
1459         gcpro1.nvars = nargs;
1460         if (jl_fi_dic_add(wnnfns_buf[snum],
1461                           XSTRING_DATA(args[0]),
1462                           XSTRING_DATA(args[1]),
1463                           WNN_FI_USER_DICT,
1464                           NILP(args[2]) ? WNN_DIC_RDONLY : WNN_DIC_RW,
1465                           NILP(args[3]) ? WNN_DIC_RDONLY : WNN_DIC_RW,
1466                           NILP(args[4]) ? 0 : XSTRING_DATA(args[4]),
1467                           NILP(args[5]) ? 0 : XSTRING_DATA(args[5]),
1468                           yes_or_no, puts2) < 0) {
1469                 UNGCPRO;
1470                 return Qnil;
1471         }
1472         UNGCPRO;
1473         return Qt;
1474 }
1475
1476 DEFUN("wnn-server-notrans-dict-add", Fwnn_notrans_dict_add, 3, MANY, 0, /*
1477 Add dictionary specified by NOTRANS-DICT-FILE-NAME, PRIORITY, DICT-FILE-MODE.
1478 Specify password files of dictionary and frequency PW1 if needed.
1479 */
1480       (int nargs, Lisp_Object * args))
1481 {
1482         struct gcpro gcpro1;
1483         int snum;
1484         int dic_no;
1485         struct wnn_env *cur_env;
1486         unsigned long vmask = 0;
1487         struct wnn_henkan_env henv;
1488         CHECK_STRING(args[0]);
1489         CHECK_INT(args[1]);
1490         if (!NILP(args[3]))
1491                 CHECK_STRING(args[3]);
1492         if ((snum = check_wnn_server_type()) == -1)
1493                 return Qnil;
1494         if (!wnnfns_buf[snum])
1495                 return Qnil;
1496         GCPRO1(*args);
1497         gcpro1.nvars = nargs;
1498         if (wnnfns_norm)
1499                 cur_env = wnnfns_env_norm[snum];
1500         else
1501                 cur_env = wnnfns_env_rev[snum];
1502         dic_no = js_get_autolearning_dic(cur_env, WNN_MUHENKAN_LEARNING);
1503         if (dic_no == WNN_NO_LEARNING) {
1504                 if ((dic_no = jl_dic_add(wnnfns_buf[snum],
1505                                          XSTRING_DATA(args[0]),
1506                                          0,
1507                                          wnnfns_norm ? WNN_DIC_ADD_NOR :
1508                                          WNN_DIC_ADD_REV, XINT(args[1]),
1509                                          WNN_DIC_RW, WNN_DIC_RW,
1510                                          NILP(args[3]) ? 0 :
1511                                          XSTRING_DATA(args[3]), 0, yes_or_no,
1512                                          puts2)) < 0) {
1513                         UNGCPRO;
1514                         return Qnil;
1515                 }
1516                 js_set_autolearning_dic(cur_env, WNN_MUHENKAN_LEARNING, dic_no);
1517         }
1518         if (!js_is_loaded_temporary_dic(cur_env)) {
1519                 if (js_temporary_dic_add(cur_env,
1520                                          wnnfns_norm ? WNN_DIC_ADD_NOR :
1521                                          WNN_DIC_ADD_REV) < 0) {
1522                         UNGCPRO;
1523                         return Qnil;
1524                 }
1525         }
1526         vmask |= WNN_ENV_MUHENKAN_LEARN_MASK;
1527         henv.muhenkan_flag = NILP(args[2]) ? WNN_DIC_RDONLY : WNN_DIC_RW;
1528         if (jl_set_henkan_env(wnnfns_buf[snum], vmask, &henv) < 0) {
1529                 UNGCPRO;
1530                 return Qnil;
1531         }
1532         UNGCPRO;
1533         return Qt;
1534 }
1535
1536 DEFUN("wnn-server-bmodify-dict-add", Fwnn_bmodify_dict_add, 3, MANY, 0, /*
1537 Add dictionary specified by BMODIFY-DICT-FILE-NAME, PRIORITY, DICT-FILE-MODE.
1538 Specify password files of dictionary and frequency PW1 if needed.
1539 */
1540       (int nargs, Lisp_Object * args))
1541 {
1542         struct gcpro gcpro1;
1543         int snum;
1544         int dic_no;
1545         struct wnn_env *cur_env;
1546         unsigned long vmask = 0;
1547         struct wnn_henkan_env henv;
1548         CHECK_STRING(args[0]);
1549         CHECK_INT(args[1]);
1550         if (!NILP(args[3]))
1551                 CHECK_STRING(args[3]);
1552         if ((snum = check_wnn_server_type()) == -1)
1553                 return Qnil;
1554         if (!wnnfns_buf[snum])
1555                 return Qnil;
1556         GCPRO1(*args);
1557         gcpro1.nvars = nargs;
1558         if (wnnfns_norm)
1559                 cur_env = wnnfns_env_norm[snum];
1560         else
1561                 cur_env = wnnfns_env_rev[snum];
1562         dic_no = js_get_autolearning_dic(cur_env, WNN_BUNSETSUGIRI_LEARNING);
1563         if (dic_no == WNN_NO_LEARNING) {
1564                 if ((dic_no = jl_dic_add(wnnfns_buf[snum],
1565                                          XSTRING_DATA(args[0]),
1566                                          0,
1567                                          wnnfns_norm ? WNN_DIC_ADD_NOR :
1568                                          WNN_DIC_ADD_REV, XINT(args[1]),
1569                                          WNN_DIC_RW, WNN_DIC_RW,
1570                                          NILP(args[3]) ? 0 :
1571                                          XSTRING_DATA(args[3]), 0, yes_or_no,
1572                                          puts2)) < 0) {
1573                         UNGCPRO;
1574                         return Qnil;
1575                 }
1576                 js_set_autolearning_dic(cur_env, WNN_BUNSETSUGIRI_LEARNING,
1577                                         dic_no);
1578         }
1579         if (!js_is_loaded_temporary_dic(cur_env)) {
1580                 if (js_temporary_dic_add(cur_env,
1581                                          wnnfns_norm ? WNN_DIC_ADD_NOR :
1582                                          WNN_DIC_ADD_REV) < 0) {
1583                         UNGCPRO;
1584                         return Qnil;
1585                 }
1586         }
1587         vmask |= WNN_ENV_BUNSETSUGIRI_LEARN_MASK;
1588         henv.bunsetsugiri_flag = NILP(args[2]) ? WNN_DIC_RDONLY : WNN_DIC_RW;
1589         if (jl_set_henkan_env(wnnfns_buf[snum], vmask, &henv) < 0) {
1590                 UNGCPRO;
1591                 return Qnil;
1592         }
1593         UNGCPRO;
1594         return Qt;
1595 }
1596
1597 DEFUN("wnn-server-set-last-is-first", Fwnn_last_is_first, 1, 1, 0,      /*
1598 For FI-Wnn.
1599 */
1600       (mode))
1601 {
1602         int snum;
1603         unsigned long vmask = 0;
1604         struct wnn_henkan_env henv;
1605         if ((snum = check_wnn_server_type()) == -1)
1606                 return Qnil;
1607         if (!wnnfns_buf[snum])
1608                 return Qnil;
1609         vmask |= WNN_ENV_LAST_IS_FIRST_MASK;
1610         henv.last_is_first_flag = NILP(mode) ? False : True;
1611         if (jl_set_henkan_env(wnnfns_buf[snum], vmask, &henv) < 0)
1612                 return Qnil;
1613         return Qt;
1614 }
1615
1616 DEFUN("wnn-server-set-complex-conv-mode", Fwnn_complex_conv, 1, 1, 0,   /*
1617 For FI-Wnn.
1618 */
1619       (mode))
1620 {
1621         int snum;
1622         unsigned long vmask = 0;
1623         struct wnn_henkan_env henv;
1624         if ((snum = check_wnn_server_type()) == -1)
1625                 return Qnil;
1626         if (!wnnfns_buf[snum])
1627                 return Qnil;
1628         vmask |= WNN_ENV_COMPLEX_CONV_MASK;
1629         henv.complex_flag = NILP(mode) ? False : True;
1630         if (jl_set_henkan_env(wnnfns_buf[snum], vmask, &henv) < 0)
1631                 return Qnil;
1632         return Qt;
1633 }
1634
1635 DEFUN("wnn-server-set-okuri-learn-mode", Fwnn_okuri_learn, 1, 1, 0,     /*
1636 For FI-Wnn.
1637 */
1638       (mode))
1639 {
1640         int snum;
1641         unsigned long vmask = 0;
1642         struct wnn_henkan_env henv;
1643         if ((snum = check_wnn_server_type()) == -1)
1644                 return Qnil;
1645         if (!wnnfns_buf[snum])
1646                 return Qnil;
1647         vmask |= WNN_ENV_OKURI_LEARN_MASK;
1648         henv.okuri_learn_flag = NILP(mode) ? False : True;
1649         if (jl_set_henkan_env(wnnfns_buf[snum], vmask, &henv) < 0)
1650                 return Qnil;
1651         return Qt;
1652 }
1653
1654 DEFUN("wnn-server-set-okuri-flag", Fwnn_okuri_flag, 1, 1, 0,    /*
1655 For FI-Wnn.
1656 */
1657       (lmode))
1658 {
1659         int snum, mode;
1660         unsigned long vmask = 0;
1661         struct wnn_henkan_env henv;
1662         CHECK_INT(lmode);
1663         mode = XINT(lmode);
1664         if ((snum = check_wnn_server_type()) == -1)
1665                 return Qnil;
1666         if (!wnnfns_buf[snum])
1667                 return Qnil;
1668         if (mode != WNN_OKURI_REGULATION &&
1669             mode != WNN_OKURI_NO && mode != WNN_OKURI_YES)
1670                 return Qnil;
1671         else
1672                 henv.okuri_flag = mode;
1673         vmask |= WNN_ENV_OKURI_MASK;
1674         if (jl_set_henkan_env(wnnfns_buf[snum], vmask, &henv) < 0)
1675                 return Qnil;
1676         return Qt;
1677 }
1678
1679 DEFUN("wnn-server-set-prefix-learn-mode", Fwnn_prefix_learn, 1, 1, 0,   /*
1680 For FI-Wnn.
1681 */
1682       (mode))
1683 {
1684         int snum;
1685         unsigned long vmask = 0;
1686         struct wnn_henkan_env henv;
1687         if ((snum = check_wnn_server_type()) == -1)
1688                 return Qnil;
1689         if (!wnnfns_buf[snum])
1690                 return Qnil;
1691         vmask |= WNN_ENV_PREFIX_LEARN_MASK;
1692         henv.prefix_learn_flag = NILP(mode) ? False : True;
1693         if (jl_set_henkan_env(wnnfns_buf[snum], vmask, &henv) < 0)
1694                 return Qnil;
1695         return Qt;
1696 }
1697
1698 DEFUN("wnn-server-set-prefix-flag", Fwnn_prefix_flag, 1, 1, 0,  /*
1699 For FI-Wnn.
1700 */
1701       (lmode))
1702 {
1703         int snum, mode;
1704         unsigned long vmask = 0;
1705         struct wnn_henkan_env henv;
1706         CHECK_INT(lmode);
1707         mode = XINT(lmode);
1708         if ((snum = check_wnn_server_type()) == -1)
1709                 return Qnil;
1710         if (!wnnfns_buf[snum])
1711                 return Qnil;
1712         if (mode != WNN_KANA_KOUHO && mode != WNN_KANJI_KOUHO)
1713                 return Qnil;
1714         else
1715                 henv.prefix_flag = mode;
1716         vmask |= WNN_ENV_PREFIX_MASK;
1717         if (jl_set_henkan_env(wnnfns_buf[snum], vmask, &henv) < 0)
1718                 return Qnil;
1719         return Qt;
1720 }
1721
1722 DEFUN("wnn-server-set-suffix-learn-mode", Fwnn_suffix_learn, 1, 1, 0,   /*
1723 For FI-Wnn.
1724 */
1725       (mode))
1726 {
1727         int snum;
1728         unsigned long vmask = 0;
1729         struct wnn_henkan_env henv;
1730         if ((snum = check_wnn_server_type()) == -1)
1731                 return Qnil;
1732         if (!wnnfns_buf[snum])
1733                 return Qnil;
1734         vmask |= WNN_ENV_SUFFIX_LEARN_MASK;
1735         henv.suffix_learn_flag = NILP(mode) ? False : True;
1736         if (jl_set_henkan_env(wnnfns_buf[snum], vmask, &henv) < 0)
1737                 return Qnil;
1738         return Qt;
1739 }
1740
1741 DEFUN("wnn-server-set-common-learn-mode", Fwnn_common_learn, 1, 1, 0,   /*
1742 For FI-Wnn.
1743 */
1744       (mode))
1745 {
1746         int snum;
1747         unsigned long vmask = 0;
1748         struct wnn_henkan_env henv;
1749         if ((snum = check_wnn_server_type()) == -1)
1750                 return Qnil;
1751         if (!wnnfns_buf[snum])
1752                 return Qnil;
1753         vmask |= WNN_ENV_COMMON_LAERN_MASK;
1754         henv.common_learn_flag = NILP(mode) ? False : True;
1755         if (jl_set_henkan_env(wnnfns_buf[snum], vmask, &henv) < 0)
1756                 return Qnil;
1757         return Qt;
1758 }
1759
1760 DEFUN("wnn-server-set-freq-func-mode", Fwnn_freq_func, 1, 1, 0, /*
1761 For FI-Wnn.
1762 */
1763       (lmode))
1764 {
1765         int snum, mode;
1766         unsigned long vmask = 0;
1767         struct wnn_henkan_env henv;
1768         CHECK_INT(lmode);
1769         mode = XINT(lmode);
1770         if ((snum = check_wnn_server_type()) == -1)
1771                 return Qnil;
1772         if (!wnnfns_buf[snum])
1773                 return Qnil;
1774         if (mode != 0 && mode != 1 && mode != 2 && mode != 3 && mode != 4)
1775                 return Qnil;
1776         else
1777                 henv.freq_func_flag = mode;
1778         vmask |= WNN_ENV_FREQ_FUNC_MASK;
1779         if (jl_set_henkan_env(wnnfns_buf[snum], vmask, &henv) < 0)
1780                 return Qnil;
1781         return Qt;
1782 }
1783
1784 DEFUN("wnn-server-set-numeric-mode", Fwnn_numeric, 1, 1, 0,     /*
1785 For FI-Wnn.
1786 */
1787       (lmode))
1788 {
1789         int snum, mode;
1790         unsigned long vmask = 0;
1791         struct wnn_henkan_env henv;
1792         CHECK_INT(lmode);
1793         mode = XINT(lmode);
1794         if ((snum = check_wnn_server_type()) == -1)
1795                 return Qnil;
1796         if (!wnnfns_buf[snum])
1797                 return Qnil;
1798         if (mode != WNN_NUM_KANSUUJI &&
1799             mode != WNN_NUM_KANOLD &&
1800             mode != WNN_NUM_HANCAN &&
1801             mode != WNN_NUM_ZENCAN &&
1802             mode != WNN_NUM_HAN && mode != WNN_NUM_ZEN && mode != WNN_NUM_KAN)
1803                 return Qnil;
1804         else
1805                 henv.numeric_flag = mode;
1806         vmask |= WNN_ENV_NUMERIC_MASK;
1807         if (jl_set_henkan_env(wnnfns_buf[snum], vmask, &henv) < 0)
1808                 return Qnil;
1809         return Qt;
1810 }
1811
1812 DEFUN("wnn-server-set-alphabet-mode", Fwnn_alphabet, 1, 1, 0,   /*
1813 For FI-Wnn.
1814 */
1815       (lmode))
1816 {
1817         int snum, mode;
1818         unsigned long vmask = 0;
1819         struct wnn_henkan_env henv;
1820         CHECK_INT(lmode);
1821         mode = XINT(lmode);
1822         if ((snum = check_wnn_server_type()) == -1)
1823                 return Qnil;
1824         if (!wnnfns_buf[snum])
1825                 return Qnil;
1826         if (mode != WNN_ALP_HAN && mode != WNN_ALP_ZEN)
1827                 return Qnil;
1828         else
1829                 henv.alphabet_flag = mode;
1830         vmask |= WNN_ENV_ALPHABET_MASK;
1831         if (jl_set_henkan_env(wnnfns_buf[snum], vmask, &henv) < 0)
1832                 return Qnil;
1833         return Qt;
1834 }
1835
1836 DEFUN("wnn-server-set-symbol-mode", Fwnn_symbol, 1, 1, 0,       /*
1837 For FI-Wnn.
1838 */
1839       (lmode))
1840 {
1841         int snum, mode;
1842         unsigned long vmask = 0;
1843         struct wnn_henkan_env henv;
1844         CHECK_INT(lmode);
1845         mode = XINT(lmode);
1846         if ((snum = check_wnn_server_type()) == -1)
1847                 return Qnil;
1848         if (!wnnfns_buf[snum])
1849                 return Qnil;
1850         if (mode != WNN_KIG_HAN && mode != WNN_KIG_JIS && mode != WNN_KIG_ASC)
1851                 return Qnil;
1852         else
1853                 henv.symbol_flag = mode;
1854         vmask |= WNN_ENV_SYMBOL_MASK;
1855         if (jl_set_henkan_env(wnnfns_buf[snum], vmask, &henv) < 0)
1856                 return Qnil;
1857         return Qt;
1858 }
1859
1860 DEFUN("wnn-server-set-yuragi-mode", Fwnn_yuragi, 1, 1, 0,       /*
1861 For FI-Wnn.
1862 */
1863       (mode))
1864 {
1865         int snum;
1866         unsigned long vmask = 0;
1867         struct wnn_henkan_env henv;
1868         if ((snum = check_wnn_server_type()) == -1)
1869                 return Qnil;
1870         if (!wnnfns_buf[snum])
1871                 return Qnil;
1872         vmask |= WNN_ENV_YURAGI_MASK;
1873         henv.yuragi_flag = NILP(mode) ? False : True;
1874         if (jl_set_henkan_env(wnnfns_buf[snum], vmask, &henv) < 0)
1875                 return Qnil;
1876         return Qt;
1877 }
1878
1879 DEFUN("wnn-reset-previous-info", Fwnn_reset_prev, 0, 0, 0,      /*
1880 For FI-Wnn.
1881 */
1882       ())
1883 {
1884         int snum;
1885         if ((snum = check_wnn_server_type()) == -1)
1886                 return Qnil;
1887         if (!wnnfns_buf[snum])
1888                 return Qnil;
1889         if (jl_reset_prev_bun(wnnfns_buf[snum]) < 0)
1890                 return Qnil;
1891         return Qt;
1892 }
1893 #endif                          /* Wnn6 */
1894
1895 DEFUN("wnn-server-version", Fwnn_version, 0, 0, 0,      /*
1896 Returns Wnn server version ID.
1897 */
1898       ())
1899 {
1900         int snum;
1901         int serv;
1902         int libv;
1903         struct wnn_env *cur_env;
1904         if ((snum = check_wnn_server_type()) == -1)
1905                 return Qnil;
1906         if (!wnnfns_buf[snum])
1907                 return Qnil;
1908         if (wnnfns_norm)
1909                 cur_env = wnnfns_env_norm[snum];
1910         else
1911                 cur_env = wnnfns_env_rev[snum];
1912         if (js_version(cur_env->js_id, &serv, &libv) < 0)
1913                 return Qnil;
1914         return make_int(serv);
1915 }
1916
1917 DEFUN("wnn-server-hinsi-number", Fwnn_hinsi_number, 1, 1, 0,    /*
1918 For Wnn.
1919 */
1920       (name))
1921 {
1922         w_char w_buf[256];
1923         int no;
1924         int snum;
1925         CHECK_STRING(name);
1926         if ((snum = check_wnn_server_type()) == -1)
1927                 return Qnil;
1928         if (!wnnfns_buf[snum])
1929                 return Qnil;
1930         m2w(XSTRING_DATA(name), w_buf);
1931         if ((no = jl_hinsi_number(wnnfns_buf[snum], w_buf)) < 0)
1932                 return Qnil;
1933         return make_int(no);
1934 }
1935
1936 void syms_of_mule_wnn(void)
1937 {
1938         DEFSUBR(Fwnn_open);
1939         DEFSUBR(Fwnn_close);
1940         DEFSUBR(Fwnn_dict_add);
1941         DEFSUBR(Fwnn_dict_delete);
1942         DEFSUBR(Fwnn_dict_list);
1943         DEFSUBR(Fwnn_dict_comment);
1944         DEFSUBR(Fwnn_set_rev);
1945         DEFSUBR(Fwnn_begin_henkan);
1946         DEFSUBR(Fwnn_zenkouho);
1947         DEFSUBR(Fwnn_get_zenkouho);
1948         DEFSUBR(Fwnn_zenkouho_bun);
1949         DEFSUBR(Fwnn_zenkouho_suu);
1950         DEFSUBR(Fwnn_dai_top);
1951         DEFSUBR(Fwnn_dai_end);
1952         DEFSUBR(Fwnn_kakutei);
1953         DEFSUBR(Fwnn_bunsetu_henkou);
1954         DEFSUBR(Fwnn_inspect);
1955         DEFSUBR(Fwnn_quit_henkan);
1956         DEFSUBR(Fwnn_bunsetu_kanji);
1957         DEFSUBR(Fwnn_bunsetu_yomi);
1958         DEFSUBR(Fwnn_bunsetu_suu);
1959         DEFSUBR(Fwnn_hindo_update);
1960         DEFSUBR(Fwnn_word_toroku);
1961         DEFSUBR(Fwnn_word_sakujo);
1962         DEFSUBR(Fwnn_word_use);
1963         DEFSUBR(Fwnn_word_info);
1964         DEFSUBR(Fwnn_hindo_set);
1965         DEFSUBR(Fwnn_dict_search);
1966         DEFSUBR(Fwnn_dict_save);
1967         DEFSUBR(Fwnn_get_param);
1968         DEFSUBR(Fwnn_set_param);
1969         DEFSUBR(Fwnn_get_msg);
1970         DEFSUBR(Fwnn_fuzokugo_set);
1971         DEFSUBR(Fwnn_fuzokugo_get);
1972         DEFSUBR(Fwnn_isconnect);
1973         DEFSUBR(Fwnn_hinsi_dicts);
1974         DEFSUBR(Fwnn_hinsi_list);
1975         DEFSUBR(Fwnn_hinsi_name);
1976         DEFSUBR(Fwnn_hinsi_number);
1977 #ifdef  WNN6
1978         DEFSUBR(Fwnn_fisys_dict_add);
1979         DEFSUBR(Fwnn_fiusr_dict_add);
1980         DEFSUBR(Fwnn_notrans_dict_add);
1981         DEFSUBR(Fwnn_bmodify_dict_add);
1982         DEFSUBR(Fwnn_last_is_first);
1983         DEFSUBR(Fwnn_complex_conv);
1984         DEFSUBR(Fwnn_okuri_learn);
1985         DEFSUBR(Fwnn_okuri_flag);
1986         DEFSUBR(Fwnn_prefix_learn);
1987         DEFSUBR(Fwnn_prefix_flag);
1988         DEFSUBR(Fwnn_suffix_learn);
1989         DEFSUBR(Fwnn_common_learn);
1990         DEFSUBR(Fwnn_freq_func);
1991         DEFSUBR(Fwnn_numeric);
1992         DEFSUBR(Fwnn_alphabet);
1993         DEFSUBR(Fwnn_symbol);
1994         DEFSUBR(Fwnn_yuragi);
1995         DEFSUBR(Fwnn_reset_prev);
1996 #endif                          /* Wnn6 */
1997         DEFSUBR(Fwnn_version);
1998
1999         defsymbol(&Qjserver, "jserver");
2000         defsymbol(&Qcserver, "cserver");
2001         /* defsymbol (&Qtserver, "tserver"); */
2002         defsymbol(&Qkserver, "kserver");
2003
2004         defsymbol(&Qwnn_no_uniq, "wnn-no-uniq");
2005         defsymbol(&Qwnn_uniq, "wnn-uniq");
2006         defsymbol(&Qwnn_uniq_kanji, "wnn-uniq-kanji");
2007         defsymbol(&Qwnn_n, "wnn_n");
2008         defsymbol(&Qwnn_nsho, "wnn_nsho");
2009         defsymbol(&Qwnn_hindo, "wnn_hindo");
2010         defsymbol(&Qwnn_len, "wnn_len");
2011         defsymbol(&Qwnn_jiri, "wnn_jiri");
2012         defsymbol(&Qwnn_flag, "wnn_flag");
2013         defsymbol(&Qwnn_jisho, "wnn_jisho");
2014         defsymbol(&Qwnn_sbn, "wnn_sbn");
2015         defsymbol(&Qwnn_dbn_len, "wnn_dbn_len");
2016         defsymbol(&Qwnn_sbn_cnt, "wnn_sbn_cnt");
2017         defsymbol(&Qwnn_suuji, "wnn_suuji");
2018         defsymbol(&Qwnn_kana, "wnn_kana");
2019         defsymbol(&Qwnn_eisuu, "wnn_eisuu");
2020         defsymbol(&Qwnn_kigou, "wnn_kigou");
2021         defsymbol(&Qwnn_toji_kakko, "wnn_toji_kakko");
2022         defsymbol(&Qwnn_fuzokogo, "wnn_fuzokogo");
2023         defsymbol(&Qwnn_kaikakko, "wnn_kaikakko");
2024 }
2025
2026 void reinit_vars_of_mule_wnn(void)
2027 {
2028         int i;
2029
2030         for (i = 0; i < NSERVER; i++) {
2031                 wnnfns_buf[i] = (struct wnn_buf *)0;
2032                 wnnfns_env_norm[i] = (struct wnn_env *)0;
2033                 wnnfns_env_rev[i] = (struct wnn_env *)0;
2034         }
2035 }
2036
2037 void vars_of_mule_wnn(void)
2038 {
2039         reinit_vars_of_mule_wnn();
2040
2041         DEFVAR_INT("lb-sisheng", &lb_sisheng    /*
2042 Leading character for Sisheng.
2043                                                  */ );
2044         DEFVAR_LISP("wnn-server-type", &Vwnn_server_type        /*
2045 *jserver, cserver ..
2046                                                                  */ );
2047         DEFVAR_LISP("cwnn-zhuyin", &Vcwnn_zhuyin        /*
2048 *pinyin or zhuyin
2049                                                          */ );
2050         DEFVAR_LISP("wnnenv-sticky", &Vwnnenv_sticky    /*
2051 *If non-nil, make environment sticky
2052                                                          */ );
2053         DEFVAR_LISP("wnn-uniq-level", &Vwnn_uniq_level  /*
2054 *Uniq level
2055                                                          */ );
2056
2057         Vwnn_server_type = Qjserver;
2058         Vcwnn_zhuyin = Qnil;
2059         Vwnnenv_sticky = Qnil;
2060
2061         Vwnn_uniq_level = Qwnn_uniq;
2062
2063         Fprovide(intern("wnn"));
2064 }
2065
2066 void w2m(w_char * wp, unsigned char *mp, unsigned char lb)
2067 {
2068         w_char wc;
2069         w_char pzy[10];
2070         int i, len;
2071
2072         while ((wc = *wp++) != 0) {
2073                 switch (wc & 0x8080) {
2074                 case 0x80:
2075                         if (EQ(Vwnn_server_type, Qcserver)) {
2076                                 len = cwnn_yincod_pzy(pzy, wc,
2077                                                       NILP(Vcwnn_zhuyin)
2078                                                       ? CWNN_PINYIN
2079                                                       : CWNN_ZHUYIN);
2080                                 for (i = 0; i < len; i++) {
2081                                         if (pzy[i] & 0x80) {
2082                                                 *mp++ = PRE_LEADING_BYTE_PRIVATE_1;     /* #### Not sure about this one... */
2083                                                 *mp++ = lb_sisheng;
2084                                         }
2085                                         *mp++ = pzy[i];
2086                                 }
2087                         } else {
2088                                 *mp++ = LEADING_BYTE_KATAKANA_JISX0201;
2089                                 *mp++ = (wc & 0xff);
2090                         }
2091                         break;
2092                 case 0x8080:
2093                         *mp++ = lb;
2094                         *mp++ = (wc & 0xff00) >> 8;
2095                         *mp++ = wc & 0x00ff;
2096                         break;
2097                 case 0x8000:
2098                         if (lb == LEADING_BYTE_JAPANESE_JISX0208)
2099                                 *mp++ = LEADING_BYTE_JAPANESE_JISX0212;
2100                         else if (lb == LEADING_BYTE_CHINESE_BIG5_1)
2101                                 *mp++ = LEADING_BYTE_CHINESE_BIG5_2;
2102                         else
2103                                 *mp++ = lb;
2104                         *mp++ = (wc & 0xff00) >> 8;
2105                         *mp++ = (wc & 0x00ff) | 0x80;
2106                         break;
2107                 default:
2108                         *mp++ = wc & 0x00ff;
2109                         break;
2110                 }
2111         }
2112         *mp = 0;
2113 }
2114
2115 void m2w(unsigned char *mp, w_char * wp)
2116 {
2117         unsigned int ch;
2118
2119         while ((ch = *mp++) != 0) {
2120                 if (BUFBYTE_LEADING_BYTE_P(ch)) {
2121                         switch (ch) {
2122                         case LEADING_BYTE_KATAKANA_JISX0201:
2123                                 *wp++ = *mp++;
2124                                 break;
2125                         case LEADING_BYTE_LATIN_JISX0201:
2126                                 *wp++ = *mp++ & 0x7F;
2127                                 break;
2128                         case LEADING_BYTE_JAPANESE_JISX0208_1978:
2129                         case LEADING_BYTE_CHINESE_GB2312:
2130                         case LEADING_BYTE_JAPANESE_JISX0208:
2131                         case LEADING_BYTE_KOREAN_KSC5601:
2132                                 /* case LEADING_BYTE_TW: */
2133                                 ch = *mp++;
2134                                 *wp++ = (ch << 8) | *mp++;
2135                                 break;
2136                         case LEADING_BYTE_JAPANESE_JISX0212:
2137                                 ch = *mp++;
2138                                 *wp++ = (ch << 8) | (*mp++ & 0x7f);
2139                                 break;
2140                         case PRE_LEADING_BYTE_PRIVATE_1:        /* #### Not sure about this one... */
2141                                 ch = *mp++;
2142                                 if (ch == lb_sisheng)
2143                                         *wp++ = 0x8e80 | *mp++;
2144                                 else
2145                                         mp++;
2146                                 break;
2147                         default:        /* ignore this character */
2148                                 mp += REP_BYTES_BY_FIRST_BYTE(ch) - 1;
2149                         }
2150                 } else {
2151                         *wp++ = ch;
2152                 }
2153         }
2154         *wp = 0;
2155 }
2156
2157 void w2y(w_char * w)
2158 {
2159         letter pbuf[5000], ybuf[5000];
2160         unsigned int *pin;
2161         w_char *y;
2162         int len;
2163
2164         pin = pbuf;
2165         y = w;
2166         while (1) {
2167                 if (*w == 0) {
2168                         *pin = 0;
2169                         break;
2170                 } else
2171                         *pin = *w;
2172                 w++;
2173                 pin++;
2174         }
2175         len = cwnn_pzy_yincod(ybuf, pbuf,
2176                               NILP(Vcwnn_zhuyin) ? CWNN_PINYIN : CWNN_ZHUYIN);
2177         if (len <= 0)
2178                 return;
2179
2180         pin = ybuf;
2181         while (1) {
2182                 if (*pin == 0 || len == 0) {
2183                         *y = 0;
2184                         break;
2185                 }
2186                 *y = *pin;
2187                 y++;
2188                 pin++;
2189                 len--;
2190         }
2191 }
2192
2193 void c2m(unsigned char *cp, unsigned char *mp, unsigned char lb)
2194 {
2195         unsigned char ch;
2196         while ((ch = *cp) != 0) {
2197                 if (ch & 0x80) {
2198                         *mp++ = lb;
2199                         *mp++ = *cp++;
2200                 }
2201                 *mp++ = *cp++;
2202         }
2203         *mp = 0;
2204 }
2205
2206 static int dai_end(int no, int server)
2207 {
2208         for (no++; no < jl_bun_suu(wnnfns_buf[server])
2209              && !jl_dai_top(wnnfns_buf[server], no); no++) ;
2210         return (no);
2211 }
2212
2213 static int yes_or_no(unsigned char *s)
2214 {
2215         unsigned char mbuf[512];
2216         unsigned char lb;
2217         int len;
2218         int snum;
2219         if ((snum = check_wnn_server_type()) == -1)
2220                 return 0;
2221         lb = lb_wnn_server_type[snum];
2222         /* if no message found, create file without query */
2223         /* if (wnn_msg_cat->msg_bd == 0) return 1; */
2224         if (*s == 0)
2225                 return 1;
2226         c2m(s, mbuf, lb);
2227         /* truncate "(Y/N)" */
2228         for (len = 0; (mbuf[len]) && (len < 512); len++) ;
2229         for (; (mbuf[len] != '(') && (len > 0); len--) ;
2230         {
2231                 Lisp_Object yes, str;
2232                 struct gcpro gcpro1;
2233
2234                 str = make_string(mbuf, len);
2235                 GCPRO1(str);
2236                 yes = call1(Qyes_or_no_p, str);
2237                 UNGCPRO;
2238                 if (NILP(yes))
2239                         return 0;
2240                 else
2241                         return (1);
2242         }
2243 }
2244
2245 static void puts2(char *s)
2246 {
2247 #if 0                           /* jhod: We don't really need this echoed... */
2248 #if 0
2249         Lisp_Object args[1];
2250         char mbuf[512];
2251         unsigned char lb;
2252         extern Lisp_Object Fmessage();
2253         int snum;
2254         if ((snum = check_wnn_server_type()) == -1)
2255                 return;
2256         lb = lb_wnn_server_type[snum];
2257         c2m(s, mbuf, lb);
2258         args[0] = make_string(mbuf, strlen(mbuf));
2259         Fmessage(1, args);
2260 #else
2261         message("%s", s);
2262 #endif
2263 #endif
2264 }
2265
2266 int check_wnn_server_type(void)
2267 {
2268         if (EQ(Vwnn_server_type, Qjserver)) {
2269                 return WNNSERVER_J;
2270         } else if (EQ(Vwnn_server_type, Qcserver)) {
2271                 return WNNSERVER_C;
2272         }
2273         /* else if (Vwnn_server_type == Qtserver)
2274            {
2275            return WNNSERVER_T;
2276            } */
2277         else if (EQ(Vwnn_server_type, Qkserver)) {
2278                 return WNNSERVER_K;
2279         } else
2280                 return -1;
2281 }