git.chise.org Git - chise/xemacs-chise.git-/blob - src/mule-wnnfns.c

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