Mercurial > hg > xemacs-beta

comparison src/mule-wnnfns.c @ 5200:70ed8a0d8da8

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
port Mule-ization of mule-wnnfns.c from ben-unicode-internal -------------------- ChangeLog entries follow: -------------------- src/ChangeLog addition: 2010-04-12 Ben Wing <ben@xemacs.org> * charset.h: * lisp.h: * lisp.h (XREALLOC_ARRAY): * text.h: Port charset_codepoint_to_itext(), buffer_itext_to_charset_codepoint(), EXTBYTE_STRING_TO_ALLOCA(), `enum converr' from ben-unicode-internal, for use with the mule-wnnfns.c changes. * mule-wnnfns.c: * mule-wnnfns.c (Fwnn_open): * mule-wnnfns.c (Fwnn_dict_add): * mule-wnnfns.c (Fwnn_dict_list): * mule-wnnfns.c (Fwnn_get_zenkouho): * mule-wnnfns.c (Fwnn_inspect): * mule-wnnfns.c (Fwnn_bunsetu_kanji): * mule-wnnfns.c (Fwnn_bunsetu_yomi): * mule-wnnfns.c (Fwnn_word_info): * mule-wnnfns.c (Fwnn_dict_search): * mule-wnnfns.c (Fwnn_get_msg): * mule-wnnfns.c (Fwnn_fuzokugo_set): * mule-wnnfns.c (Fwnn_fuzokugo_get): * mule-wnnfns.c (Fwnn_hinsi_list): * mule-wnnfns.c (Fwnn_fisys_dict_add): * mule-wnnfns.c (Fwnn_fiusr_dict_add): * mule-wnnfns.c (Fwnn_notrans_dict_add): * mule-wnnfns.c (Fwnn_bmodify_dict_add): * mule-wnnfns.c (reinit_vars_of_mule_wnn): * mule-wnnfns.c (vars_of_mule_wnn): * mule-wnnfns.c (w2m): * mule-wnnfns.c (m2w): * mule-wnnfns.c (yes_or_no): * mule-wnnfns.c (puts2): * mule-wnnfns.c (check_wnn_server_type): Mule-ize, borrowed from ben-unicode-internal.
author Ben Wing <ben@xemacs.org>
date Mon, 12 Apr 2010 00:55:04 -0500
parents c0934cef10c6
children 308d34e9f07d
comparison
equal deleted inserted replaced
5199:49e931565616 5200:70ed8a0d8da8
1 /* -*- coding: utf-8 -*- 1 /* -*- coding: utf-8 -*-
2 Copyright (C) 1995 Free Software Foundation, Inc. 2 Copyright (C) 1995 Free Software Foundation, Inc.
3 Copyright (C) 1995 Sun Microsystems, Inc. 3 Copyright (C) 1995 Sun Microsystems, Inc.
4 Copyright (C) 2005, 2010 Ben Wing.
4 5
5 This file is part of XEmacs. 6 This file is part of XEmacs.
6 7
7 XEmacs is free software; you can redistribute it and/or modify it 8 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 under the terms of the GNU General Public License as published by the
265 266
266 #include <config.h> 267 #include <config.h>
267 #include "lisp.h" 268 #include "lisp.h"
268 269
269 #include "buffer.h" 270 #include "buffer.h"
271 #include "charset.h"
270 #include "window.h" 272 #include "window.h"
271 #include "sysdep.h" 273 #include "sysdep.h"
272 274
273 #include "wnn/commonhd.h" 275 #include "wnn/commonhd.h"
274 #include "charset.h"
275 #include "wnn/jllib.h" 276 #include "wnn/jllib.h"
276 #include "wnn/cplib.h" 277 #include "wnn/cplib.h"
277 278
278 /* UCHAR が二重定義されるので */ 279 /* UCHAR が二重定義されるので */
279 #define _UCHAR_T 280 #define _UCHAR_T
284 #define WNNSERVER_C 1 285 #define WNNSERVER_C 1
285 #define WNNSERVER_T 2 286 #define WNNSERVER_T 2
286 #define WNNSERVER_K 3 287 #define WNNSERVER_K 3
287 288
288 int check_wnn_server_type (void); 289 int check_wnn_server_type (void);
289 void w2m (w_char *wp, unsigned char *mp, unsigned char lb); 290 void w2m (w_char *wp, Ibyte *mp, Lisp_Object charset);
290 void m2w (unsigned char *mp, w_char *wp); 291 void m2w (Ibyte *mp, w_char *wp);
291 void w2y (w_char *w); 292 void w2y (w_char *w);
292 void c2m (unsigned char *cp, unsigned char *mp, unsigned char lb); 293 void c2m (UExtbyte *cp, Ibyte *mp, Lisp_Object charset);
293 static void puts2 (char *s); 294 static void puts2 (char *s);
294 static int dai_end (int no, int server); 295 static int dai_end (int no, int server);
295 static int yes_or_no (unsigned char *s); 296 static int yes_or_no (UExtbyte *s);
296 297
297 /* Why doesn't wnn have a prototype for these? */ 298 /* Why doesn't wnn have a prototype for these? */
298 typedef unsigned int letter; 299 typedef unsigned int letter;
299 int cwnn_yincod_pzy(w_char *, w_char, int); 300 int cwnn_yincod_pzy(w_char *, w_char, int);
300 int cwnn_pzy_yincod(letter *, letter *, int); 301 int cwnn_pzy_yincod(letter *, letter *, int);
301 302
302 static struct wnn_buf *wnnfns_buf[NSERVER]; 303 static struct wnn_buf *wnnfns_buf[NSERVER];
303 static struct wnn_env *wnnfns_env_norm[NSERVER]; 304 static struct wnn_env *wnnfns_env_norm[NSERVER];
304 static struct wnn_env *wnnfns_env_rev[NSERVER]; 305 static struct wnn_env *wnnfns_env_rev[NSERVER];
305 static int wnnfns_norm; 306 static int wnnfns_norm;
306 static unsigned char lb_wnn_server_type[NSERVER] = 307 static Lisp_Object charset_wnn_server_type[NSERVER];
307 {LEADING_BYTE_JAPANESE_JISX0208, LEADING_BYTE_CHINESE_GB2312, LEADING_BYTE_THAI_TIS620, LEADING_BYTE_KOREAN_KSC5601};
308 308
309 /* Lisp Variables and Constants Definition */ 309 /* Lisp Variables and Constants Definition */
310 Lisp_Object Qjserver; 310 Lisp_Object Qjserver;
311 Lisp_Object Qcserver; 311 Lisp_Object Qcserver;
312 /*Lisp_Object Qtserver;*/ 312 /*Lisp_Object Qtserver;*/
319 Lisp_Object Qwnn_kana, Qwnn_eisuu, Qwnn_kigou, Qwnn_toji_kakko, Qwnn_fuzokogo, Qwnn_kaikakko; 319 Lisp_Object Qwnn_kana, Qwnn_eisuu, Qwnn_kigou, Qwnn_toji_kakko, Qwnn_fuzokogo, Qwnn_kaikakko;
320 Lisp_Object Vwnn_server_type; 320 Lisp_Object Vwnn_server_type;
321 Lisp_Object Vcwnn_zhuyin; 321 Lisp_Object Vcwnn_zhuyin;
322 Lisp_Object Vwnnenv_sticky; 322 Lisp_Object Vwnnenv_sticky;
323 Lisp_Object Vwnn_uniq_level; 323 Lisp_Object Vwnn_uniq_level;
324 Fixnum lb_sisheng; 324 Lisp_Object Qchinese_sisheng;
325 325
326 /* Lisp functions definition */ 326 /* Lisp functions definition */
327 327
328 DEFUN ("wnn-server-open", Fwnn_open, 2, 2, 0, /* 328 DEFUN ("wnn-server-open", Fwnn_open, 2, 2, 0, /*
329 Connect to jserver of host HNAME, make an environment with 329 Connect to jserver of host HNAME, make an environment with
330 login name LNAME in the server. 330 login name LNAME in the server.
331 Return nil if error occurs. 331 Return nil if error occurs.
332 */ 332 */
333 (hname, lname)) 333 (hname, lname))
334 { 334 {
335 char *envname; 335 Extbyte *envname;
336 char *langname; 336 Ascbyte *langname;
337 char *hostname; 337 Extbyte *hostname;
338 int snum; 338 int snum;
339 int size;
340 CHECK_STRING (lname);
341 339
342 snum = check_wnn_server_type (); 340 snum = check_wnn_server_type ();
343 switch (snum) 341 switch (snum)
344 { 342 {
345 case WNNSERVER_J: 343 case WNNSERVER_J:
358 break; 356 break;
359 case -1: 357 case -1:
360 default: 358 default:
361 return Qnil; 359 return Qnil;
362 } 360 }
363 size = XSTRING_LENGTH (lname) > 1024 ? 1026 : XSTRING_LENGTH (lname) + 2; 361 /* #### This is extremely stupid. I'm sure these alloca() copies are
364 /* !!#### */ 362 unnecessary, but the old code went out of its way to do this. --ben */
365 envname = (char *) ALLOCA (size); 363 CHECK_STRING (lname);
366 strncpy (envname, (char *) XSTRING_DATA (lname), size-2); 364 EXTBYTE_STRING_TO_ALLOCA (LISP_STRING_TO_EXTERNAL (lname, Qnative),
367 envname[size-2] = '\0'; 365 envname);
368 if (NILP (hname)) hostname = ""; 366 if (NILP (hname)) hostname = "";
369 else 367 else
370 { 368 {
371 CHECK_STRING (hname); 369 CHECK_STRING (hname);
372 size = XSTRING_LENGTH(hname) > 1024 ? 1025 : XSTRING_LENGTH(hname) + 1; 370 EXTBYTE_STRING_TO_ALLOCA (LISP_STRING_TO_EXTERNAL (hname, Qnative),
373 371 hostname);
374 hostname = (char *) ALLOCA (size); 372 }
375 strncpy (hostname, (char *) XSTRING_DATA (hname), size-1);
376 hostname[size-1] = '\0';
377 }
378 CHECK_STRING (lname);
379 /* 97/4/16 jhod@po.iijnet.or.jp 373 /* 97/4/16 jhod@po.iijnet.or.jp
380 * libwnn uses SIGALRM, so we need to stop and start interrupts. 374 * libwnn uses SIGALRM, so we need to stop and start interrupts.
381 */ 375 */
382 stop_interrupts(); 376 stop_interrupts ();
383 if (!(wnnfns_buf[snum] = jl_open_lang (envname, hostname, langname, 377 if (!(wnnfns_buf[snum] = jl_open_lang (envname, hostname, langname,
384 0, 0, 0, EGG_TIMEOUT))) 378 0, 0, 0, EGG_TIMEOUT)))
385 { 379 {
386 start_interrupts(); 380 start_interrupts ();
387 return Qnil; 381 return Qnil;
388 } 382 }
389 if (!jl_isconnect (wnnfns_buf[snum])) 383 if (!jl_isconnect (wnnfns_buf[snum]))
390 { 384 {
391 start_interrupts(); 385 start_interrupts ();
392 return Qnil; 386 return Qnil;
393 } 387 }
394 wnnfns_env_norm[snum] = jl_env_get (wnnfns_buf[snum]); 388 wnnfns_env_norm[snum] = jl_env_get (wnnfns_buf[snum]);
395 /* if (Vwnnenv_sticky == Qt) jl_env_sticky_e (wnnfns_env_norm[snum]); 389 /* if (Vwnnenv_sticky == Qt) jl_env_sticky_e (wnnfns_env_norm[snum]);
396 else jl_env_un_sticky_e (wnnfns_env_norm[snum]);*/ 390 else jl_env_un_sticky_e (wnnfns_env_norm[snum]);*/
397 strcat (envname, "R"); 391 strcat (envname, "R");
398 if (!(wnnfns_env_rev[snum] = jl_connect_lang (envname, hostname, langname, 392 if (!(wnnfns_env_rev[snum] = jl_connect_lang (envname, hostname, langname,
399 0, 0, 0, EGG_TIMEOUT))) 393 0, 0, 0, EGG_TIMEOUT)))
400 { 394 {
401 start_interrupts(); 395 start_interrupts ();
402 return Qnil; 396 return Qnil;
403 } 397 }
404 /* if (Vwnnenv_sticky == Qt) jl_env_sticky_e (wnnfns_env_rev[snum]); 398 /* if (Vwnnenv_sticky == Qt) jl_env_sticky_e (wnnfns_env_rev[snum]);
405 else jl_env_un_sticky_e (wnnfns_env_rev[snum]);*/ 399 else jl_env_un_sticky_e (wnnfns_env_rev[snum]);*/
406 start_interrupts(); 400 start_interrupts ();
407 return Qt; 401 return Qt;
408 } 402 }
409 403
410 404
411 DEFUN ("wnn-server-close", Fwnn_close, 0, 0, 0, /* 405 DEFUN ("wnn-server-close", Fwnn_close, 0, 0, 0, /*
453 if ((snum = check_wnn_server_type ()) == -1) return Qnil; 447 if ((snum = check_wnn_server_type ()) == -1) return Qnil;
454 if (!wnnfns_buf[snum]) return Qnil; 448 if (!wnnfns_buf[snum]) return Qnil;
455 GCPRO1 (*args); 449 GCPRO1 (*args);
456 gcpro1.nvars = nargs; 450 gcpro1.nvars = nargs;
457 if (jl_dic_add (wnnfns_buf[snum], 451 if (jl_dic_add (wnnfns_buf[snum],
458 XSTRING_DATA (args[0]), 452 LISP_STRING_TO_EXTERNAL (args[0], Qfile_name),
459 XSTRING_DATA (args[1]), 453 LISP_STRING_TO_EXTERNAL (args[1], Qfile_name),
460 wnnfns_norm ? WNN_DIC_ADD_NOR : WNN_DIC_ADD_REV, 454 wnnfns_norm ? WNN_DIC_ADD_NOR : WNN_DIC_ADD_REV,
461 XINT (args[2]), 455 XINT (args[2]),
462 NILP (args[3]) ? WNN_DIC_RDONLY : WNN_DIC_RW, 456 NILP (args[3]) ? WNN_DIC_RDONLY : WNN_DIC_RW,
463 NILP (args[4]) ? WNN_DIC_RDONLY : WNN_DIC_RW, 457 NILP (args[4]) ? WNN_DIC_RDONLY : WNN_DIC_RW,
464 NILP (args[5]) ? 0 : XSTRING_DATA (args[5]), 458 NILP (args[5]) ? 0 :
465 NILP (args[6]) ? 0 : XSTRING_DATA (args[6]), 459 LISP_STRING_TO_EXTERNAL (args[5], Qfile_name),
460 NILP (args[6]) ? 0 :
461 LISP_STRING_TO_EXTERNAL (args[6], Qfile_name),
466 yes_or_no, 462 yes_or_no,
467 puts2 ) < 0) 463 puts2 ) < 0)
468 { 464 {
469 UNGCPRO; 465 UNGCPRO;
470 return Qnil; 466 return Qnil;
493 */ 489 */
494 ()) 490 ())
495 { 491 {
496 WNN_DIC_INFO *dicinfo; 492 WNN_DIC_INFO *dicinfo;
497 int cnt, i; 493 int cnt, i;
498 unsigned char comment[1024]; 494 Ibyte comment[1024];
499 Lisp_Object val; 495 Lisp_Object val;
500 int snum; 496 int snum;
501 unsigned char lb; 497 Lisp_Object charset;
502 498
503 if ((snum = check_wnn_server_type ()) == -1) return Qnil; 499 if ((snum = check_wnn_server_type ()) == -1) return Qnil;
504 lb = lb_wnn_server_type[snum]; 500 charset = charset_wnn_server_type[snum];
505 if (!wnnfns_buf[snum]) return Qnil; 501 if (!wnnfns_buf[snum]) return Qnil;
506 #ifdef WNN6 502 #ifdef WNN6
507 if((cnt = jl_fi_dic_list (wnnfns_buf[snum], 0x3f, &dicinfo)) < 0) 503 if((cnt = jl_fi_dic_list (wnnfns_buf[snum], 0x3f, &dicinfo)) < 0)
508 return Qnil; 504 return Qnil;
509 #else 505 #else
511 #endif 507 #endif
512 val = Qnil; 508 val = Qnil;
513 for (i = 0, dicinfo += cnt; i < cnt; i++) 509 for (i = 0, dicinfo += cnt; i < cnt; i++)
514 { 510 {
515 dicinfo--; 511 dicinfo--;
516 w2m (dicinfo->comment, comment, lb); 512 w2m (dicinfo->comment, comment, charset);
517 /* #### The following has not been Mule-ized!!
518 fname and comment must be ASCII strings! */
519 val = 513 val =
520 Fcons (Fcons (make_int (dicinfo->dic_no), 514 Fcons (Fcons (make_int (dicinfo->dic_no),
521 list4 (make_string ((Ibyte *) (dicinfo->fname), 515 list4 (build_extstring (dicinfo->fname, Qfile_name),
522 strlen (dicinfo->fname)), 516 build_istring (comment),
523 make_string (comment, strlen ((char *) comment)),
524 make_int (dicinfo->gosuu), 517 make_int (dicinfo->gosuu),
525 make_int (dicinfo->nice))), val); 518 make_int (dicinfo->nice))), val);
526 } 519 }
527 return val; 520 return val;
528 } 521 }
628 DEFUN ("wnn-server-get-zenkouho", Fwnn_get_zenkouho, 1, 1, 0, /* 621 DEFUN ("wnn-server-get-zenkouho", Fwnn_get_zenkouho, 1, 1, 0, /*
629 Get kanji string of KOUHO-NUMBER. 622 Get kanji string of KOUHO-NUMBER.
630 */ 623 */
631 (kouhoNo)) 624 (kouhoNo))
632 { 625 {
633 unsigned char kanji_buf[256]; 626 Ibyte kanji_buf[256];
634 w_char wbuf[256]; 627 w_char wbuf[256];
635 int snum; 628 int snum;
636 unsigned char lb; 629 Lisp_Object charset;
637 CHECK_INT (kouhoNo); 630 CHECK_INT (kouhoNo);
638 if ((snum = check_wnn_server_type ()) == -1) return Qnil; 631 if ((snum = check_wnn_server_type ()) == -1) return Qnil;
639 lb = lb_wnn_server_type[snum]; 632 charset = charset_wnn_server_type[snum];
640 if (!wnnfns_buf[snum]) return Qnil; 633 if (!wnnfns_buf[snum]) return Qnil;
641 jl_get_zenkouho_kanji (wnnfns_buf[snum], XINT (kouhoNo), wbuf); 634 jl_get_zenkouho_kanji (wnnfns_buf[snum], XINT (kouhoNo), wbuf);
642 w2m (wbuf, kanji_buf, lb); 635 w2m (wbuf, kanji_buf, charset);
643 return make_string (kanji_buf, strlen ((char *) kanji_buf)); 636 return build_istring (kanji_buf);
644 } 637 }
645 638
646 DEFUN ("wnn-server-zenkouho-bun", Fwnn_zenkouho_bun, 0, 0, 0, /* 639 DEFUN ("wnn-server-zenkouho-bun", Fwnn_zenkouho_bun, 0, 0, 0, /*
647 For Wnn. 640 For Wnn.
648 */ 641 */
737 Get bunsetsu information specified by BUN-NUMBER. 730 Get bunsetsu information specified by BUN-NUMBER.
738 */ 731 */
739 (bunNo)) 732 (bunNo))
740 { 733 {
741 Lisp_Object val; 734 Lisp_Object val;
742 unsigned char cbuf[512]; 735 Ibyte cbuf[512];
743 w_char wbuf[256]; 736 w_char wbuf[256];
744 int bun_no, yomilen, jirilen, i; 737 int bun_no, yomilen, jirilen, i;
745 int snum; 738 int snum;
746 unsigned char lb; 739 Lisp_Object charset;
747 CHECK_INT (bunNo); 740 CHECK_INT (bunNo);
748 if ((snum = check_wnn_server_type ()) == -1) return Qnil; 741 if ((snum = check_wnn_server_type ()) == -1) return Qnil;
749 lb = lb_wnn_server_type[snum]; 742 charset = charset_wnn_server_type[snum];
750 if (!wnnfns_buf[snum]) return Qnil; 743 if (!wnnfns_buf[snum]) return Qnil;
751 bun_no = XINT (bunNo); 744 bun_no = XINT (bunNo);
752 val = Qnil; 745 val = Qnil;
753 val = Fcons (make_int (wnnfns_buf[snum]->bun[bun_no]->kangovect), val); 746 val = Fcons (make_int (wnnfns_buf[snum]->bun[bun_no]->kangovect), val);
754 val = Fcons (make_int (wnnfns_buf[snum]->bun[bun_no]->daihyoka), val); 747 val = Fcons (make_int (wnnfns_buf[snum]->bun[bun_no]->daihyoka), val);
760 val = Fcons (make_int (wnnfns_buf[snum]->bun[bun_no]->dic_no), val); 753 val = Fcons (make_int (wnnfns_buf[snum]->bun[bun_no]->dic_no), val);
761 yomilen = jl_get_yomi (wnnfns_buf[snum], bun_no, bun_no + 1, wbuf); 754 yomilen = jl_get_yomi (wnnfns_buf[snum], bun_no, bun_no + 1, wbuf);
762 jirilen = wnnfns_buf[snum]->bun[bun_no]->jirilen; 755 jirilen = wnnfns_buf[snum]->bun[bun_no]->jirilen;
763 for (i = yomilen; i >= jirilen; i--) wbuf[i+1] = wbuf[i]; 756 for (i = yomilen; i >= jirilen; i--) wbuf[i+1] = wbuf[i];
764 wbuf[jirilen] = '+'; 757 wbuf[jirilen] = '+';
765 w2m (wbuf, cbuf, lb); 758 w2m (wbuf, cbuf, charset);
766 val = Fcons (make_string (cbuf, strlen ((char *) cbuf)), val); 759 val = Fcons (build_istring (cbuf), val);
767 jl_get_kanji (wnnfns_buf[snum], bun_no, bun_no + 1, wbuf); 760 jl_get_kanji (wnnfns_buf[snum], bun_no, bun_no + 1, wbuf);
768 w2m (wbuf, cbuf, lb); 761 w2m (wbuf, cbuf, charset);
769 return Fcons (make_string (cbuf, strlen ((char *) cbuf)), val); 762 return Fcons (build_istring (cbuf), val);
770 } 763 }
771 764
772 765
773 DEFUN ("wnn-server-henkan-quit", Fwnn_quit_henkan, 0, 0, 0, /* 766 DEFUN ("wnn-server-henkan-quit", Fwnn_quit_henkan, 0, 0, 0, /*
774 do nothing. 767 do nothing.
785 Get the pair of kanji and length of bunsetsu specified by BUN-NUMBER. 778 Get the pair of kanji and length of bunsetsu specified by BUN-NUMBER.
786 */ 779 */
787 (bunNo)) 780 (bunNo))
788 { 781 {
789 int no; 782 int no;
790 unsigned char kanji_buf[256]; 783 Ibyte kanji_buf[256];
791 w_char wbuf[256]; 784 w_char wbuf[256];
792 int kanji_len; 785 int kanji_len;
793 int snum; 786 int snum;
794 unsigned char lb; 787 Lisp_Object charset;
795 CHECK_INT (bunNo); 788 CHECK_INT (bunNo);
796 if ((snum = check_wnn_server_type ()) == -1) return Qnil; 789 if ((snum = check_wnn_server_type ()) == -1) return Qnil;
797 lb = lb_wnn_server_type[snum]; 790 charset = charset_wnn_server_type[snum];
798 if (!wnnfns_buf[snum]) return Qnil; 791 if (!wnnfns_buf[snum]) return Qnil;
799 no = XINT (bunNo); 792 no = XINT (bunNo);
800 kanji_len = jl_get_kanji (wnnfns_buf[snum], no, no + 1, wbuf); 793 kanji_len = jl_get_kanji (wnnfns_buf[snum], no, no + 1, wbuf);
801 w2m (wbuf, kanji_buf, lb); 794 w2m (wbuf, kanji_buf, charset);
802 return Fcons (make_string (kanji_buf, strlen ((char *) kanji_buf)), 795 return Fcons (build_istring (kanji_buf), make_int (kanji_len));
803 make_int (kanji_len));
804 } 796 }
805 797
806 DEFUN ("wnn-server-bunsetu-yomi", Fwnn_bunsetu_yomi, 1, 1, 0, /* 798 DEFUN ("wnn-server-bunsetu-yomi", Fwnn_bunsetu_yomi, 1, 1, 0, /*
807 Get the pair of yomi and length of bunsetsu specified by BUN-NUMBER. 799 Get the pair of yomi and length of bunsetsu specified by BUN-NUMBER.
808 */ 800 */
809 (bunNo)) 801 (bunNo))
810 { 802 {
811 int no; 803 int no;
812 unsigned char yomi_buf[256]; 804 Ibyte yomi_buf[256];
813 w_char wbuf[256]; 805 w_char wbuf[256];
814 int yomi_len; 806 int yomi_len;
815 int snum; 807 int snum;
816 unsigned char lb; 808 Lisp_Object charset;
817 CHECK_INT (bunNo); 809 CHECK_INT (bunNo);
818 if ((snum = check_wnn_server_type ()) == -1) return Qnil; 810 if ((snum = check_wnn_server_type ()) == -1) return Qnil;
819 lb = lb_wnn_server_type[snum]; 811 charset = charset_wnn_server_type[snum];
820 if (!wnnfns_buf[snum]) return Qnil; 812 if (!wnnfns_buf[snum]) return Qnil;
821 no = XINT (bunNo); 813 no = XINT (bunNo);
822 yomi_len = jl_get_yomi (wnnfns_buf[snum], no, no + 1, wbuf); 814 yomi_len = jl_get_yomi (wnnfns_buf[snum], no, no + 1, wbuf);
823 w2m (wbuf, yomi_buf, lb); 815 w2m (wbuf, yomi_buf, charset);
824 return Fcons (make_string (yomi_buf, strlen ((char *) yomi_buf)), 816 return Fcons (build_istring (yomi_buf), make_int (yomi_len));
825 make_int (yomi_len));
826 } 817 }
827 818
828 DEFUN ("wnn-server-bunsetu-suu", Fwnn_bunsetu_suu, 0, 0, 0, /* 819 DEFUN ("wnn-server-bunsetu-suu", Fwnn_bunsetu_suu, 0, 0, 0, /*
829 Get the number of bunsetsu. 820 Get the number of bunsetsu.
830 */ 821 */
923 */ 914 */
924 (no, serial)) 915 (no, serial))
925 { 916 {
926 Lisp_Object val; 917 Lisp_Object val;
927 struct wnn_jdata *info_buf; 918 struct wnn_jdata *info_buf;
928 unsigned char cbuf[512]; 919 Ibyte cbuf[512];
929 int snum; 920 int snum;
930 unsigned char lb; 921 Lisp_Object charset;
931 CHECK_INT (no); 922 CHECK_INT (no);
932 CHECK_INT (serial); 923 CHECK_INT (serial);
933 if ((snum = check_wnn_server_type ()) == -1) return Qnil; 924 if ((snum = check_wnn_server_type ()) == -1) return Qnil;
934 lb = lb_wnn_server_type[snum]; 925 charset = charset_wnn_server_type[snum];
935 if (!wnnfns_buf[snum]) return Qnil; 926 if (!wnnfns_buf[snum]) return Qnil;
936 if ((info_buf = jl_word_info (wnnfns_buf[snum], 927 if ((info_buf = jl_word_info (wnnfns_buf[snum],
937 XINT (no), XINT (serial))) != NULL) 928 XINT (no), XINT (serial))) != NULL)
938 { 929 {
939 return Qnil; 930 return Qnil;
941 else 932 else
942 { 933 {
943 val = Qnil; 934 val = Qnil;
944 val = Fcons (make_int (info_buf->hinshi), val); 935 val = Fcons (make_int (info_buf->hinshi), val);
945 val = Fcons (make_int (info_buf->hindo), val); 936 val = Fcons (make_int (info_buf->hindo), val);
946 w2m (info_buf->com, cbuf, lb); 937 w2m (info_buf->com, cbuf, charset);
947 val = Fcons (make_string (cbuf, strlen ((char *) cbuf)), val); 938 val = Fcons (build_istring (cbuf), val);
948 w2m (info_buf->kanji, cbuf, lb); 939 w2m (info_buf->kanji, cbuf, charset);
949 val = Fcons (make_string (cbuf, strlen ((char *) cbuf)), val); 940 val = Fcons (build_istring (cbuf), val);
950 w2m (info_buf->yomi, cbuf, lb); 941 w2m (info_buf->yomi, cbuf, charset);
951 val = Fcons (make_string (cbuf, strlen ((char *) cbuf)), val); 942 val = Fcons (build_istring (cbuf), val);
952 return val; 943 return val;
953 } 944 }
954 } 945 }
955 946
956 DEFUN ("wnn-server-word-hindo-set", Fwnn_hindo_set, 3, 3, 0, /* 947 DEFUN ("wnn-server-word-hindo-set", Fwnn_hindo_set, 3, 3, 0, /*
982 (yomi)) 973 (yomi))
983 { 974 {
984 Lisp_Object val; 975 Lisp_Object val;
985 struct wnn_jdata *wordinfo; 976 struct wnn_jdata *wordinfo;
986 int i, count; 977 int i, count;
987 w_char wbuf[256]; 978 w_char wbuf[256];
988 unsigned char kanji_buf[256]; 979 Ibyte kanji_buf[256];
989 int snum; 980 int snum;
990 unsigned char lb; 981 Lisp_Object charset;
991 CHECK_STRING (yomi); 982 CHECK_STRING (yomi);
992 if ((snum = check_wnn_server_type ()) == -1) return Qnil; 983 if ((snum = check_wnn_server_type ()) == -1) return Qnil;
993 lb = lb_wnn_server_type[snum]; 984 charset = charset_wnn_server_type[snum];
994 if (!wnnfns_buf[snum]) return Qnil; 985 if (!wnnfns_buf[snum]) return Qnil;
995 m2w (XSTRING_DATA (yomi), wbuf); 986 m2w (XSTRING_DATA (yomi), wbuf);
996 if (snum == WNNSERVER_C) 987 if (snum == WNNSERVER_C)
997 w2y (wbuf); 988 w2y (wbuf);
998 if ((count = jl_word_search_by_env (wnnfns_buf[snum], 989 if ((count = jl_word_search_by_env (wnnfns_buf[snum],
1000 return Qnil; 991 return Qnil;
1001 val = Qnil; 992 val = Qnil;
1002 for (i = 0, wordinfo += count; i < count; i++) 993 for (i = 0, wordinfo += count; i < count; i++)
1003 { 994 {
1004 wordinfo--; 995 wordinfo--;
1005 w2m (wordinfo->kanji, kanji_buf, lb); 996 w2m (wordinfo->kanji, kanji_buf, charset);
1006 val = Fcons (Fcons (make_string (kanji_buf, strlen ((char *) kanji_buf)), 997 val = Fcons (Fcons (build_istring (kanji_buf),
1007 list4 (make_int (wordinfo->hinshi), 998 list4 (make_int (wordinfo->hinshi),
1008 make_int (wordinfo->hindo), 999 make_int (wordinfo->hindo),
1009 make_int (wordinfo->dic_no), 1000 make_int (wordinfo->dic_no),
1010 make_int (wordinfo->serial))), 1001 make_int (wordinfo->serial))),
1011 val); 1002 val);
1132 DEFUN ("wnn-server-get-msg", Fwnn_get_msg, 0, 0, 0, /* 1123 DEFUN ("wnn-server-get-msg", Fwnn_get_msg, 0, 0, 0, /*
1133 Get message string from wnn_perror. 1124 Get message string from wnn_perror.
1134 */ 1125 */
1135 ()) 1126 ())
1136 { 1127 {
1137 unsigned char mbuf[256]; 1128 Ibyte mbuf[256];
1138 char *msgp; 1129 char *msgp;
1139 int snum; 1130 int snum;
1140 unsigned char lb; 1131 Lisp_Object charset;
1141 char langname[32]; 1132 char langname[32];
1142 /* CHECK_INT (errno);*/ 1133 /* CHECK_INT (errno);*/
1143 if ((snum = check_wnn_server_type ()) == -1) return Qnil; 1134 if ((snum = check_wnn_server_type ()) == -1) return Qnil;
1144 lb = lb_wnn_server_type[snum]; 1135 charset = charset_wnn_server_type[snum];
1145 switch (snum) 1136 switch (snum)
1146 { 1137 {
1147 case WNNSERVER_J: 1138 case WNNSERVER_J:
1148 strcpy (langname, "ja_JP"); 1139 strcpy (langname, "ja_JP");
1149 break; 1140 break;
1160 break; 1151 break;
1161 } 1152 }
1162 if (!wnnfns_buf[snum]) return Qnil; 1153 if (!wnnfns_buf[snum]) return Qnil;
1163 /* msgp = msg_get (wnn_msg_cat, XINT (errno), 0, 0);*/ 1154 /* msgp = msg_get (wnn_msg_cat, XINT (errno), 0, 0);*/
1164 msgp = wnn_perror_lang (langname); 1155 msgp = wnn_perror_lang (langname);
1165 c2m ((unsigned char *) msgp, mbuf, lb); 1156 c2m ((UExtbyte *) msgp, mbuf, charset);
1166 return make_string (mbuf, strlen ((char *) mbuf)); 1157 return build_istring (mbuf);
1167 } 1158 }
1168 1159
1169 1160
1170 DEFUN ("wnn-server-fuzokugo-set", Fwnn_fuzokugo_set, 1, 1, 0, /* 1161 DEFUN ("wnn-server-fuzokugo-set", Fwnn_fuzokugo_set, 1, 1, 0, /*
1171 For Wnn. 1162 For Wnn.
1174 { 1165 {
1175 int snum; 1166 int snum;
1176 CHECK_STRING (file); 1167 CHECK_STRING (file);
1177 if ((snum = check_wnn_server_type ()) == -1) return Qnil; 1168 if ((snum = check_wnn_server_type ()) == -1) return Qnil;
1178 if (!wnnfns_buf[snum]) return Qnil; 1169 if (!wnnfns_buf[snum]) return Qnil;
1179 if (jl_fuzokugo_set (wnnfns_buf[snum], XSTRING_DATA (file)) < 0) 1170 if (jl_fuzokugo_set (wnnfns_buf[snum],
1171 LISP_STRING_TO_EXTERNAL (file, Qfile_name)) < 0)
1180 return Qnil; 1172 return Qnil;
1181 return Qt; 1173 return Qt;
1182 } 1174 }
1183 1175
1184 DEFUN ("wnn-server-fuzokugo-get", Fwnn_fuzokugo_get, 0, 0, 0, /* 1176 DEFUN ("wnn-server-fuzokugo-get", Fwnn_fuzokugo_get, 0, 0, 0, /*
1189 char fname[256]; 1181 char fname[256];
1190 int snum; 1182 int snum;
1191 if ((snum = check_wnn_server_type ()) == -1) return Qnil; 1183 if ((snum = check_wnn_server_type ()) == -1) return Qnil;
1192 if (!wnnfns_buf[snum]) return Qnil; 1184 if (!wnnfns_buf[snum]) return Qnil;
1193 if (jl_fuzokugo_get (wnnfns_buf[snum], fname) < 0) return Qnil; 1185 if (jl_fuzokugo_get (wnnfns_buf[snum], fname) < 0) return Qnil;
1194 return make_string ((Ibyte *) fname, strlen (fname)); 1186 return build_extstring (fname, Qfile_name);
1195 } 1187 }
1196 1188
1197 1189
1198 DEFUN ("wnn-server-isconnect", Fwnn_isconnect, 0, 0, 0, /* 1190 DEFUN ("wnn-server-isconnect", Fwnn_isconnect, 0, 0, 0, /*
1199 For Wnn. 1191 For Wnn.
1235 */ 1227 */
1236 (dicno, name)) 1228 (dicno, name))
1237 { 1229 {
1238 int cnt; 1230 int cnt;
1239 Lisp_Object val; 1231 Lisp_Object val;
1240 w_char wbuf[256]; 1232 w_char wbuf[256];
1241 w_char **area; 1233 w_char **area;
1242 unsigned char cbuf[512]; 1234 Ibyte cbuf[512];
1243 int snum; 1235 int snum;
1244 unsigned char lb; 1236 Lisp_Object charset;
1245 CHECK_INT (dicno); 1237 CHECK_INT (dicno);
1246 CHECK_STRING (name); 1238 CHECK_STRING (name);
1247 if ((snum = check_wnn_server_type ()) == -1) return Qnil; 1239 if ((snum = check_wnn_server_type ()) == -1) return Qnil;
1248 lb = lb_wnn_server_type[snum]; 1240 charset = charset_wnn_server_type[snum];
1249 if (!wnnfns_buf[snum]) return Qnil; 1241 if (!wnnfns_buf[snum]) return Qnil;
1250 m2w (XSTRING_DATA (name), wbuf); 1242 m2w (XSTRING_DATA (name), wbuf);
1251 if ((cnt = jl_hinsi_list (wnnfns_buf[snum], XINT (dicno), wbuf, &area)) < 0) 1243 if ((cnt = jl_hinsi_list (wnnfns_buf[snum], XINT (dicno), wbuf, &area)) < 0)
1252 return Qnil; 1244 return Qnil;
1253 if (cnt == 0) return make_int (0); 1245 if (cnt == 0) return make_int (0);
1254 val = Qnil; 1246 val = Qnil;
1255 for (area += cnt; cnt > 0; cnt--) 1247 for (area += cnt; cnt > 0; cnt--)
1256 { 1248 {
1257 area--; 1249 area--;
1258 w2m (*area, cbuf, lb); 1250 w2m (*area, cbuf, charset);
1259 val = Fcons (make_string (cbuf, strlen ((char *) cbuf)), val); 1251 val = Fcons (build_istring (cbuf), val);
1260 } 1252 }
1261 return val; 1253 return val;
1262 } 1254 }
1263 1255
1264 DEFUN ("wnn-server-hinsi-name", Fwnn_hinsi_name, 1, 1, 0, /* 1256 DEFUN ("wnn-server-hinsi-name", Fwnn_hinsi_name, 1, 1, 0, /*
1265 For Wnn. 1257 For Wnn.
1266 */ 1258 */
1267 (no)) 1259 (no))
1268 { 1260 {
1269 unsigned char name[256]; 1261 Ibyte name[256];
1270 w_char *wname; 1262 w_char *wname;
1271 int snum; 1263 int snum;
1272 unsigned char lb; 1264 Lisp_Object charset;
1273 CHECK_INT (no); 1265 CHECK_INT (no);
1274 if ((snum = check_wnn_server_type ()) == -1) return Qnil; 1266 if ((snum = check_wnn_server_type ()) == -1) return Qnil;
1275 lb = lb_wnn_server_type[snum]; 1267 charset = charset_wnn_server_type[snum];
1276 if (!wnnfns_buf[snum]) return Qnil; 1268 if (!wnnfns_buf[snum]) return Qnil;
1277 if ((wname = jl_hinsi_name (wnnfns_buf[snum], XINT (no))) == 0) return Qnil; 1269 if ((wname = jl_hinsi_name (wnnfns_buf[snum], XINT (no))) == 0) return Qnil;
1278 w2m (wname, name, lb); 1270 w2m (wname, name, charset);
1279 return make_string (name, strlen ((char *) name)); 1271 return build_istring (name);
1280 } 1272 }
1281 #ifdef WNN6 1273 #ifdef WNN6
1282 DEFUN ("wnn-server-fisys-dict-add", Fwnn_fisys_dict_add, 3, MANY, 0, /* 1274 DEFUN ("wnn-server-fisys-dict-add", Fwnn_fisys_dict_add, 3, MANY, 0, /*
1283 Add dictionary specified by FISYS-DICT-FILE-NAME, FISYS-FREQ-FILE-NAME, 1275 Add dictionary specified by FISYS-DICT-FILE-NAME, FISYS-FREQ-FILE-NAME,
1284 FISYS-FREQ-FILE-MODE. 1276 FISYS-FREQ-FILE-MODE.
1288 { 1280 {
1289 struct gcpro gcpro1; 1281 struct gcpro gcpro1;
1290 int snum; 1282 int snum;
1291 CHECK_STRING (args[0]); 1283 CHECK_STRING (args[0]);
1292 CHECK_STRING (args[1]); 1284 CHECK_STRING (args[1]);
1293 if (! NILP (args[3])) CHECK_STRING (args[3]); 1285 if (!NILP (args[3])) CHECK_STRING (args[3]);
1294 if ((snum = check_wnn_server_type()) == -1) return Qnil; 1286 if ((snum = check_wnn_server_type()) == -1) return Qnil;
1295 if(!wnnfns_buf[snum]) return Qnil; 1287 if (!wnnfns_buf[snum]) return Qnil;
1296 GCPRO1 (*args); 1288 GCPRO1 (*args);
1297 gcpro1.nvars = nargs; 1289 gcpro1.nvars = nargs;
1298 if(jl_fi_dic_add(wnnfns_buf[snum], 1290 if (jl_fi_dic_add (wnnfns_buf[snum],
1299 XSTRING_DATA (args[0]), 1291 LISP_STRING_TO_EXTERNAL (args[0], Qfile_name),
1300 XSTRING_DATA (args[1]), 1292 LISP_STRING_TO_EXTERNAL (args[1], Qfile_name),
1301 WNN_FI_SYSTEM_DICT, 1293 WNN_FI_SYSTEM_DICT,
1302 WNN_DIC_RDONLY, 1294 WNN_DIC_RDONLY,
1303 NILP (args[2]) ? WNN_DIC_RDONLY : WNN_DIC_RW, 1295 NILP (args[2]) ? WNN_DIC_RDONLY : WNN_DIC_RW,
1304 0, 1296 0,
1305 NILP (args[3]) ? 0 : XSTRING_DATA (args[3]), 1297 NILP (args[3]) ? 0 :
1306 yes_or_no, 1298 LISP_STRING_TO_EXTERNAL (args[3], Qfile_name),
1307 puts2 ) < 0) { 1299 yes_or_no,
1308 UNGCPRO; 1300 puts2) < 0)
1309 return Qnil; 1301 {
1310 } 1302 UNGCPRO;
1303 return Qnil;
1304 }
1311 UNGCPRO; 1305 UNGCPRO;
1312 return Qt; 1306 return Qt;
1313 } 1307 }
1314 1308
1315 DEFUN ("wnn-server-fiusr-dict-add", Fwnn_fiusr_dict_add, 4, MANY, 0, /* 1309 DEFUN ("wnn-server-fiusr-dict-add", Fwnn_fiusr_dict_add, 4, MANY, 0, /*
1321 { 1315 {
1322 struct gcpro gcpro1; 1316 struct gcpro gcpro1;
1323 int snum; 1317 int snum;
1324 CHECK_STRING (args[0]); 1318 CHECK_STRING (args[0]);
1325 CHECK_STRING (args[1]); 1319 CHECK_STRING (args[1]);
1326 if (! NILP (args[4])) CHECK_STRING (args[4]); 1320 if (!NILP (args[4])) CHECK_STRING (args[4]);
1327 if (! NILP (args[5])) CHECK_STRING (args[5]); 1321 if (!NILP (args[5])) CHECK_STRING (args[5]);
1328 if ((snum = check_wnn_server_type()) == -1) return Qnil; 1322 if ((snum = check_wnn_server_type()) == -1) return Qnil;
1329 if(!wnnfns_buf[snum]) return Qnil; 1323 if (!wnnfns_buf[snum]) return Qnil;
1330 GCPRO1 (*args); 1324 GCPRO1 (*args);
1331 gcpro1.nvars = nargs; 1325 gcpro1.nvars = nargs;
1332 if(jl_fi_dic_add(wnnfns_buf[snum], 1326 if (jl_fi_dic_add (wnnfns_buf[snum],
1333 XSTRING_DATA (args[0]), 1327 LISP_STRING_TO_EXTERNAL (args[0], Qfile_name),
1334 XSTRING_DATA (args[1]), 1328 LISP_STRING_TO_EXTERNAL (args[1], Qfile_name),
1335 WNN_FI_USER_DICT, 1329 WNN_FI_USER_DICT,
1336 NILP (args[2]) ? WNN_DIC_RDONLY : WNN_DIC_RW, 1330 NILP (args[2]) ? WNN_DIC_RDONLY : WNN_DIC_RW,
1337 NILP (args[3]) ? WNN_DIC_RDONLY : WNN_DIC_RW, 1331 NILP (args[3]) ? WNN_DIC_RDONLY : WNN_DIC_RW,
1338 NILP (args[4]) ? 0 : XSTRING_DATA (args[4]), 1332 NILP (args[4]) ? 0 :
1339 NILP (args[5]) ? 0 : XSTRING_DATA (args[5]), 1333 LISP_STRING_TO_EXTERNAL (args[4], Qfile_name),
1340 yes_or_no, 1334 NILP (args[5]) ? 0 :
1341 puts2 ) < 0) { 1335 LISP_STRING_TO_EXTERNAL (args[5], Qfile_name),
1342 UNGCPRO; 1336 yes_or_no,
1343 return Qnil; 1337 puts2) < 0)
1344 } 1338 {
1339 UNGCPRO;
1340 return Qnil;
1341 }
1345 UNGCPRO; 1342 UNGCPRO;
1346 return Qt; 1343 return Qt;
1347 } 1344 }
1348 1345
1349 DEFUN ("wnn-server-notrans-dict-add", Fwnn_notrans_dict_add, 3, MANY, 0, /* 1346 DEFUN ("wnn-server-notrans-dict-add", Fwnn_notrans_dict_add, 3, MANY, 0, /*
1368 if(wnnfns_norm) 1365 if(wnnfns_norm)
1369 cur_env = wnnfns_env_norm[snum]; 1366 cur_env = wnnfns_env_norm[snum];
1370 else 1367 else
1371 cur_env = wnnfns_env_rev[snum]; 1368 cur_env = wnnfns_env_rev[snum];
1372 dic_no = js_get_autolearning_dic(cur_env, WNN_MUHENKAN_LEARNING); 1369 dic_no = js_get_autolearning_dic(cur_env, WNN_MUHENKAN_LEARNING);
1373 if (dic_no == WNN_NO_LEARNING) { 1370 if (dic_no == WNN_NO_LEARNING)
1374 if((dic_no = jl_dic_add(wnnfns_buf[snum], 1371 {
1375 XSTRING_DATA (args[0]), 1372 if ((dic_no = jl_dic_add (wnnfns_buf[snum],
1376 0, 1373 LISP_STRING_TO_EXTERNAL (args[0],
1377 wnnfns_norm ? WNN_DIC_ADD_NOR : WNN_DIC_ADD_REV, 1374 Qfile_name),
1378 XINT(args[1]), 1375 0,
1379 WNN_DIC_RW, WNN_DIC_RW, 1376 wnnfns_norm ? WNN_DIC_ADD_NOR :
1380 NILP (args[3]) ? 0 : XSTRING_DATA (args[3]), 1377 WNN_DIC_ADD_REV,
1381 0, 1378 XINT (args[1]),
1382 yes_or_no, 1379 WNN_DIC_RW, WNN_DIC_RW,
1383 puts2)) < 0) { 1380 NILP (args[3]) ? 0 :
1381 LISP_STRING_TO_EXTERNAL (args[3],
1382 Qfile_name),
1383 0,
1384 yes_or_no,
1385 puts2)) < 0)
1386 {
1384 UNGCPRO; 1387 UNGCPRO;
1385 return Qnil; 1388 return Qnil;
1386 } 1389 }
1387 js_set_autolearning_dic(cur_env, WNN_MUHENKAN_LEARNING, dic_no); 1390 js_set_autolearning_dic (cur_env, WNN_MUHENKAN_LEARNING, dic_no);
1388 } 1391 }
1389 if(!js_is_loaded_temporary_dic(cur_env)) { 1392 if (!js_is_loaded_temporary_dic (cur_env))
1390 if(js_temporary_dic_add(cur_env, 1393 {
1391 wnnfns_norm ? WNN_DIC_ADD_NOR : WNN_DIC_ADD_REV) < 0) { 1394 if (js_temporary_dic_add (cur_env,
1395 wnnfns_norm ? WNN_DIC_ADD_NOR :
1396 WNN_DIC_ADD_REV) < 0)
1397 {
1392 UNGCPRO; 1398 UNGCPRO;
1393 return Qnil; 1399 return Qnil;
1394 } 1400 }
1395 } 1401 }
1396 vmask |= WNN_ENV_MUHENKAN_LEARN_MASK; 1402 vmask |= WNN_ENV_MUHENKAN_LEARN_MASK;
1397 henv.muhenkan_flag = NILP (args[2]) ? WNN_DIC_RDONLY : WNN_DIC_RW; 1403 henv.muhenkan_flag = NILP (args[2]) ? WNN_DIC_RDONLY : WNN_DIC_RW;
1398 if(jl_set_henkan_env(wnnfns_buf[snum], 1404 if (jl_set_henkan_env (wnnfns_buf[snum],
1399 vmask, 1405 vmask,
1400 &henv) < 0) { 1406 &henv) < 0)
1407 {
1401 UNGCPRO; 1408 UNGCPRO;
1402 return Qnil; 1409 return Qnil;
1403 } 1410 }
1404 UNGCPRO; 1411 UNGCPRO;
1405 return Qt; 1412 return Qt;
1406 } 1413 }
1407 1414
1408 DEFUN ("wnn-server-bmodify-dict-add", Fwnn_bmodify_dict_add, 3, MANY, 0, /* 1415 DEFUN ("wnn-server-bmodify-dict-add", Fwnn_bmodify_dict_add, 3, MANY, 0, /*
1427 if(wnnfns_norm) 1434 if(wnnfns_norm)
1428 cur_env = wnnfns_env_norm[snum]; 1435 cur_env = wnnfns_env_norm[snum];
1429 else 1436 else
1430 cur_env = wnnfns_env_rev[snum]; 1437 cur_env = wnnfns_env_rev[snum];
1431 dic_no = js_get_autolearning_dic(cur_env, WNN_BUNSETSUGIRI_LEARNING); 1438 dic_no = js_get_autolearning_dic(cur_env, WNN_BUNSETSUGIRI_LEARNING);
1432 if (dic_no == WNN_NO_LEARNING) { 1439 if (dic_no == WNN_NO_LEARNING)
1433 if((dic_no = jl_dic_add(wnnfns_buf[snum], 1440 {
1434 XSTRING_DATA (args[0]), 1441 if ((dic_no = jl_dic_add (wnnfns_buf[snum],
1435 0, 1442 LISP_STRING_TO_EXTERNAL (args[0],
1436 wnnfns_norm ? WNN_DIC_ADD_NOR : WNN_DIC_ADD_REV, 1443 Qfile_name),
1437 XINT(args[1]), 1444 0,
1438 WNN_DIC_RW, WNN_DIC_RW, 1445 wnnfns_norm ? WNN_DIC_ADD_NOR :
1439 NILP (args[3]) ? 0 : XSTRING_DATA (args[3]), 1446 WNN_DIC_ADD_REV,
1440 0, 1447 XINT(args[1]),
1441 yes_or_no, 1448 WNN_DIC_RW, WNN_DIC_RW,
1442 puts2)) < 0) { 1449 NILP (args[3]) ? 0 :
1450 LISP_STRING_TO_EXTERNAL (args[3],
1451 Qfile_name),
1452 0,
1453 yes_or_no,
1454 puts2)) < 0)
1455 {
1443 UNGCPRO; 1456 UNGCPRO;
1444 return Qnil; 1457 return Qnil;
1445 } 1458 }
1446 js_set_autolearning_dic(cur_env, WNN_BUNSETSUGIRI_LEARNING, dic_no); 1459 js_set_autolearning_dic (cur_env, WNN_BUNSETSUGIRI_LEARNING, dic_no);
1447 } 1460 }
1448 if(!js_is_loaded_temporary_dic(cur_env)) { 1461 if (!js_is_loaded_temporary_dic (cur_env))
1449 if(js_temporary_dic_add(cur_env, 1462 {
1450 wnnfns_norm ? WNN_DIC_ADD_NOR : WNN_DIC_ADD_REV) < 0) { 1463 if (js_temporary_dic_add (cur_env,
1464 wnnfns_norm ? WNN_DIC_ADD_NOR :
1465 WNN_DIC_ADD_REV) < 0)
1466 {
1451 UNGCPRO; 1467 UNGCPRO;
1452 return Qnil; 1468 return Qnil;
1453 } 1469 }
1454 } 1470 }
1455 vmask |= WNN_ENV_BUNSETSUGIRI_LEARN_MASK; 1471 vmask |= WNN_ENV_BUNSETSUGIRI_LEARN_MASK;
1456 henv.bunsetsugiri_flag = NILP (args[2]) ? WNN_DIC_RDONLY : WNN_DIC_RW; 1472 henv.bunsetsugiri_flag = NILP (args[2]) ? WNN_DIC_RDONLY : WNN_DIC_RW;
1457 if(jl_set_henkan_env(wnnfns_buf[snum], 1473 if (jl_set_henkan_env (wnnfns_buf[snum],
1458 vmask, 1474 vmask,
1459 &henv) < 0) { 1475 &henv) < 0)
1476 {
1460 UNGCPRO; 1477 UNGCPRO;
1461 return Qnil; 1478 return Qnil;
1462 } 1479 }
1463 UNGCPRO; 1480 UNGCPRO;
1464 return Qt; 1481 return Qt;
1465 } 1482 }
1466 1483
1467 DEFUN ("wnn-server-set-last-is-first", Fwnn_last_is_first, 1, 1, 0, /* 1484 DEFUN ("wnn-server-set-last-is-first", Fwnn_last_is_first, 1, 1, 0, /*
1884 { 1901 {
1885 wnnfns_buf[i] = (struct wnn_buf *) 0; 1902 wnnfns_buf[i] = (struct wnn_buf *) 0;
1886 wnnfns_env_norm[i] = (struct wnn_env *) 0; 1903 wnnfns_env_norm[i] = (struct wnn_env *) 0;
1887 wnnfns_env_rev[i] = (struct wnn_env *) 0; 1904 wnnfns_env_rev[i] = (struct wnn_env *) 0;
1888 } 1905 }
1906
1907 charset_wnn_server_type[0] = Vcharset_japanese_jisx0208;
1908 charset_wnn_server_type[1] = Vcharset_chinese_gb2312;
1909 charset_wnn_server_type[2] = Vcharset_thai_tis620;
1910 charset_wnn_server_type[3] = Vcharset_korean_ksc5601;
1889 } 1911 }
1890 1912
1891 void 1913 void
1892 vars_of_mule_wnn (void) 1914 vars_of_mule_wnn (void)
1893 { 1915 {
1894 DEFVAR_INT ("lb-sisheng", &lb_sisheng /*
1895 Leading character for Sisheng.
1896 */ );
1897 DEFVAR_LISP ("wnn-server-type", &Vwnn_server_type /* 1916 DEFVAR_LISP ("wnn-server-type", &Vwnn_server_type /*
1898 *jserver, cserver .. 1917 *jserver, cserver ..
1899 */ ); 1918 */ );
1900 DEFVAR_LISP ("cwnn-zhuyin", &Vcwnn_zhuyin /* 1919 DEFVAR_LISP ("cwnn-zhuyin", &Vcwnn_zhuyin /*
1901 *pinyin or zhuyin 1920 *pinyin or zhuyin
1909 1928
1910 Vwnn_server_type = Qjserver; 1929 Vwnn_server_type = Qjserver;
1911 Vcwnn_zhuyin = Qnil; 1930 Vcwnn_zhuyin = Qnil;
1912 Vwnnenv_sticky = Qnil; 1931 Vwnnenv_sticky = Qnil;
1913 1932
1933 DEFSYMBOL (Qchinese_sisheng);
1934
1914 Vwnn_uniq_level = Qwnn_uniq; 1935 Vwnn_uniq_level = Qwnn_uniq;
1915 1936
1916 Fprovide (intern ("wnn")); 1937 Fprovide (intern ("wnn"));
1917 } 1938 }
1918 1939
1940 /* Convert from the wide-char format expected for wnn to the XEmacs string
1941 format. */
1942
1919 void 1943 void
1920 w2m (w_char *wp, unsigned char *mp, unsigned char lb) 1944 w2m (w_char *wp, Ibyte *mp, Lisp_Object charset)
1921 { 1945 {
1922 w_char wc; 1946 w_char wc;
1923 w_char pzy[10]; 1947 w_char pzy[10];
1924 int i, len; 1948 int i, len;
1925 1949
1935 ? CWNN_PINYIN 1959 ? CWNN_PINYIN
1936 : CWNN_ZHUYIN); 1960 : CWNN_ZHUYIN);
1937 for (i = 0; i < len; i++) 1961 for (i = 0; i < len; i++)
1938 { 1962 {
1939 if (pzy[i] & 0x80) 1963 if (pzy[i] & 0x80)
1940 { 1964 mp += charset_codepoint_to_itext
1941 *mp++ = PRE_LEADING_BYTE_PRIVATE_1; /* #### Not sure about this one... */ 1965 (Fget_charset (Qchinese_sisheng), 0, pzy[i] & 0x7f, mp,
1942 *mp++ = lb_sisheng; 1966 CONVERR_USE_PRIVATE);
1943 } 1967 else
1944 *mp++ = pzy[i]; 1968 /* @@#### Correct? */
1969 mp += charset_codepoint_to_itext
1970 (Vcharset_ascii, 0, pzy[i] & 0x7f, mp,
1971 CONVERR_USE_PRIVATE);
1945 } 1972 }
1946 } 1973 }
1947 else 1974 else
1948 { 1975 mp += charset_codepoint_to_itext (Vcharset_katakana_jisx0201,
1949 *mp++ = LEADING_BYTE_KATAKANA_JISX0201; 1976 0, wc & 0x7f, mp,
1950 *mp++ = (wc & 0xff); 1977 CONVERR_USE_PRIVATE);
1951 }
1952 break; 1978 break;
1953 case 0x8080: 1979 case 0x8080:
1954 *mp++ = lb; 1980 mp += charset_codepoint_to_itext (charset, (wc & 0x7f00) >> 8,
1955 *mp++ = (wc & 0xff00) >> 8; 1981 wc & 0x007f, mp,
1956 *mp++ = wc & 0x00ff; 1982 CONVERR_USE_PRIVATE);
1957 break; 1983 break;
1958 case 0x8000: 1984 case 0x8000:
1959 if (lb == LEADING_BYTE_JAPANESE_JISX0208) 1985 {
1960 *mp++ = LEADING_BYTE_JAPANESE_JISX0212; 1986 Lisp_Object newchar = charset;
1961 else if (lb == LEADING_BYTE_CHINESE_BIG5_1) 1987 if (EQ (charset, Vcharset_japanese_jisx0208))
1962 *mp++ = LEADING_BYTE_CHINESE_BIG5_2; 1988 newchar = Vcharset_japanese_jisx0212;
1963 else 1989 #ifndef UNICODE_INTERNAL
1964 *mp++ = lb; 1990 /* @@#### Something very strange about this */
1965 *mp++ = (wc & 0xff00) >> 8; 1991 else if (EQ (charset, Vcharset_chinese_big5_1))
1966 *mp++ = (wc & 0x00ff) | 0x80; 1992 newchar = Vcharset_chinese_big5_2;
1967 break; 1993 #endif /* not UNICODE_INTERNAL */
1994 mp += charset_codepoint_to_itext (newchar, (wc & 0x7f00) >> 8,
1995 wc & 0x007f, mp,
1996 CONVERR_USE_PRIVATE);
1997 break;
1998 }
1968 default: 1999 default:
1969 *mp++ = wc & 0x00ff; 2000 mp += set_itext_ichar (mp, wc & 0x00ff);
1970 break; 2001 break;
1971 } 2002 }
1972 } 2003 }
1973 *mp = 0; 2004 *mp = 0;
1974 } 2005 }
1975 2006
2007 /* Convert XEmacs string format to the wide-char format expected for wnn. */
1976 void 2008 void
1977 m2w (unsigned char *mp, w_char *wp) 2009 m2w (Ibyte *mp, w_char *wp)
1978 { 2010 {
1979 int ch; 2011 while (*mp)
1980 2012 {
1981 while ((ch = *mp++) != 0) 2013 Lisp_Object charset;
1982 { 2014 int c1, c2;
1983 if (ibyte_leading_byte_p (ch)) 2015 int ch;
1984 { 2016
1985 switch (ch) 2017 /* @@#### current_buffer dependency */
1986 { 2018 buffer_itext_to_charset_codepoint (mp, current_buffer,
1987 case LEADING_BYTE_KATAKANA_JISX0201: 2019 &charset, &c1, &c2, CONVERR_FAIL);
1988 *wp++ = *mp++; break; 2020 INC_IBYTEPTR (mp);
1989 case LEADING_BYTE_LATIN_JISX0201: 2021 if (EQ (charset, Vcharset_ascii) ||
1990 *wp++ = *mp++ & 0x7F; break; 2022 EQ (charset, Vcharset_latin_jisx0201) ||
1991 case LEADING_BYTE_JAPANESE_JISX0208_1978: 2023 EQ (charset, Vcharset_katakana_jisx0201))
1992 case LEADING_BYTE_CHINESE_GB2312: 2024 ch = c2;
1993 case LEADING_BYTE_JAPANESE_JISX0208: 2025 else if (EQ (charset, Vcharset_japanese_jisx0208) ||
1994 case LEADING_BYTE_KOREAN_KSC5601: 2026 EQ (charset, Vcharset_japanese_jisx0208_1978) ||
1995 /* case LEADING_BYTE_TW: */ 2027 EQ (charset, Vcharset_chinese_gb2312) ||
1996 ch = *mp++; 2028 EQ (charset, Vcharset_korean_ksc5601)
1997 *wp++ = (ch << 8) | *mp++; 2029 /* || other 2-byte charsets??? */
1998 break; 2030 )
1999 case LEADING_BYTE_JAPANESE_JISX0212: 2031 ch = ((c1 | 0x80) << 8) + (c2 | 0x80);
2000 ch = *mp++; 2032 else if (EQ (charset, Vcharset_japanese_jisx0212))
2001 *wp++ = (ch << 8) | (*mp++ & 0x7f); 2033 ch = ((c1 | 0x80) << 8) + c2;
2002 break; 2034 else if (EQ (charset, Fget_charset (Qchinese_sisheng)))
2003 case PRE_LEADING_BYTE_PRIVATE_1: /* #### Not sure about this one... */ 2035 ch = 0x8e80 | c2;
2004 ch = *mp++; 2036 else /* Ignore character */
2005 if (ch == lb_sisheng) 2037 continue;
2006 *wp++ = 0x8e80 | *mp++; 2038 *wp++ = (w_char) ch;
2007 else
2008 mp++;
2009 break;
2010 default: /* ignore this character */
2011 mp += rep_bytes_by_first_byte(ch) - 1;
2012 }
2013 }
2014 else
2015 {
2016 *wp++ = ch;
2017 }
2018 } 2039 }
2019 *wp = 0; 2040 *wp = 0;
2020 } 2041 }
2021 2042
2022 void 2043 void
2049 *y = *pin; 2070 *y = *pin;
2050 y++; pin++; len--; 2071 y++; pin++; len--;
2051 } 2072 }
2052 } 2073 }
2053 2074
2075 /* Converts text in the multi-byte locale-specific format returned by some
2076 WNN functions into XEmacs-internal. This format appears to be a simple
2077 MBCS encoding with a single locale, and we could use probably existing
2078 coding systems to handle it. */
2079
2054 void 2080 void
2055 c2m (unsigned char *cp, unsigned char *mp, unsigned char lb) 2081 c2m (UExtbyte *cp, Ibyte *mp, Lisp_Object charset)
2056 { 2082 {
2057 unsigned char ch; 2083 UExtbyte ch;
2058 while ((ch = *cp) != 0) 2084 while ((ch = *cp) != 0)
2059 { 2085 {
2060 if (ch & 0x80) 2086 if (ch & 0x80)
2061 { 2087 {
2062 *mp++ = lb; 2088 mp += charset_codepoint_to_itext (charset, cp[0] & 0x7f,
2063 *mp++ = *cp++; 2089 cp[1] & 0x7f, mp,
2090 CONVERR_USE_PRIVATE);
2091 cp += 2;
2064 } 2092 }
2065 *mp++ = *cp++; 2093 else
2094 *mp++ = *cp++; /* Guaranteed ASCII */
2066 } 2095 }
2067 *mp = 0; 2096 *mp = 0;
2068 } 2097 }
2069 2098
2070 static int 2099 static int
2074 && !jl_dai_top (wnnfns_buf[server], no); no++); 2103 && !jl_dai_top (wnnfns_buf[server], no); no++);
2075 return (no); 2104 return (no);
2076 } 2105 }
2077 2106
2078 static int 2107 static int
2079 yes_or_no (unsigned char *s) 2108 yes_or_no (UExtbyte *s)
2080 { 2109 {
2081 unsigned char mbuf[512]; 2110 Ibyte mbuf[512];
2082 unsigned char lb; 2111 Lisp_Object charset;
2083 int len; 2112 int len;
2084 int snum; 2113 int snum;
2085 if ((snum = check_wnn_server_type ()) == -1) return 0; 2114 if ((snum = check_wnn_server_type ()) == -1) return 0;
2086 lb = lb_wnn_server_type[snum]; 2115 charset = charset_wnn_server_type[snum];
2087 /* if no message found, create file without query */ 2116 /* if no message found, create file without query */
2088 /* if (wnn_msg_cat->msg_bd == 0) return 1;*/ 2117 /* if (wnn_msg_cat->msg_bd == 0) return 1;*/
2089 if (*s == 0) return 1; 2118 if (*s == 0) return 1;
2090 c2m (s, mbuf, lb); 2119 c2m (s, mbuf, charset);
2091 /* truncate "(Y/N)" */ 2120 /* truncate "(Y/N)" */
2092 for (len = 0; (mbuf[len]) && (len < 512); len++); 2121 for (len = 0; (mbuf[len]) && (len < 512); len++);
2093 for (; (mbuf[len] != '(') && (len > 0); len--); 2122 for (; (mbuf[len] != '(') && (len > 0); len--);
2094 { 2123 {
2095 Lisp_Object yes, str; 2124 Lisp_Object yes, str;
2096 struct gcpro gcpro1; 2125 struct gcpro gcpro1;
2097 2126
2098 str = make_string (mbuf, len); 2127 str = make_string (mbuf, len);
2099 GCPRO1 (str); 2128 GCPRO1 (str);
2100 yes = call1(Qyes_or_no_p, str); 2129 yes = call1 (Qyes_or_no_p, str);
2101 UNGCPRO; 2130 UNGCPRO;
2102 if (NILP (yes)) return 0; 2131 if (NILP (yes)) return 0;
2103 else return (1); 2132 else return (1);
2104 } 2133 }
2105 } 2134 }
2106 2135
2107 static void 2136 static void
2108 puts2 (char *s) 2137 puts2 (char *UNUSED (s))
2109 { 2138 {
2110 #if 0 /* jhod: We don't really need this echoed... */ 2139 #if 0 /* jhod: We don't really need this echoed... */
2111 #if 0 2140 Ibyte mbuf[512];
2112 Lisp_Object args[1]; 2141 Lisp_Object charset;
2113 char mbuf[512];
2114 unsigned char lb;
2115 extern Lisp_Object Fmessage ();
2116 int snum; 2142 int snum;
2117 if ((snum = check_wnn_server_type ()) == -1) return; 2143 if ((snum = check_wnn_server_type ()) == -1) return;
2118 lb = lb_wnn_server_type[snum]; 2144 charset = charset_wnn_server_type[snum];
2119 c2m (s, mbuf, lb); 2145 c2m (s, mbuf, charset);
2120 args[0] = make_string (mbuf, strlen (mbuf)); 2146 message ("%s", mbuf);
2121 Fmessage (1, args);
2122 #else
2123 message("%s",s);
2124 #endif
2125 #endif 2147 #endif
2126 } 2148 }
2127 2149
2128 int 2150 int
2129 check_wnn_server_type (void) 2151 check_wnn_server_type (void)