;;; egg/wnnrpc.el --- WNN Support (low level interface) in Egg
;;;                   Input Method Architecture

;; Copyright (C) 1997, 1998 Mule Project, Powered by Electrotechnical
;; Laboratory, JAPAN.
;; Project Leader: Satoru Tomura <tomura@etl.go.jp>

;; Author: NIIBE Yutaka <gniibe@mri.co.jp>
;;         KATAYAMA Yoshio <kate@pfu.co.jp> ; Korean, Chinese support.
;;
;; Maintainer: NIIBE Yutaka <gniibe@mri.co.jp>

;; This file will be part of GNU Emacs (in future).

;; EGG is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.

;; EGG is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING.  If not, write to the
;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.

;;; Commentary:

;;; Code:

(eval-when-compile
  (require 'egg-com)
  ;; (load-library "egg/wnn")
  (defmacro wnn-const (c)
    "Macro for WNN constants."
    (cond ((eq c 'JS_VERSION)             0)
	  ((eq c 'JS_OPEN)                1)
          ((eq c 'JS_CLOSE)               3)
          ((eq c 'JS_CONNECT)             5)
          ((eq c 'JS_DISCONNECT)          6)
          ((eq c 'JS_ENV_EXIST)           7)
          ((eq c 'JS_ENV_STICKY)          8)
          ((eq c 'JS_ENV_UNSTICKY)        9)
          ((eq c 'JS_KANREN)             17)
          ((eq c 'JS_KANTAN_SHO)         18)
          ((eq c 'JS_KANZEN_SHO)         19)
          ((eq c 'JS_KANTAN_DAI)         20)
          ((eq c 'JS_KANZEN_DAI)         21)
          ((eq c 'JS_HINDO_SET)          24)
          ((eq c 'JS_DIC_ADD)            33)
          ((eq c 'JS_DIC_DELETE)         34)
          ((eq c 'JS_DIC_USE)            35)
          ((eq c 'JS_DIC_LIST)           36)
          ((eq c 'JS_DIC_INFO)           37)
          ((eq c 'JS_FUZOKUGO_SET)       41)
          ((eq c 'JS_FUZOKUGO_GET)       48)
          ((eq c 'JS_WORD_ADD)           49)
          ((eq c 'JS_WORD_DELETE)        50)
          ((eq c 'JS_WORD_SEARCH)        51)
          ((eq c 'JS_WORD_SEARCH_BY_ENV) 52)
          ((eq c 'JS_WORD_INFO)          53)
          ((eq c 'JS_WORD_COMMENT_SET)   54)
          ((eq c 'JS_PARAM_SET)          65)
          ((eq c 'JS_PARAM_GET)          66)
          ((eq c 'JS_MKDIR)              81)
          ((eq c 'JS_ACCESS)             82)
          ((eq c 'JS_WHO)                83)
          ((eq c 'JS_ENV_LIST)           85)
          ((eq c 'JS_FILE_LIST_ALL)      86)
          ((eq c 'JS_DIC_LIST_ALL)       87)
          ((eq c 'JS_FILE_READ)          97)
          ((eq c 'JS_FILE_WRITE)         98)
          ((eq c 'JS_FILE_SEND)          99)
          ((eq c 'JS_FILE_RECEIVE)      100)
          ((eq c 'JS_HINDO_FILE_CREATE) 101)
          ((eq c 'JS_DIC_FILE_CREATE)   102)
          ((eq c 'JS_FILE_REMOVE)       103)
          ((eq c 'JS_FILE_LIST)         104)
          ((eq c 'JS_FILE_INFO)         105)
          ((eq c 'JS_FILE_LOADED)       106)
          ((eq c 'JS_FILE_LOADED_LOCAL) 107)
          ((eq c 'JS_FILE_DISCARD)      108)
          ((eq c 'JS_FILE_COMMENT_SET)  109)
          ((eq c 'JS_FILE_PASSWORD)     110)
          ((eq c 'JS_FILE_STAT)         111)
          ((eq c 'JS_KILL)              112)
          ((eq c 'JS_HINSI_LIST)        114)
          ((eq c 'JS_HINSI_NAME)        115)
          ((eq c 'JS_HINSI_NUMBER)      116)
          ((eq c 'JS_HINSI_DICTS)       117)
          ((eq c 'JS_HINSI_TABLE_SET)   118)

	  ((eq c 'JLIB_VERSION) 16387)	; 0x4003

	  ((eq c 'WNN_REV_DICT) 3)
	  ((eq c 'WNN_VECT_NO)      -1)
	  ((eq c 'WNN_VECT_BUNSETSU) 2)
	  ((eq c 'WNN_VECT_KANREN) 0)
	  ((eq c 'WNN_VECT_KANZEN) 1)
	  ((eq c 'WNN_VECT_KANTAN) 1)
	  ((eq c 'WNN_MAX_ENV_OF_A_CLIENT) 32)
	  ((eq c 'WNN_MAX_DIC_OF_AN_ENV)   30)
	  ((eq c 'WNN_MAX_FILE_OF_AN_ENV)  60))))

(defconst wnnrpc-error-message
  '(("Japanese" .
     [
      nil
      "$B%U%!%$%k$,B8:_$7$^$;$s(B"
      nil
      "$B%a%b%j(B allocation $B$G<:GT$7$^$7$?(B"
      nil
      "$B<-=q$G$O$"$j$^$;$s(B"
      "$BIQEY%U%!%$%k$G$O$"$j$^$;$s(B"
      "$BIUB08l%U%!%$%k$G$O$"$j$^$;$s(B"
      nil
      "$B<-=q%F!<%V%k$,0lGU$G$9(B"
      "$BIQEY%U%!%$%k$,;XDj$5$l$?<-=q$NIQEY%U%!%$%k$G$O$"$j$^$;$s(B"
      nil
      nil
      nil
      nil
      nil
      "$B%U%!%$%k$,%*!<%W%s$G$-$^$;$s(B"
      "$B@5$7$$IQEY%U%!%$%k$G$O$"$j$^$;$s(B"
      "$B@5$7$$IUB08l%U%!%$%k$G$O$"$j$^$;$s(B"
      "$BIUB08l$N8D?t(B, $B%Y%/%?D9$5$J$I$,B?2a$.$^$9(B"
      "$B$=$NHV9f$N<-=q$O;H$o$l$F$$$^$;$s(B"
      nil
      nil
      nil
      "$BIUB08l%U%!%$%k$NFbMF$,@5$7$/$"$j$^$;$s(B"
      "$B5?;wIJ;lHV9f$,0[>o$G$9(B(hinsi.data $B$,@5$7$/$"$j$^$;$s(B)"
      "$BL$Dj5A$NIJ;l$,A0C<IJ;l$H$7$FDj5A$5$l$F$$$^$9(B"
      "$BIUB08l%U%!%$%k$,FI$_9~$^$l$F$$$^$;$s(B"
      nil
      nil
      "$B<-=q$N%(%$%s%H%j$,B?2a$.$^$9(B"
      "$BJQ49$7$h$&$H$9$kJ8;zNs$,D92a$.$^$9(B"
      "$BIUB08l2r@ONN0h$,ITB-$7$F$$$^$9(B"
      nil
      "$B<!8uJdNN0h$,ITB-$7$F$$$^$9(B"
      "$B8uJd$,(B 1 $B$D$b:n$l$^$;$s$G$7$?(B"
      nil
      nil
      nil
      nil
      "$BFI$_$,D92a$.$^$9(B"
      "$B4A;z$,D92a$.$^$9(B"
      "$B;XDj$5$l$?<-=q$OEPO?2DG=$G$O$"$j$^$;$s(B"
      "$BFI$_$ND9$5$,(B 0 $B$G$9(B"
      "$B;XDj$5$l$?<-=q$O5U0z$-2DG=$G$O$"$j$^$;$s(B"
      "$B%j!<%I%*%s%j!<$N<-=q$KEPO?(B/$B:o=|$7$h$&$H$7$^$7$?(B"
      "$B4D6-$KB8:_$7$J$$<-=q$KEPO?$7$h$&$H$7$^$7$?(B"
      nil
      nil
      "$B%j!<%I%*%s%j!<$NIQEY$rJQ99$7$h$&$H$7$^$7$?(B"
      "$B;XDj$5$l$?C18l$,B8:_$7$^$;$s(B"
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      "$B%a%b%j(B allocation $B$G<:GT$7$^$7$?(B"
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      "$B2?$+$N%(%i!<$,5/$3$j$^$7$?(B"
      "$B%P%0$,H/@8$7$F$$$kLOMM$G$9(B"
      "$B%5!<%P$,;`$s$G$$$^$9(B"
      "allocation $B$K<:GT$7$^$7$?(B"
      "$B%5!<%P$H@\B3$G$-$^$;$s$G$7$?(B"
      "$BDL?.%W%m%H%3%k$N%P!<%8%g%s$,9g$C$F$$$^$;$s(B"
      "$B%/%i%$%"%s%H$N@8@.$7$?4D6-$G$O$"$j$^$;$s(B"
      nil
      nil
      nil
      nil
      nil
      "$B%G%#%l%/%H%j$r:n$k$3$H$,$G$-$^$;$s(B"
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      "$B%U%!%$%k$rFI$_9~$`$3$H$,$G$-$^$;$s(B"
      "$B%U%!%$%k$r=q$-=P$9$3$H$,$G$-$^$;$s(B"
      "$B%/%i%$%"%s%H$NFI$_9~$s$@%U%!%$%k$G$O$"$j$^$;$s(B"
      "$B$3$l0J>e%U%!%$%k$rFI$_9~$`$3$H$,$G$-$^$;$s(B"
      "$B%Q%9%o!<%I$,4V0c$C$F$$$^$9(B"
      "$B%U%!%$%k$,FI$_9~$^$l$F$$$^$9(B"
      "$B%U%!%$%k$,:o=|$G$-$^$;$s(B"
      "$B%U%!%$%k$,:n@.=PMh$^$;$s(B"
      "WNN $B$N%U%!%$%k$G$"$j$^$;$s(B"
      "$B%U%!%$%k$N(B inode $B$H(B FILE_UNIQ $B$r0lCW$5$;$k;v$,$G$-$^$;$s(B"
      "$BIJ;l%U%!%$%k$,Bg$-2a$.$^$9(B"
      "$BIJ;l%U%!%$%k$,Bg$-2a$.$^$9(B"
      "$BIJ;l%U%!%$%k$,B8:_$7$^$;$s(B"
      "$BIJ;l%U%!%$%k$NFbMF$,4V0c$C$F$$$^$9(B"
      nil
      "$BIJ;l%U%!%$%k$,FI$_9~$^$l$F$$$^$;$s(B"
      "$BIJ;lL>$,4V0c$C$F$$$^$9(B"
      "$BIJ;lHV9f$,4V0c$C$F$$$^$9(B"
      nil
      "$B$=$NA`:n$O%5%]!<%H$5$l$F$$$^$;$s(B"
      "$B%Q%9%o!<%I$NF~$C$F$$$k%U%!%$%k$,%*!<%W%s$G$-$^$;$s(B"
      "uumrc $B%U%!%$%k$,B8:_$7$^$;$s(B"
      "uumrc $B%U%!%$%k$N7A<0$,8m$C$F$$$^$9(B"
      "$B$3$l0J>e4D6-$r:n$k$3$H$O$G$-$^$;$s(B"
      "$B$3$N%/%i%$%"%s%H$,FI$_9~$s$@%U%!%$%k$G$"$j$^$;$s(B"
      "$B<-=q$KIQEY%U%!%$%k$,$D$$$F$$$^$;$s(B"
      "$B%Q%9%o!<%I$N%U%!%$%k$,:n@.=PMh$^$;$s(B"
      ])
    ("Chinese-GB" .
     [
      nil
      "$AND<~2;4fTZ(B"
      nil
      "$ADZ4f(Balloc$AJ'0\(B"
      nil
      "$A2;JGWV5d(B"
      "$A2;JGF56HND<~(B"
      "$A2;JGND7(ND<~(B"
      nil
      "$AWV5d1m8qBz(B"
      "$AF56HND<~#:2;JGV86(5DWV5d5DF56HND<~(B"
      nil
      nil
      nil
      nil
      nil
      "$AND<~2;D\4r?*(B"
      "$A2;JGU}H75DF56HND<~(B"
      "$A2;JGU}H75DND7(ND<~(B"
      "$A8=JtSo5D8vJ}!"OrA?3$6H5H3,9}(B"
      "$AUb8v:EBk5DWV5d!"C;SPJ9SC(B"
      nil
      nil
      nil
      "$AND7(ND<~5DDZH]2;U}H7(B"
      "$APiDb4JPT:EBkRl3#(Bcixing.data$A2;U}H7(B"
      "$AN46(Re5D4JPT!"6(ReAKG06K4JPT(B"
      "$AND7(ND<~2;D\6AH!(B"
      nil
      nil
      "$AWV5d5DOnJ}3,9}(B"
      "$A1d;;:sWV7{4.5D3$6H3,9}(B"
      "$A8=JtSo=bNvSr2;9;(B"
      nil
      "$A4N:n29Sr2;9;(B"
      "$A:n29(B 1$A8vR2C;SP(B"
      nil
      nil
      nil
      nil
      "$A6ARt3$6H3,9}(B"
      "$A::WV3$6H3,9}(B"
      "$AV86(5DWV5d!"2;D\5GB<(B"
      "$A6ARt5D3$6HJG(B0"
      "$AV86(5DWV5d!"2;D\Df2i(B"
      "$AV;6A5DWV5d!"5GB<(B/$AO{3}AK(B"
      "$A;7>3VP2;4fTZ5DWV5d!"5GB<AK(B"
      nil
      nil
      "$AV;6A5DF56H!"1d8|AK(B"
      "$AV86(5D5%WV2;4fTZ(B"
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      "$ADZ4f(Balloc$AJ'0\(B"
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      "$ASP3v4m7"Iz(B"
      "$A:COsSP#b#u#g7"Iz(B"
      "server$AK@AK(B"
      "alloc$AJ'0\AK(B"
      "$A2;D\:M(Bserver$AA,=S(B"
      "$AM(PE9f3L5D0f1>2;7{(B"
      "$A2;JG#c#W#n#nSC;'Iz3I5D;7>3(B"
      nil
      nil
      nil
      nil
      nil
      "$AWSD?B<2;D\44=((B"
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      "$AND<~2;D\6AH!(B"
      "$AND<~2;D\P43v(B"
      "$A2;JG#c#W#n#nSC;'?I6AH!5DND<~(B"
      "$ARTIO5DND<~2;D\6AH!(B"
      "password$A2;6T(B"
      "$AND<~U}TZ6AH!(B"
      "$AND<~2;D\O{3}(B"
      "$AND<~C;SP44=(3v@4(B"
      "$A2;JG#c#W#n#n5DND<~(B"
      "$AND<~5D(BI-node$A:M(BFILE_UNIQ$A2;D\R;VB(B"
      "$A4JPTND<~L+4s(B"
      "$A4JPTND<~L+4s(B"
      "$A4JPTND<~2;4fTZ(B"
      "$A4JPTND<~5DDZH]2;6T(B"
      nil
      "$A4JPTND<~2;D\6AH!(B"
      "$A4JPTC{2;6T(B"
      "$A4JPT:EBk2;6T(B"
      nil
      "$AUb8v2YWw2;V'3V(B"
      "password$A5DJdHkND<~2;D\4r?*(B"
      "uumrc$AND<~2;4fTZ(B"
      "uumrc$AND<~5DPNJ=4mNs(B"
      "$ARTIO;7>32;D\44=((B"
      "$AUb8v#c#W#n#nSC;'!"6AH!5DND<~C;SP(B"
      "$AWV5d5DF56HND<~C;SP(B"
      "password$A5DND<~C;SP44=(3v@4(B"
      ])
    ("Chinese-CNS" .
     [
      nil
      "$(GEFG5DbGtGc(B"
      nil
      "$(GDyGt(Balloc$(GFBZu(B"
      nil
      "$(GDbQRGsL((B"
      "$(GDbQRs"PyEFG5(B"
      "$(GDbQREFNNEFG5(B"
      nil
      "$(GGsL(OPV*iH(B"
      "$(Gs"PyEFG5!3DbQRQ@LyN{GsL(N{s"PyEFG5(B"
      nil
      nil
      nil
      nil
      nil
      "$(GEFG5DbWdFTbd(B"
      "$(GDbQRF_m}N{s"PyEFG5(B"
      "$(GDbQRF_m}N{EFNNEFG5(B"
      "$(GOazhk#N{T6m0!#GWbXO[Pya+b>g4(B"
      "$(G]UT6f@n#N{GsL(!#JtH4KpFn(B"
      nil
      nil
      nil
      "$(GEFNNEFG5N{DyU)DbF_m}(B"
      "$(Gapsib$MLf@n#\,Z&(Bcixing.data$(GDbF_m}(B"
      "$(GF\LyexN{b$ML!#LyexD'P)j&b$ML(B"
      "$(GEFNNEFG5DbWd{tL=(B"
      nil
      nil
      "$(GGsL(N{bzm0b>g4(B"
      "$(G|H_PG[Gs\JHkN{O[Pyb>g4(B"
      "$(GOazhk#fXN5YQDbY\(B"
      nil
      "$(GH9OlfPYQDbY\(B"
      "$(GOlfP(B 1$(GT6D>JtH4(B"
      nil
      nil
      nil
      nil
      "$(G{tSvO[Pyb>g4(B"
      "$(GiGGsO[Pyb>g4(B"
      "$(GQ@LyN{GsL(!#DbWd`trg(B"
      "$(G{tSvN{O[PyQR(B0"
      "$(GQ@LyN{GsL(!#DbWdXKQg(B"
      "$(GF7{tN{GsL(!#`trg(B/$(GV<XfD'(B"
      "$(Gt?h:DcDbGtGcN{GsL(!#`trgD'(B"
      nil
      nil
      "$(GF7{tN{s"Py!#|HJUD'(B"
      "$(GQ@LyN{^LGsDbGtGc(B"
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      "$(GDyGt(Balloc$(GFBZu(B"
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      "$(GH4Exrc`uFm(B"
      "$(GGob/H4$\$o$a`uFm(B"
      "server$(GH;D'(B"
      "alloc$(GFBZuD'(B"
      "$(GDbWdLO(Bserver$(G]YZY(B"
      "$(G]WOj]=a#N{NjF[Db\J(B"
      "$(GDbQR$]$q$h$hFnEBFmH)N{t?h:(B"
      nil
      nil
      nil
      nil
      nil
      "$(GDMFxrgDbWd^6Pz(B"
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      "$(GEFG5DbWd{tL=(B"
      "$(GEFG5DbWdlQEx(B"
      "$(GDbQR$]$q$h$hFnEBF+{tL=N{EFG5(B"
      "$(GEhD8N{EFG5DbWd{tL=(B"
      "password$(GDbhW(B"
      "$(GEFG5F_Gc{tL=(B"
      "$(GEFG5DbWdV<Xf(B"
      "$(GEFG5JtH4^6PzExKt(B"
      "$(GDbQR$C$W$h$hN{EFG5(B"
      "$(GEFG5N{(BI-node$(GLO(BFILE_UNIQ$(GDbWdD!S3(B"
      "$(Gb$MLEFG5E4DK(B"
      "$(Gb$MLEFG5E4DK(B"
      "$(Gb$MLEFG5DbGtGc(B"
      "$(Gb$MLEFG5N{DyU)DbhW(B"
      nil
      "$(Gb$MLEFG5DbWd{tL=(B"
      "$(Gb$MLGXDbhW(B"
      "$(Gb$MLf@n#DbhW(B"
      nil
      "$(G]UT6pgI"DbEEQ=(B"
      "password$(GN{rSD+EFG5DbWdFTbd(B"
      "cwnnrc$(GEFG5DbGtGc(B"
      "cwnnrc$(GEFG5N{J0H"rck((B"
      "$(GEhD8t?h:DbWd^6Pz(B"
      "$(G]UT6$C$W$h$hFnEB!#{tL=N{EFG5JtH4(B"
      "$(GGsL(N{s"PyEFG5JtH4(B"
      "password$(GN{EFG5JtH4^6PzExKt(B"
      ])
    ("Korean" .
     [
      nil
      "$(CH-@O@L(B $(CA8@gGOAv(B $(C>J=@4O4Y(B"
      nil
      "$(C8^8p8.(B alloc $(C?!<-(B $(C=GFPG_@>4O4Y(B"
      nil
      "$(C;g@|@L(B $(C>F4U4O4Y(B"
      "$(C:s55(B $(CH-@O@L(B $(C>F4U4O4Y(B"
      "$(C:N<S>n(B $(CH-@O@L(B $(C>F4U4O4Y(B"
      nil
      "$(C;g@|(B $(CEW@L:m@L(B $(C2K(B $(CC!@>4O4Y(B"
      "$(CAvA$5H(B $(C;g@|@G(B $(C:s55(B $(CH-@O@L(B $(C>F4U4O4Y(B"
      nil
      nil
      nil
      nil
      nil
      "$(CH-@O@;(B $(C?-(B $(C<v(B $(C>x@>4O4Y(B"
      "$(C8B4B(B $(C:s55(B $(CH-@O@L(B $(C>F4U4O4Y(B"
      "$(C8B4B(B $(C:N<S>n(B $(CH-@O@L(B $(C>F4U4O4Y(B"
      "$(C:N<S>n@G(B $(C09<v0!(B $(C3J9+(B $(C890E3*(B $(C:$EM@G(B $(C1f@L0!(B $(C3J9+(B $(C1i4O4Y(B"
      "$(C1W(B $(C9xH#@G(B $(C;g@|@:(B $(C;g?k5G0m(B $(C@VAv(B $(C>J=@4O4Y(B"
      nil
      nil
      nil
      "$(C:N<S>n(B $(CH-@O@G(B $(C3;?k@L(B $(C8BAv(B $(C>J=@4O4Y(B"
      "$(C0!;s(B $(CG0;g@G(B $(C9xH#0!(B $(CF2834O4Y(B. hinsi.data $(C0!(B $(C8BAv(B $(C>J=@4O4Y(B"
      "$(C9LA$@G@G(B $(CG0;g0!(B $(C@|4\(B $(CG0;g7N(B $(CA$@G5G>n(B $(C@V=@4O4Y(B"
      "$(C:N<S>n(B $(CH-@O@L(B $(C@PGtA.(B $(C@VAv(B $(C>J=@4O4Y(B"
      nil
      nil
      "$(C;g@|@G(B $(C?#F.8.0!(B $(C3J9+(B $(C89=@4O4Y(B"
      "$(C:/H/GO7A4B(B $(C9.@Z?-@L(B $(C3J9+(B $(C1i4O4Y(B"
      "$(C:N<S>n(B $(CGX<.(B $(C?5?*@L(B $(C:NA7GU4O4Y(B"
      nil
      "$(C4Y@=(B $(CHD:8(B $(C?5?*@L(B $(C:NA7GU4O4Y(B"
      "$(CHD:80!(B $(C>x@>4O4Y(B"
      nil
      nil
      nil
      nil
      "$(CGQ1[@L(B $(C3J9+(B $(C1i4O4Y(B"
      "$(CGQ@Z0!(B $(C3J9+(B $(C1i4O4Y(B"
      "$(CAvA$5H(B $(C;g@|@:(B $(C5n7O(B $(C:R0!4I@T4O4Y(B"
      "$(CGQ1[@G(B $(C1f@L0!(B 0 $(C@T4O4Y(B"
      "$(CAvA$5H(B $(C;g@|@:(B $(C?*B|A6(B $(C:R0!4I@T4O4Y(B"
      "$(C@P1b@|?k(B $(C;g@|?!(B $(C5n7O(B/$(C<R0E(B $(CGO7A0m(B $(CG_@>4O4Y(B"
      "$(CA8@gGOAv(B $(C>J4B(B $(C;g@|?!(B $(C5n7O(B $(CGO7A0m(B $(CG_@>4O4Y(B"
      nil
      nil
      "$(C@P1b@|?k(B $(C:s558&(B $(C0f=E(B $(CGO7A0m(B $(CG_@>4O4Y(B"
      "$(CAvA$5H(B $(C4\>n4B(B $(CA8@gGOAv(B $(C>J=@4O4Y(B"
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      "$(C8^8p8.(B alloc $(C?!(B $(C=GFPG_@>4O4Y(B"
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      "$(C?!7/0!(B $(C9_;}G_@>4O4Y(B"
      "$(C9v1W(B(Bug)$(C0!(B $(C9_;}G_@>4O4Y(B"
      "$(C<-9v(B(Server)$(C0!(B $(CAW>n(B $(C@V@>4O4Y(B"
      "alloc$(C?!(B $(C=GFPG_@>4O4Y(B"
      "$(C<-9v(B(Server) $(C?M(B $(CA"CKGR(B $(C<v(B $(C>x@>4O4Y(B"
      "$(CEk=E(B $(CGA7NEdD]@G(B $(C9vA/@L(B $(C8BAv(B $(C>J=@4O4Y(B"
      "$(CE,6s@L>HF.0!(B $(C;}<:GQ(B $(CH/0f@L(B $(C>F4U4O4Y(B"
      nil
      nil
      nil
      nil
      nil
      "$(C5p7:Ed8.8&(B $(C885i(B $(C<v(B $(C>x@>4O4Y(B"
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      nil
      "$(CH-@O(B $(C@P1b?!(B $(C=GFPG_@>4O4Y(B"
      "$(CH-@O(B $(C>21b?!(B $(C=GFPG_@>4O4Y(B"
      "$(CE,6s@L>HF.0!(B $(C@P>n(B $(C5e80(B $(CH-@O@L(B $(C>F4U4O4Y(B"
      "$(C4u(B $(C@L;s@G(B $(CH-@O@;(B $(C@P>n(B $(C5e81(B $(C<v(B $(C>x@>4O4Y(B"
      "$(CFP=:?v5e0!(B $(CF2834O4Y(B"
      "$(CH-@O@L(B $(C@PGtA.(B $(C@V@>4O4Y(B"
      "$(CH-@O@;(B $(C<R0EGR(B $(C<v(B $(C>x@>4O4Y(B"
      "$(CH-@O@;(B $(C@[<:GR(B $(C<v(B $(C>x@>4O4Y(B"
      "kWnn$(C@G(B $(CH-@O@L(B $(C>F4U4O4Y(B"
      "$(CH-@O@G(B I-node $(C?M(B FILE_UNIQ $(C8&(B $(C@OD!=CE3(B $(C<v(B $(C>x@>4O4Y(B"
      "$(CG0;g(B $(CH-@O@G(B $(CE)1b0!(B $(C3J9+(B $(CE.4O4Y(B"
      "$(CG0;g(B $(CH-@O@G(B $(CE)1b0!(B $(C3J9+(B $(CE.4O4Y(B"
      "$(CG0;g(B $(CH-@O@L(B $(CA8@gGOAv(B $(C>J=@4O4Y(B"
      "$(CG0;g(B $(CH-@O@G(B $(C3;?k@L(B $(CF2834O4Y(B"
      nil
      "$(CG0;g(B $(CH-@O@L(B $(C@PGtA.(B $(C@VAv(B $(C>J=@4O4Y(B"
      "$(CG0;g(B $(C@L8'@L(B $(CF2834O4Y(B"
      "$(CG0;g(B $(C9xH#0!(B $(CF2834O4Y(B"
      nil
      "$(C1W(B $(CA6@[@:(B $(CAv?x5GAv(B $(C>J=@4O4Y(B"
      "$(CFP=:?v5e0!(B $(C5i>n@V4B(B $(CH-@O@;(B $(C?-(B $(C<v(B $(C>x@>4O4Y(B"
      "uumrc $(C@L(B $(CA8@gGOAv(B $(C>J=@4O4Y(B"
      "uumrc $(C@G(B $(CG|=D@L(B $(CF2834O4Y(B"
      "$(C@L(B $(C@L;s(B $(CH/0f@;(B $(C@[<:GR(B $(C<v(B $(C>x@>4O4Y(B"
      "$(CE)6s@L>HF.0!(B $(C@P>n(B $(C5e80(B $(CH-@O@L(B $(C>F4U4O4Y(B"
      "$(C;g@|?!(B $(C:s55(B $(CH-@O@L(B $(CA8@gGOAv(B $(C>J=@4O4Y(B"
      "$(CFP=:?v5e(B $(CH-@O@;(B $(C@[<:GR(B $(C<v(B $(C>x@>4O4Y(B"
      ]))
  "Array of WNN error messages.  Indexed by error code.")

(defun wnnrpc-get-error-message (errno)
  "Return error message string specified by ERRNO."
  (let ((msg (or (assoc egg-default-language wnnrpc-error-message)
		 (assoc its-current-language wnnrpc-error-message)
		 (assoc "Japanese" wnnrpc-error-message))))
    (or (aref (cdr msg) errno) (format "#%d" errno))))

(defmacro wnnrpc-call-with-environment (e vlist send-expr &rest receive-exprs)
  (let ((v (append
	    `((proc (wnnenv-get-proc ,e))
	      (env-id (wnnenv-get-env-id ,e))
	      (egg-zhuyin its-zhuyin))
	    vlist)))
    (list
     'let v
     (append
	`(save-excursion
	   (set-buffer (process-buffer proc))
	   (erase-buffer)
	   ,send-expr
	   (process-send-region proc (point-min) (point-max))
	   (goto-char (prog1 (point) (accept-process-output proc))))
	receive-exprs))))

(defsubst wnnrpc-test-result-and-get-error (proc result)
  (if (< result 0)			; Get error # (XXX: Bad protocol)
      (let (error)
	(comm-unpack (u) error)
	(- error))
    result))

(defun wnnrpc-open (proc myhostname username)
  "Open the session.  Return 0 on success, error code on failure."
  (comm-call-with-proc proc (result)
    (comm-format (u u s s)
		 (wnn-const JS_OPEN)
		 (wnn-const JLIB_VERSION)
		 myhostname username)
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defun wnnrpc-connect (proc envname)
  "Establish new `connection' and make an environment.
Return the identitifation of the environment on success, 
negate-encoded error code on failure."
  (comm-call-with-proc proc (result)
    (comm-format (u s) (wnn-const JS_CONNECT) envname)
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defun wnnrpc-open-file (proc env-id filename)
  "Open the file FILENAME on the environment ENV-ID on server process PROC.
Return file descripter on success, negate-encoded error code on failure."
  (comm-call-with-proc proc (result)
    (comm-format (u u s) (wnn-const JS_FILE_READ) env-id filename)
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defun wnnrpc-set-fuzokugo-file (proc env-id fid)
  "For PROC, on environment ENV-ID, 
Set Fuzokugo file specified by FID.
Return 0 on success, negate-encoded error code on failure."
  (comm-call-with-proc proc (result)
    (comm-format (u u i) (wnn-const JS_FUZOKUGO_SET) env-id fid)
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defun wnnrpc-set-dictionary (proc env-id rev dic freq pri dic-mode freq-mode)
  "Set dictionary on server.
Return 0 on success, negate-encoded error code on faiulure."
  (comm-call-with-proc proc (result)
    (comm-format (u u i i i u u s s u) (wnn-const JS_DIC_ADD)
		 env-id dic freq pri
		 (if dic-mode 0 1)
		 (if freq-mode 0 1)
		 "" ""		; XXX: No password
		 (if rev 1 0))
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defun wnnrpc-version (proc)
  "Return the version number of WNN server."
  (comm-call-with-proc proc (result)
    (comm-format (u) (wnn-const JS_VERSION))
    (comm-unpack (u) result)
    result))

(defun wnnrpc-access (proc env-id mode path) 
  "On the server connected by PROC, check the accessibility of file in
the environment ENV-ID.  Return 0 when the remote file
(dictionary/frequency) of PATH can be accessed in mode MODE.  Return
Non-zero otherwise."
  (comm-call-with-proc proc (result)
    (comm-format (u u u s) (wnn-const JS_ACCESS) env-id mode path)
    (comm-unpack (u) result)
    result))

(defun wnnrpc-mkdir (proc env-id path)
  "Create directory specified by PATH."
  (comm-call-with-proc proc (result)
    (comm-format (u u s) (wnn-const JS_MKDIR) env-id path)
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defun wnnrpc-create-dictionary (proc env-id dicname)
  "Create dictionary on server."
  (comm-call-with-proc proc (result)
    (comm-format (u u s S s s u) (wnn-const JS_DIC_FILE_CREATE)
		 env-id dicname ""	; XXX: No comment
		 "" ""		; XXX: No passwd
		 (wnn-const WNN_REV_DICT))
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defun wnnrpc-create-frequency (proc env-id freqname dictionary)
  "Create frequency file on server."
  (comm-call-with-proc proc (result)
    (comm-format (u u u s S s) (wnn-const JS_HINDO_FILE_CREATE)
		 env-id dictionary freqname "" ; XXX: No comment
		 "")			; XXX: No password
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defun wnnrpc-discard-file (proc env-id fid)
  "Discard a file specified by FID.  Call this for already-opened file
before remove and create new file."
  (comm-call-with-proc proc (result)
    (comm-format (u u u) (wnn-const JS_FILE_DISCARD)
		 env-id fid)
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defun wnnrpc-remove-file (proc filename)
  "Remove the file."
  (comm-call-with-proc proc (result)
    (comm-format (u s s) (wnn-const JS_FILE_REMOVE) filename "") ; No passwd
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defun wnnrpc-set-conversion-parameters (proc env-id v)
  "Set conversion parameters."
  (comm-call-with-proc proc (result)
    (comm-format  (u u i i i i i i i i i i i i i i i i i)
		  (wnn-const JS_PARAM_SET)
		  env-id
		  (aref v  0) (aref v  1) (aref v  2) (aref v  3)
		  (aref v  4) (aref v  5) (aref v  6) (aref v  7)
		  (aref v  8) (aref v  9) (aref v 10) (aref v 11)
		  (aref v 12) (aref v 13) (aref v 14) (aref v 15)
		  (aref v 16) (aref v 17))
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defsubst wnnrpc-receive-sho-bunsetsu-list-sub (e proc number-of-sho-bunsetsu)
  (let ((i 0)
	slist
	end start jiritsugo-end dic-no entry freq right-now
	hinshi status status-backward kangovect evaluation)
    (while (< i number-of-sho-bunsetsu)
      (comm-unpack (u u u u u u u u u u u u)
		   end start jiritsugo-end dic-no entry freq right-now
		   hinshi status status-backward kangovect evaluation)
      (setq slist
	    (cons
	     (wnn-bunsetsu-create e
	      end start jiritsugo-end dic-no entry freq right-now
	      hinshi status status-backward kangovect evaluation)
	     slist))
      (setq i (1+ i)))
    (reverse slist)))

(defsubst wnnrpc-receive-sho-bunsetsu-list-sub-2 (proc slist)
  (let ((l slist)
	result origin fuzokugo b)
    (while l
      (setq b (car l))
      (comm-unpack (S S S) result origin fuzokugo)
      (wnn-bunsetsu-set-converted b result)
      (wnn-bunsetsu-set-yomi b origin)
      (wnn-bunsetsu-set-fuzokugo b fuzokugo)
      (setq l (cdr l)))
    slist))

(defun wnnrpc-receive-sho-bunsetsu-list (e proc number-of-sho-bunsetsu)
  (let ((slist (wnnrpc-receive-sho-bunsetsu-list-sub e proc
						     number-of-sho-bunsetsu)))
    (wnnrpc-receive-sho-bunsetsu-list-sub-2 proc slist)))

(defun wnnrpc-renbunsetsu-conversion (e yomi hinshi fuzoku &optional v)
  "Convert YOMI string into Kanji.
HINSHI and FUZOKU are information of preceding bunsetsu."
  (let (v0 v1)
    (if v
	(setq v0 v
	      v1 (wnn-const WNN_VECT_KANREN))
      (setq v0 (wnn-const WNN_VECT_KANREN)
	    v1 (wnn-const WNN_VECT_NO)))
    (wnnrpc-call-with-environment e (number-of-dai-bunsetsu kanji-length error
				     number-of-sho-bunsetsu dlist)
      (comm-format (u u S i S i i i) (wnn-const JS_KANREN)
		   env-id yomi hinshi fuzoku v0 v1
		   (wnn-const WNN_VECT_BUNSETSU))
      (comm-unpack (u) number-of-dai-bunsetsu)
      (if (< number-of-dai-bunsetsu 0)
	  (let (error)
	    (comm-unpack (u) error)
	    (error "WNN Error on renbunsetsu conversion: %s"
		   (wnnrpc-get-error-message error)))
	(comm-unpack (u u) number-of-sho-bunsetsu kanji-length)
	(setq dlist (cons nil nil))
	(let ((i 0)
	      (d dlist)
	      end start count evaluation)
	  (catch 'break
	    (while t
	      (comm-unpack (u u u u) end start count evaluation)
	      (setcar d (vector end start count evaluation))
	      (if (< (setq i (1+ i)) number-of-dai-bunsetsu)
		  (setq d (setcdr d (cons nil nil)))
		(throw 'break nil))))
	  (cons dlist
		(wnnrpc-receive-sho-bunsetsu-list e proc
						  number-of-sho-bunsetsu)))))))

(defun wnnrpc-get-bunsetsu-candidates (e yomi hinshi fuzoku &optional v)
  ""
  (let (v0 v1)
    (if v
	(setq v0 v
	      v1 (wnn-const WNN_VECT_KANZEN))
      (setq v0 (wnn-const WNN_VECT_KANZEN)
	    v1 (wnn-const WNN_VECT_NO)))
    (wnnrpc-call-with-environment e (number-of-sho-bunsetsu kanji-length slist)
      (comm-format (u u S i S i i) (wnn-const JS_KANZEN_SHO)
		     env-id yomi hinshi fuzoku v0 v1)
      (comm-unpack (u) number-of-sho-bunsetsu)
      (if (< number-of-sho-bunsetsu 0)
	  (let (error)
	    (comm-unpack (u) error)
	    (error "WNN Error on getting candidates: %s"
		   (wnnrpc-get-error-message error)))
	(comm-unpack (u) kanji-length)
	(wnnrpc-receive-sho-bunsetsu-list e proc number-of-sho-bunsetsu)))))

(defun wnnrpc-tanbunsetsu-conversion (e yomi hinshi fuzoku &optional v)
  ""
  (let (v0 v1)
    (if v
	(setq v0 v
	      v1 (wnn-const WNN_VECT_KANTAN))
      (setq v0 (wnn-const WNN_VECT_KANTAN)
	    v1 (wnn-const WNN_VECT_NO)))
    (wnnrpc-call-with-environment e (number-of-sho-bunsetsu kanji-length slist)
      (comm-format (u u S i S i i) (wnn-const JS_KANTAN_SHO)
		     env-id yomi hinshi fuzoku v0 v1)
      (comm-unpack (u) number-of-sho-bunsetsu)
      (if (< number-of-sho-bunsetsu 0)	; Get error # (XXX: Bad protocol)
	  (let (error)
	    (comm-unpack (u) error)
	    (error "WNN Error on tanbunsetsu conversion: %s"
		   (wnnrpc-get-error-message error)))
	(comm-unpack (u) kanji-length)
	(wnnrpc-receive-sho-bunsetsu-list e proc number-of-sho-bunsetsu)))))

(defun wnnrpc-set-frequency (e dicno entry ima hindo)
  ""
  (wnnrpc-call-with-environment e (result)
    (comm-format (u u i i i i) (wnn-const JS_HINDO_SET)
		 env-id dicno entry ima hindo)
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defun wnnrpc-close (proc)
  ""
  (comm-call-with-proc proc (result)
    (comm-format (u) (wnn-const JS_CLOSE))
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defun wnnrpc-env-exist (proc envname)
  ""
  (comm-call-with-proc proc (result)
    (comm-format (u s) (wnn-const JS_ENV_EXIST) envname)
    (comm-unpack (u) result)
    result))

(defun wnnrpc-make-env-sticky (e)
  ""
  (wnnrpc-call-with-environment e (result)
    (comm-format (u u) (wnn-const JS_ENV_STICKY) env-id)
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defun wnnrpc-make-env-unsticky (e)
  ""
  (wnnrpc-call-with-environment e (result)
    (comm-format (u u) (wnn-const JS_ENV_UNSTICKY) env-id)
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defun wnnrpc-disconnect (e)
  ""
  (wnnrpc-call-with-environment e (result)
    (comm-format (u u) (wnn-const JS_DISCONNECT) env-id)
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defun wnnrpc-add-word (e dictionary yomi kanji comment hinshi initial-freq)
  ""
  (wnnrpc-call-with-environment e (result)
    (comm-format (u u u S S S u u) (wnn-const JS_WORD_ADD)
		 env-id
		 dictionary yomi kanji comment
		 hinshi initial-freq)
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defun wnnrpc-get-dictionary-list-with-environment (e)
  ""
  (wnnrpc-call-with-environment e (number-of-dic)
    (comm-format (u u) (wnn-const JS_DIC_LIST) env-id)
    (comm-unpack (u) number-of-dic)
    (if (< number-of-dic 0)
	(let (error)			; XXX js.c is correct?
	  (comm-unpack (u) error)
	  (error "WNN Error on listing dictionaries: %s"
		 (wnnrpc-get-error-message error)))
      (wnnrpc-receive-dictionary-list proc number-of-dic))))

(defun wnnrpc-receive-dictionary-list (proc number-of-dic)
  (let (dic-entry dic freq dic-mode freq-mode enable-flag nice
	rev comment dicname freqname dic-passwd freq-passwd
	type gosuu dic-local-flag freq-local-flag)
    (if (= number-of-dic 0)
	nil
      (comm-unpack (u u u u u u u u S s s s s u u u u)
		   dic-entry dic freq dic-mode freq-mode enable-flag nice
		   rev comment dicname freqname dic-passwd freq-passwd
		   type gosuu dic-local-flag freq-local-flag)
      (cons 
       (vector dic-entry dic freq dic-mode freq-mode enable-flag nice
	       rev comment dicname freqname dic-passwd freq-passwd
	       type gosuu dic-local-flag freq-local-flag)
       (wnnrpc-receive-dictionary-list proc (1- number-of-dic))))))

(defsubst wnndic-get-id (dic)
  (aref dic 0))

(defsubst wnndic-get-comment (dic)
  (aref dic 8))

(defsubst wnndic-get-dictname (dic)
  (aref dic 9))

(defun wnnrpc-get-writable-dictionary-id-list (e)
  ""
  (wnnrpc-call-with-environment e (number-of-dic result)
    (comm-format (u u i) (wnn-const JS_HINSI_DICTS) env-id -1)
    (comm-unpack (u) number-of-dic)
    (if (> number-of-dic 0)
	(let ((l (cons nil nil))
	      (i 0)
	      dic)
	  (setq result l)
	  (catch 'break
	    (while t
	      (comm-unpack (u) dic)
	      (setcar l dic)
	      (if (< (setq i (1+ i)) number-of-dic)
		  (setq l (setcdr l (cons nil nil)))
		(throw 'break nil))))
	  result)
      (if (= number-of-dic 0)
	  nil
	(let (error)
	  (comm-unpack (u) error)
	  (error "WNN Error on listing dictionaries: %s"
		 (wnnrpc-get-error-message error)))))))

(defun wnnrpc-get-hinshi-list (e dic name)
  ""
  (wnnrpc-call-with-environment e (number-of-hinshi size result)
    (comm-format (u u u S) (wnn-const JS_HINSI_LIST) env-id dic name)
    (comm-unpack (u u) number-of-hinshi size)
    (if (> number-of-hinshi 0)
	(let ((l (cons nil nil))
	      (i 0)
	      hinshi)
	  (setq result l)
	  (catch 'break
	    (while t
	      (comm-unpack (S) hinshi)
	      (setcar l hinshi)
	      (if (< (setq i (1+ i)) number-of-hinshi)
		  (setq l (setcdr l (cons nil nil)))
		(throw 'break nil))))
	  result)
      (if (= number-of-hinshi 0)
	  nil
	(let (error)
	  (comm-unpack (u) error)
	  (error "WNN Error on listing HINSHI: %s"
		 (wnnrpc-get-error-message error)))))))

(defun wnnrpc-hinshi-number (proc name)
  ""
  (comm-call-with-proc proc (result)
    (comm-format (u S) (wnn-const JS_HINSI_NUMBER) name)
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defun wnnrpc-get-conversion-parameters (e)
  ""
  (wnnrpc-call-with-environment e (result
				   n nsho p1 p2 p3 p4 p5 p6 p7 p8 p9
				   p10 p11 p12 p13 p14 p15)
    (comm-format (u u) (wnn-const JS_PARAM_GET) env-id)
    (comm-unpack (u) result)
    (if (< result 0)
	(let (error)
	  (comm-unpack (u) error)
	  (- error))
      (comm-unpack  (u u u u u  u u u u u  u u u u u u u)
		    n nsho p1 p2 p3 p4 p5 p6 p7 p8 p9
		    p10 p11 p12 p13 p14 p15)
      (vector n nsho p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 p11 p12 p13 p14 p15))))

(defun wnnrpc-file-loaded (proc path)
  ""
  (comm-call-with-proc proc (result)
    (comm-format (u s) (wnn-const JS_FILE_LOADED) path)
    (comm-unpack (u) result)
    result))

(defun wnnrpc-write-file (e fid filename)
  (wnnrpc-call-with-environment e (result)
    (comm-format (u u u s) (wnn-const JS_FILE_WRITE) env-id fid filename)
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defun wnnrpc-get-fuzokugo-file (e)
  ""
  (wnnrpc-call-with-environment e (result)
    (comm-format (u u u) (wnn-const JS_FUZOKUGO_GET) env-id)
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defsubst wnnrpc-receive-file-list (proc)
  (let ((i 0)
	flist
	number-of-files fid local-flag ref-count type name)
    (comm-unpack (u) number-of-files)
    (if (< number-of-files 0)
	(error "WNN: wnnrpc-receive-file-list")
      (while (< i number-of-files)
	(comm-unpack (u u u u s) fid local-flag ref-count type name)
	(setq flist (cons (vector fid local-flag ref-count type name) flist))
	(setq i (1+ i)))
      flist)))

(defun wnnrpc-get-file-list (proc)
  ""
  (comm-call-with-proc proc (result)
    (comm-format (u) (wnn-const JS_FILE_LIST_ALL))
    (wnnrpc-receive-file-list proc)))

(defun wnnrpc-get-file-list-with-env (e)
  ""
  (wnnrpc-call-with-environment e (result)
    (comm-format (u u) (wnn-const JS_FILE_LIST) env-id)
    (wnnrpc-receive-file-list proc)))

(defun wnnrpc-file-attribute (e path)
  "3: dictionary, 4: hindo file, 5: fuzokugo-file"
  (wnnrpc-call-with-environment e (result)
    (comm-format (u u s) (wnn-const JS_FILE_STAT) env-id path)
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defun wnnrpc-get-file-info (e fid)
  ""
  (wnnrpc-call-with-environment e (result name local-flag ref-count type)
    (comm-format (u u u) (wnn-const JS_FILE_INFO) env-id fid)
    (comm-unpack (u) result)
    (if (< result 0)
	(let (error)
	  (comm-unpack (u) error)
	  (- error))
      (comm-unpack (s u u u) name local-flag ref-count type)
      (vector name local-flag ref-count type))))

(defun wnnrpc-who (proc)
  ""
  (comm-call-with-proc proc (number-of-entry w)
    (comm-format (u) (wnn-const JS_WHO))
    (comm-unpack (u) number-of-entry)
    (if (< number-of-entry 0)
	(let (error)
	  (comm-unpack (u) error)
	  (- error))
      (let ((i 0)
	    sd username hostname e-array)
	(while (< i number-of-entry)
	  (comm-unpack (u s s) sd username hostname)
	  (setq e-array (make-vector 32 nil))
	  (let ((j 0) e)
	    (while (< j (wnn-const WNN_MAX_ENV_OF_A_CLIENT))
	      (comm-unpack (u) e)
	      (aset e-array j e)
	      (setq j (1+ j))))
	  (setq w (cons (vector sd username hostname e-array) w))
	  (setq i (1+ i)))
	(reverse w)))))

(defun wnnrpc-get-env-list (proc)
  (comm-call-with-proc proc (number-of-entry l)
    (comm-format (u) (wnn-const JS_ENV_LIST))
    (comm-unpack (u) number-of-entry)
    (if (< number-of-entry 0)
	(let (error)
	  (comm-unpack (u) error)
	  (- error))
      (let ((i 0)
	    env-id env-name ref-count fuzokugo-fid dic-max
	    dic-array file-array)
	(while (< i number-of-entry)
	  (comm-unpack (u s u u u) env-id env-name ref-count
			 fuzokugo-fid dic-max)
	  (setq dic-array (make-vector 30 nil))
	  (setq file-array (make-vector 60 nil))
	  (let ((j 0) d)
	    (while (< j (wnn-const WNN_MAX_DIC_OF_AN_ENV))
	      (comm-unpack (u) d)
	      (aset dic-array j d)
	      (setq j (1+ j))))
	  (let ((j 0) f)
	    (while (< j (wnn-const WNN_MAX_FILE_OF_AN_ENV))
	      (comm-unpack (u) f)
	      (aset file-array j f)
	      (setq j (1+ j))))
	  (setq l (cons (vector env-id env-name ref-count fuzokugo-fid dic-max
				dic-array file-array) l))
	  (setq i (1+ i)))
	(reverse l)))))

(defun wnnrpc-kill (proc)
  ""
  (comm-call-with-proc proc (result)
    (comm-format (u) (wnn-const JS_KILL))
    (comm-unpack (u) result)
    result))				; XXX: Bad protocol: error?

(defun wnnrpc-delete-dictionary (e dic)
  ""
  (wnnrpc-call-with-environment e (result)
    (comm-format (u u u) (wnn-const JS_DIC_DELETE) env-id dic)
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defun wnnrpc-set-flag-on-dictionary (e dic flag)
  ""
  (wnnrpc-call-with-environment e (result)
    (comm-format (u u u u) (wnn-const JS_DIC_USE) env-id dic flag)
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defun wnnrpc-get-dictionary-list (proc)
  ""
  (comm-call-with-proc proc (number-of-dic)
    (comm-format (u) (wnn-const JS_DIC_LIST_ALL))
    (comm-unpack (u) number-of-dic)
    (wnnrpc-receive-dictionary-list proc number-of-dic)))

(defun wnnrpc-delete-word (e dic entry)
  ""
  (wnnrpc-call-with-environment e (result)
    (comm-format (u u u u) (wnn-const JS_WORD_DELETE) env-id dic entry)
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defun wnnrpc-receive-word (proc yomi)
  (let ((loop t)
	dic serial hinshi hindo right-now internal-hindo internal-right-now
	l l1 kanji comment)
    (while loop
      (comm-unpack (u) dic)
      (if (< dic 0)
	  (setq loop nil)
	(comm-unpack (u u u u u u) serial hinshi hindo right-now
		     internal-hindo internal-right-now)
	(setq l (cons (vector dic serial hinshi hindo right-now
			      internal-hindo internal-right-now
			      yomi nil nil) l) )))
    (setq l (reverse l)
	  l1 l)
    (while l1
      (comm-unpack (S S) kanji comment)
      (aset (car l1) 8 kanji)
      (aset (car l1) 9 comment)
      (setq l1 (cdr l1)))
    l))

(defun wnnrpc-search-word-in-dictionary (e dic yomi)
  ""
  (wnnrpc-call-with-environment e (c0 c1)
    (comm-format (u u u S) (wnn-const JS_WORD_SEARCH) env-id dic yomi)
    ;; XXX Bad protocol: error?
    (comm-unpack (u u) c0 c1)		; ignored
    (wnnrpc-receive-word proc yomi)))

(defun wnnrpc-search-word (e yomi)
  ""
  (wnnrpc-call-with-environment e (c0 c1)
    (comm-format (u u S) (wnn-const JS_WORD_SEARCH_BY_ENV) env-id yomi)
    ;; XXX Bad protocol: error?
    (comm-unpack (u u) c0 c1)		; ignored
    (wnnrpc-receive-word proc yomi)))

(defun wnnrpc-get-word-info (e dic entry)
  ""
  (wnnrpc-call-with-environment e (result c0 c1 yomi)
    (comm-format (u u u u) (wnn-const JS_WORD_INFO) env-id dic entry)
    (comm-unpack (u) result)
    (if (< result 0)
	(let (error)
	  (comm-unpack (u) error)
	  (- error))
      (comm-unpack (S) yomi)		; XXX: reversed string
      (comm-unpack (u u) c0 c1)	; ignored
      (wnnrpc-receive-word proc yomi))))

(defun wnnrpc-set-comment-on-word (e dic entry comment)
  ""
  (wnnrpc-call-with-environment e (result)
    (comm-format (u u u u S) (wnn-const JS_WORD_COMMENT_SET)
		 env-id dic entry comment)
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defun wnnrpc-get-dictionary-info (e dic)
  ""
  (wnnrpc-call-with-environment e (result)
    (comm-format (u u u) (wnn-const JS_DIC_INFO) env-id dic)
    (comm-unpack (u) result)
    (if (< result 0)
	(let (error)
	  (comm-unpack (u) error)
	  (- error))
      (wnnrpc-receive-dictionary-list proc 1))))

(defun wnnrpc-set-file-comment (e fid comment)
  ""
  (wnnrpc-call-with-environment e (result)
    (comm-format (u u u S) (wnn-const JS_FILE_COMMENT_SET) env-id fid comment)
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defun wnnrpc-hinshi-name (proc hinshi)
  ""
  (comm-call-with-proc proc (result)
    (comm-format (u u) (wnn-const JS_HINSI_NAME) hinshi)
    (comm-unpack (u) result)
    (if (< result 0)
	(let (error)
	  (comm-unpack (u) error)
	  (- error))
      (comm-unpack (S) result)
      result)))

;;; WHICH: 1: DIC, 2: HINDO, 3(0): Both
(defun wnnrpc-set-file-password (e fid which old new)
  ""
  (wnnrpc-call-with-environment e (result)
    (comm-format (u u u u s s) (wnn-const JS_FILE_PASSWORD)
		 env-id fid which old new)
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defun wnnrpc-set-hinshi-table (e dic hinshi-table)
  ""
  (wnnrpc-call-with-environment e (result)
    (comm-format (u u u S) (wnn-const JS_HINSI_TABLE_SET)
		 env-id dic hinshi-table)
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defsubst wnnrpc-receive-dai-bunsetsu-list (proc number-of-bunsetsu)
  (let ((i 0)
	slist
	end start number-of-sho-bunsetsu evaluation v)
    (while (< i number-of-bunsetsu)
      (comm-unpack (u u u u)
		   end start number-of-sho-bunsetsu evaluation)
      (setq slist
	    (cons (vector end start number-of-sho-bunsetsu evaluation nil)
		  slist))
      (setq i (1+ i)))
    (setq slist (reverse slist))
    (let ((s slist)
	  result)
      (while s
	(setq v (car s))
	(setq result (wnnrpc-receive-sho-bunsetsu-list-sub-2 proc (aref v 2)))
	(aset v 4 result)
	(setq s (cdr s)))
      (setq s slist)
      (while s
	(setq v (car s))
	(wnnrpc-receive-sho-bunsetsu-list-sub-2 proc (aref v 4))
	(setq s (cdr s)))
      slist)))

(defun wnnrpc-daibunsetsu-conversion (e yomi hinshi fuzoku &optional v)
  ""
  (let (v0 v1)
    (if v
	(setq v0 v
	      v1 (wnn-const WNN_VECT_KANTAN))
      (setq v0 (wnn-const WNN_VECT_KANTAN)
	    v1 (wnn-const WNN_VECT_NO)))
    (wnnrpc-call-with-environment e (number-of-bunsetsu sho-size kanji-size)
      (comm-format (u u S i S i i) (wnn-const JS_KANTAN_DAI)
		   env-id yomi hinshi fuzoku v0 v1)
      (comm-unpack (u) number-of-bunsetsu)
      (if (< number-of-bunsetsu 0)	; Get error # (XXX: Bad protocol)
	  (let (error)
	    (comm-unpack (u) error)
	    (error "WNN Error on daibunsetsu conversion: %s"
		   (wnnrpc-get-error-message error)))
	(comm-unpack (u u) sho-size kanji-size)
	(wnnrpc-receive-dai-bunsetsu-list proc number-of-bunsetsu)))))

(defun wnnrpc-get-daibunsetsu-candidate (e yomi hinshi fuzoku &optional v)
  ""
  (let (v0 v1)
    (if v
	(setq v0 v
	      v1 (wnn-const WNN_VECT_KANZEN))
      (setq v0 (wnn-const WNN_VECT_KANZEN)
	    v1 (wnn-const WNN_VECT_NO)))
    (wnnrpc-call-with-environment e (number-of-bunsetsu sho-size kanji-size)
      (comm-format (u u S i S i i) (wnn-const JS_KANZEN_DAI)
		   env-id yomi hinshi fuzoku v0 v1)
      (comm-unpack (u) number-of-bunsetsu)
      (if (< number-of-bunsetsu 0)	; Get error # (XXX: Bad protocol)
	  (let (error)
	    (comm-unpack (u) error)
	    (error "WNN Error on daibunsetsu conversion: %s"
		   (wnnrpc-get-error-message error)))
	(comm-unpack (u u) sho-size kanji-size)
	(wnnrpc-receive-dai-bunsetsu-list proc number-of-bunsetsu)))))

;; XXX: NIY: check in the file contents
;; 16
(defun wnnrpc-local-file-loaded (proc path)
  ""
  (let ((attr (file-attributes path)))
    (let ((time (cons (car (nth 6 attr)) (car (cdr (nth 6 attr)))))
	  (inode (nth 10 attr))
	  (dev (nth 11 attr))
	  (padded-hostname
	   (substring 
	    (concat (system-name)
		    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0") 0 16)))
      (comm-call-with-proc proc (result)
        (comm-format (u U U U s) (wnn-const JS_FILE_LOADED_LOCAL)
		     time dev inode padded-hostname)
	(comm-unpack (u) result)
	result))))

(defun wnnrpc-file-receive (e fid local-filename)
  ""
  (wnnrpc-call-with-environment e (filename)
    (comm-format (u u u) (wnn-const JS_FILE_RECEIVE)
		 env-id fid)
    (comm-unpack (s) filename)
    (if (null local-filename)
	(setq local-filename (substring filename
					(1+ (string-match "!" filename)))))
    (wnnrpc-file-receive-sub proc local-filename)))

(defun wnnrpc-file-receive-sub (proc local-filename)
  ;; XXX check file header
  (let ((attr (file-attributes local-filename)))
    (let ((time (cons (car (nth 6 attr)) (car (cdr (nth 6 attr)))))
	  (inode (nth 10 attr))
	  (dev (nth 11 attr))
	  (padded-hostname
	   (substring 
	    (concat (system-name)
		    "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0") 0 16)))
    (comm-call-with-proc-1 proc (result)
      (comm-format (u U U U s) 0 ; ACK
		   time dev inode padded-hostname)
      (comm-unpack (s) result)
      (cond ((< result 0)
	     (let (error)
	       (comm-unpack (u) error)
	       (- error)))
	    ((= result 0)
	     )		; done
	    ((or (= result 1) (= result 3) (= result 2))
	      ;; XXX distingush creation...
	     (comm-call-with-proc-1 proc (contents result)
	       (comm-format (u) 0)	; ACK
	       (comm-unpack (B u) contents result)
	       ;; XXX XXXXXXXXXXXXXXXXX save the contents...
	       (wnnrpc-test-result-and-get-error proc result))))))))

(defun wnnrpc-file-send (e filename)
  ""
  (wnnrpc-call-with-environment e (result)
    (comm-format (u u U U U s) (wnn-const JS_FILE_SEND)
		 env-id time dev inode padded-hostname)
    (comm-unpack (u) result)
    (if (/= result -1)
	(progn
	  (comm-unpack (u) result)
	  (if (< result 0)
	      (let (error)
		(comm-unpack (u) error)
		(- error))
	    result))
      (comm-unpack (u) result)
      (if (< result 0)
	  (let (error)
	    (comm-unpack (u) error)
	    (- error))
	(let ((path (concat (system-name) "!" filename)))
	  (wnnrpc-send-file-sub proc path))))))

(defun wnnrpc-send-file-sub (proc path)
  (comm-call-with-proc-1 proc (result)
    (progn
      (comm-format (s) path)
      ;; XXXXXXXXXXXXXX send the contents of file...
      (while xxx
	(if (= c 255)
	    (comm-format (b b) 255 0)
	  (comm-format (b) c)))
      (comm-format (b b) 255 255))
    (comm-unpack (u) result)
    (wnnrpc-test-result-and-get-error proc result)))

(defun wnnrpc-file-remove-client ()
)

(defun wnnrpc-dic-file-create-client ()
)

(defun wnnrpc-hindo-file-create-client ()
113
)

;;; egg/wnnrpc.el ends here.