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