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

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

;; Author: NIIBE Yutaka <gniibe@mri.co.jp>
;; Maintainer: NIIBE Yutaka <gniibe@mri.co.jp>

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

;; GNU Emacs 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.

;; GNU Emacs 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
  [
   nil
   "ファイルが存在しません"
   nil
   "メモリ allocation で失敗しました"
   nil
   "辞書ではありません"
   "頻度ファイルではありません"
   "付属語ファイルではありません"
   nil
   "辞書テーブルが一杯です"
   "頻度ファイルが指定された辞書の頻度ファイルではありません"
   nil
   nil
   nil
   nil
   nil
   "ファイルがオープンできません"
   "正しい頻度ファイルではありません"
   "正しい付属語ファイルではありません"
   "付属語の個数, ベクタ長さなどが多過ぎます"
   "その番号の辞書は使われていません"
   nil
   nil
   nil
   "付属語ファイルの内容が正しくありません"
   "疑似品詞番号が異常です(hinsi.data が正しくありません)"
   "未定義の品詞が前端品詞として定義されています"
   "付属語ファイルが読み込まれていません"
   nil
   nil
   "辞書のエイントリが多過ぎます"
   "変換しようとする文字列が長過ぎます"
   "付属語解析領域が不足しています"
   nil
   "次候補領域が不足しています"
   "候補が 1 つも作れませんでした"
   nil
   nil
   nil
   nil
   "読みが長過ぎます"
   "漢字が長過ぎます"
   "指定された辞書は登録可能ではありません"
   "読みの長さが 0 です"
   "指定された辞書は逆引き可能ではありません"
   "リードオンリーの辞書に登録/削除しようとしました"
   "環境に存在しない辞書に登録しようとしました"
   nil
   nil
   "リードオンリーの頻度を変更しようとしました"
   "指定された単語が存在しません"
   nil
   nil
   nil
   nil
   nil
   nil
   nil
   nil
   nil
   "メモリ allocation で失敗しました"
   nil
   nil
   nil
   nil
   nil
   nil
   nil
   "何かのエラーが起こりました"
   "バグが発生している模様です"
   "サーバが死んでいます"
   "allocation に失敗しました"
   "サーバと接続できませんでした"
   "通信プロトコルのバージョンが合っていません"
   "クライアントの生成した環境ではありません"
   nil
   nil
   nil
   nil
   nil
   "ディレクトリを作ることができません"
   nil
   nil
   nil
   nil
   nil
   nil
   nil
   nil
   nil
   "ファイルを読み込むことができません"
   "ファイルを書き出すことができません"
   "クライアントの読み込んだファイルではありません"
   "これ以上ファイルを読み込むことができません"
   "パスワードが間違っています"
   "ファイルが読み込まれています"
   "ファイルが削除できません"
   "ファイルが作成出来ません"
   "WNN のファイルでありません"
   "ファイルの inode と FILE_UNIQ を一致させる事ができません"
   "品詞ファイルが大き過ぎます"
   "品詞ファイルが大き過ぎます"
   "品詞ファイルが存在しません"
   "品詞ファイルの内容が間違っています"
   nil
   "品詞ファイルが読み込まれていません"
   "品詞名が間違っています"
   "品詞番号が間違っています"
   nil
   "その操作はサポートされていません"
   "パスワードの入っているファイルがオープンできません"
   "uumrc ファイルが存在しません"
   "uumrc ファイルの形式が誤っています"
   "これ以上環境を作ることはできません"
   "このクライアントが読み込んだファイルでありません"
   "辞書に頻度ファイルがついていません"
   "パスワードのファイルが作成出来ません"
]
  "Array of WNN error messages.  Indexed by error code.")

(defun wnnrpc-get-error-message (errno)
  "Return error message string specified by ERRNO."
  (or (aref wnnrpc-error-message 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)))
	    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
)

(provide 'egg/wnnrpc)

;;; egg/wnnrpc.el ends here.