1 /*
2 * $Id: jl.c,v 2.113.2.4 2000/09/01 09:31:20 kaneda Exp $
3 */
4
5 /*
6 WNN6 CLIENT LIBRARY--SOFTWARE LICENSE TERMS AND CONDITIONS
7
8
9 Wnn6 Client Library :
10 (C) Copyright OMRON Corporation. 1995,1998,2000 all rights reserved.
11 (C) Copyright OMRON Software Co., Ltd. 1995,1998,2000 all rights reserved.
12
13 Wnn Software :
14 (C) Copyright Kyoto University Research Institute for Mathematical Sciences
15 1987, 1988, 1989, 1990, 1991, 1992, 1993
16 (C) Copyright OMRON Corporation. 1987, 1988, 1989, 1990, 1991, 1992, 1993
17 (C) Copyright ASCTEC, Inc. 1987, 1988, 1989, 1990, 1991, 1992, 1993
18
19 Preamble
20
21 These Wnn6 Client Library--Software License Terms and Conditions
22 (the "License Agreement") shall state the conditions under which you are
23 permitted to copy, distribute or modify the software which can be used
24 to create Wnn6 Client Library (the "Wnn6 Client Library"). The License
25 Agreement can be freely copied and distributed verbatim, however, you
26 shall NOT add, delete or change anything on the License Agreement.
27
28 OMRON Corporation and OMRON Software Co., Ltd. (collectively referred to
29 as "OMRON") jointly developed the Wnn6 Software (development code name
30 is FI-Wnn), based on the Wnn Software. Starting from November, 1st, 1998,
31 OMRON publishes the source code of the Wnn6 Client Library, and OMRON
32 permits anyone to copy, distribute or change the Wnn6 Client Library under
33 the License Agreement.
34
35 Wnn6 Client Library is based on the original version of Wnn developed by
36 Kyoto University Research Institute for Mathematical Sciences (KURIMS),
37 OMRON Corporation and ASTEC Inc.
38
39 Article 1. Definition.
40
41 "Source Code" means the embodiment of the computer code, readable and
42 understandable by a programmer of ordinary skills. It includes related
43 source code level system documentation, comments and procedural code.
44
45 "Object File" means a file, in substantially binary form, which is directly
46 executable by a computer after linking applicable files.
47
48 "Library" means a file, composed of several Object Files, which is directly
49 executable by a computer after linking applicable files.
50
51 "Software" means a set of Source Code including information on its use.
52
53 "Wnn6 Client Library" the computer program, originally supplied by OMRON,
54 which can be used to create Wnn6 Client Library.
55
56 "Executable Module" means a file, created after linking Object Files or
57 Library, which is directly executable by a computer.
58
59 "User" means anyone who uses the Wnn6 Client Library under the License
60 Agreement.
61
62 Article 2. Copyright
63
64 2.1 OMRON Corporation and OMRON Software Co., Ltd. jointly own the Wnn6
65 Client Library, including, without limitation, its copyright.
66
67 2.2 Following words followed by the above copyright notices appear
68 in all supporting documentation of software based on Wnn6 Client Library:
69
70 This software is based on the original version of Wnn6 Client Library
71 developed by OMRON Corporation and OMRON Software Co., Ltd. and also based on
72 the original version of Wnn developed by Kyoto University Research Institute
73 for Mathematical Sciences (KURIMS), OMRON Corporation and ASTEC Inc.
74
75 Article 3. Grant
76
77 3.1 A User is permitted to make and distribute verbatim copies of
78 the Wnn6 Client Library, including verbatim of copies of the License
79 Agreement, under the License Agreement.
80
81 3.2 A User is permitted to modify the Wnn6 Client Library to create
82 Software ("Modified Software") under the License Agreement. A User
83 is also permitted to make or distribute copies of Modified Software,
84 including verbatim copies of the License Agreement with the following
85 information. Upon modifying the Wnn6 Client Library, a User MUST insert
86 comments--stating the name of the User, the reason for the modifications,
87 the date of the modifications, additional terms and conditions on the
88 part of the modifications if there is any, and potential risks of using
89 the Modified Software if they are known--right after the end of the
90 License Agreement (or the last comment, if comments are inserted already).
91
92 3.3 A User is permitted to create Library or Executable Modules by
93 modifying the Wnn6 Client Library in whole or in part under the License
94 Agreement. A User is also permitted to make or distribute copies of
95 Library or Executable Modules with verbatim copies of the License
96 Agreement under the License Agreement. Upon modifying the Wnn6 Client
97 Library for creating Library or Executable Modules, except for porting
98 a computer, a User MUST add a text file to a package of the Wnn6 Client
99 Library, providing information on the name of the User, the reason for
100 the modifications, the date of the modifications, additional terms and
101 conditions on the part of the modifications if there is any, and potential
102 risks associated with using the modified Wnn6 Client Library, Library or
103 Executable Modules if they are known.
104
105 3.4 A User is permitted to incorporate the Wnn6 Client Library in whole
106 or in part into another Software, although its license terms and
107 conditions may be different from the License Agreement, if such
108 incorporation or use associated with the incorporation does NOT violate
109 the License Agreement.
110
111 Article 4. Warranty
112
113 THE WNN6 CLIENT LIBRARY IS PROVIDED BY OMRON ON AN "AS IS" BAISIS.
114 OMRON EXPRESSLY DISLCIAMS ANY AND ALL WRRANTIES, EXPRESS OR IMPLIED,
115 INCLUDING, WITHOUT LIMITATION, WARRANTIES OF MERCHANTABILITY AND FITNESS
116 FOR A PARTICULAR PURPOSE, IN CONNECTION WITH THE WNN6 CLIENT LIBRARY
117 OR THE USE OR OTHER DEALING IN THE WNN6 CLIENT LIBRARY. IN NO EVENT
118 SHALL OMRON BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, PUNITIVE
119 OR CONSEQUENTIAL DAMAGES OF ANY KIND WHATSOEVER IN CONNECTION WITH THE
120 WNN6 CLIENT LIBRARY OR THE USE OR OTHER DEALING IN THE WNN6 CLIENT
121 LIBRARY.
122
123 ***************************************************************************
124 Wnn6 Client Library :
125 (C) Copyright OMRON Corporation. 1995,1998,2000 all rights reserved.
126 (C) Copyright OMRON Software Co., Ltd. 1995,1998,2000 all rights reserved.
127
128 Wnn Software :
129 (C) Copyright Kyoto University Research Institute for Mathematical Sciences
130 1987, 1988, 1989, 1990, 1991, 1992, 1993
131 (C) Copyright OMRON Corporation. 1987, 1988, 1989, 1990, 1991, 1992, 1993
132 (C) Copyright ASCTEC, Inc. 1987, 1988, 1989, 1990, 1991, 1992, 1993
133 ***************************************************************************
134
135 Comments on Modifications:
136 */
137
138 /* Version 4
139 */
140 /*
141 Nihongo Henkan Hi-level Library
142 */
143
144 #if defined(__DragonFly__)
145 #include <stdlib.h>
146 #include <string.h>
147 #include <unistd.h>
148 #include <sys/stat.h>
149 #include <time.h>
150 #endif
151
152 #include "commonhd.h"
153 #include "config.h"
154 #include <stdio.h>
155 #include <sys/types.h>
156 #ifdef SYSVR2
157 # include <string.h>
158 #endif
159 #ifdef BSD42
160 # include <strings.h>
161 #endif
162 #include <sys/file.h>
163 #include <ctype.h>
164 #include <pwd.h>
165
166 #include "wnnerror.h"
167 #include "jd_sock.h"
168 #include "jslib.h"
169 #include "jllib.h"
170 #include "mt_jlib.h"
171
172 #include "msg.h"
173 #include "serverdefs.h"
174 #include "wnn_string.h"
175 extern struct msg_cat *wnn_msg_cat;
176
177
178 #define MAXENVS WNN_MAX_ENV_OF_A_CLIENT
179
180 #define MAXINCLUDE 10
181
182 #define DEFAULT_BUN_LEN 3
183
184 #define DEFAULT_ZENKOUHO_LEN 3
185
186 #define DEFAULT_HEAP_LEN 3
187
188 #define INCREMENT 2
189
190 #define SHO 0
191 #define DAI 1
192 #define IKEIJI 2 /* ==WNN_IKEIJI */
193
194 #define BUN 0
195 #define ZENKOUHO 1 /* Must not change!, they are assigned to two bit flag */
196 #define ZENKOUHO_DAI 3 /* DAI << 1 | ZENKOUHO */
197 #define ZENKOUHO_IKEIJI_DAI 5 /* IKEIJI << 1 | ZENKOUHO */
198
199 #define if_dead_disconnect(env) \
200 { \
201 if (env_wnn_errorno_eql == WNN_JSERVER_DEAD) { \
202 jl_disconnect_if_server_dead_body((WNN_ENV_INT *)env);\
203 } \
204 }
205
206 #define if_dead_disconnect_b(buf) \
207 { \
208 if (buf_wnn_errorno_eql == WNN_JSERVER_DEAD) { \
209 jl_disconnect_if_server_dead_body((WNN_ENV_INT *) \
210 ((WNN_BUF_MT *)buf)->orig.env);\
211 ((WNN_BUF_MT *)buf)->orig.env = NULL; \
212 } \
213 }
214
215 #define ARGS char
216 #define env_wnn_errorno_set wnn_errorno
217 #define env_wnn_errorno_eql wnn_errorno
218 #define env_wnn_errorno_copy(env) {}
219 #define buf_wnn_errorno_set wnn_errorno
220 #define buf_wnn_errorno_eql wnn_errorno
221 #define buf_wnn_errorno_copy(buf) {}
222 #define env_rb rb
223 #define buf_rb rb
224
225 static struct wnn_ret_buf rb = {0, NULL};
226 static struct wnn_ret_buf dicrb = {0, NULL};
227 static struct wnn_ret_buf wordrb = {0, NULL};
228
229 static int dumbhinsi;
230 static w_char *mae_fzk;
231 static int syuutanv;
232 static int syuutanv1;
233
234 int confirm_state;
235 # ifdef KOREAN
236 static int kwnn_tankan = -1;
237 static int kwnn_hangul = -1;
238 static int kwnn_meisi = -1;
239 static int kwnn_fuzokugo = -1;
240 # endif /* KOREAN */
241 static int wnn_rendaku = -1;
242 static int wnn_settou = -1;
243 static int wnn_meisi = -1;
244 /* �ؽ�����ư�������ѳ��ꥫ������ */
245 static int kakutei_count = 0;
246
247 #define jl_get_yomi_body(buf, bun_no, bun_no2, area) \
248 wnn_get_area_body(buf, bun_no, bun_no2, area, WNN_YOMI)
249
250 #define jl_get_kanji_body(buf, bun_no, bun_no2, area) \
251 wnn_get_area_body(buf, bun_no, bun_no2, area, WNN_KANJI)
252
253 #define CONFIRM 1
254 #define CONFIRM1 2
255 #define CREATE_WITHOUT_CONFIRM 3
256 #define NO_CREATE 4
257
258 static void add_down_bnst();
259 static int alloc_heap();
260 static int call_error_handler();
261 static int change_ascii_to_int();
262 static int create_file();
263 static int dai_end();
264 static int expand_expr();
265 static int expand_expr_all();
266 static int file_discard();
267 static int file_exist();
268 static int file_read();
269 static int file_remove();
270 static int find_same_kouho();
271 static int find_same_kouho_dai();
272 static void free_bun();
273 static void free_down();
274 static void free_sho();
275 static void free_zenkouho();
276 static int get_c_jikouho();
277 static int get_c_jikouho_dai();
278 static int get_c_jikouho_from_zenkouho();
279 static int get_c_jikouho_from_zenkouho_dai();
280 static int get_pwd();
281 static int insert_dai();
282 static int insert_sho();
283 static int jl_set_env_wnnrc1_body();
284 static int jl_yomi_len_body();
285 static int make_dir1();
286 static int make_dir_rec1();
287 static void make_space_for();
288 static void make_space_for_bun();
289 static void make_space_for_zenkouho();
290 static void message_out();
291 static int ren_conv1(), ren_conv_sub();
292 static int nobi_conv_sub();
293 static void set_dai();
294 static void set_sho();
295 static int tan_conv1(), tan_conv_sub();
296 static int wnn_get_area_body();
297 static w_char *wnn_area();
298 static void _Sstrcpy();
299 static int jl_hinsi_number_e_body();
300 static int zen_conv_sho1();
301 static int zen_conv_dai1();
302 static int set_ima_off();
303 static int optimize_in_lib();
304 static int optimize_in_server();
305
306 static int insert_dai_or_ikeiji();
307 static int jl_dic_save_all_e_body();
308
309 /*
310 * Sub-routines to handle files, enviroments and connections.
311 */
312
313 struct wnn_file_name_id {
314 struct wnn_file_name_id *next;
315 int id;
316 char name[1];
317 };
318
319 struct wnn_jl_env{
320 WNN_JSERVER_ID *js;
321 struct wnn_env_int *env;
322 char env_n[WNN_ENVNAME_LEN];
323 char server_n[WNN_HOSTLEN];
324 char lang[32];
325 int ref_cnt;
326 struct wnn_file_name_id *file;
327 } envs[MAXENVS];
328
329 static void
initialize_envs()330 initialize_envs()
331 {
332 int i;
333 for (i = 0; i < MAXENVS; i++) {
334 envs[i].ref_cnt = 0;
335 }
336 }
337
338 /*
339 * File management routines.
340 */
341
342 static
find_jl_env(env)343 struct wnn_jl_env *find_jl_env(env)
344 register struct wnn_env_int *env;
345 {
346 register int k;
347 for(k = 0 ; k < MAXENVS; k++){
348 if(envs[k].env == env) return(envs + k);
349 }
350 return(NULL);
351 }
352
353
354 static
355 struct wnn_env_int *
find_env_of_same_js_id(js_id)356 find_env_of_same_js_id(js_id)
357 register WNN_JSERVER_ID *js_id;
358 {
359 register int k;
360
361 for(k = 0 ; k < MAXENVS; k++){
362 if (envs[k].js == NULL) continue;
363 if (envs[k].js->sd == js_id->sd){
364 return(envs[k].env);
365 }
366 }
367 return(NULL);
368 }
369
370 static
371 WNN_JSERVER_ID *
find_same_env_server(env_n,server_n,lang)372 find_same_env_server(env_n, server_n, lang)
373 register char *env_n, *server_n, *lang;
374 {
375 register int k;
376
377 if (server_n == NULL || lang == NULL) return(NULL);
378 for(k = 0 ; k < MAXENVS; k++){
379 if(strncmp(envs[k].server_n, server_n, WNN_HOSTLEN - 1) == 0 &&
380 strcmp(envs[k].lang, lang) == 0){
381 return(envs[k].js);
382 }
383 }
384 return(NULL);
385 }
386
387 static int
find_same_server_from_id(js)388 find_same_server_from_id(js)
389 register WNN_JSERVER_ID *js;
390 {
391 register int k;
392 for(k = 0 ; k < MAXENVS; k++){
393 if(envs[k].js == NULL) continue;
394 if(envs[k].js->sd == js->sd) return(1);
395 }
396 return(0);
397 }
398
399
400
401 static
402 struct wnn_env_int *
find_same_env(js,env_n,lang)403 find_same_env(js, env_n, lang)
404 register WNN_JSERVER_ID *js;
405 register char *env_n;
406 char *lang;
407 {
408 register int k;
409
410 if (env_n == NULL || lang == NULL) return(NULL);
411 for(k = 0 ; k < MAXENVS; k++){
412 if(envs[k].js == js && strcmp(envs[k].env_n, env_n) == 0
413 && strcmp(envs[k].lang, lang) == 0){
414 envs[k].ref_cnt++;
415 return(envs[k].env);
416 }
417 }
418 return(NULL);
419 }
420
421 static char *
env_name(env)422 env_name(env)
423 register struct wnn_env_int *env;
424 {
425 register int k;
426
427 for(k = 0 ; k < MAXENVS; k++){
428 if(envs[k].env == env){
429 return(envs[k].env_n);
430 }
431 }
432 return(NULL);
433 }
434
435
436 static void
add_new_env(js,env,env_n,server_n,lang)437 add_new_env(js, env, env_n, server_n, lang)
438 register WNN_JSERVER_ID *js;
439 register struct wnn_env_int *env;
440 char *env_n, *server_n, *lang;
441 {
442 register int k;
443
444 for(k = 0 ; k < MAXENVS; k++){
445 if(envs[k].ref_cnt == 0){
446 strncpy(envs[k].server_n, server_n, WNN_HOSTLEN - 1);
447 envs[k].server_n[WNN_HOSTLEN - 1] = '\0';
448 strncpy(envs[k].env_n, env_n, WNN_ENVNAME_LEN - 1);
449 envs[k].env_n[WNN_ENVNAME_LEN - 1] = '\0';
450 strncpy(envs[k].lang, lang, sizeof(envs[k].lang) - 1);
451 envs[k].lang[sizeof(envs[k].lang) - 1] = 0;
452 envs[k].js = js;
453 envs[k].env = env;
454 envs[k].ref_cnt = 1;
455 envs[k].file = NULL;
456 break;
457 }
458 }
459 }
460
461 static int
delete_env(env)462 delete_env(env)
463 register struct wnn_env_int *env;
464 {
465 register int k;
466
467 for(k = 0 ; k < MAXENVS; k++){
468 if(envs[k].env == env){
469 if(--envs[k].ref_cnt == 0){
470 strcpy(envs[k].server_n, "");
471 strcpy(envs[k].env_n, "");
472 strcpy(envs[k].lang, "");
473 envs[k].js = NULL;
474 envs[k].env = NULL;
475 return(1); /* Need To delete env */
476 }else{
477 return(0); /* Need not to delete env */
478 }
479 }
480 }
481 return(-1); /* This must not happen */
482 }
483
484 /* Routines to manipulate files */
485
486 static int
add_file_to_env(env,id,name)487 add_file_to_env(env, id, name)
488 struct wnn_env_int *env;
489 int id;
490 register char *name;
491 {
492 register struct wnn_file_name_id *f, *f1;
493 if((f = (struct wnn_file_name_id *)malloc(sizeof(struct wnn_file_name_id) +
494 strlen(name) + 1)) == NULL){
495 env_wnn_errorno_set=WNN_ALLOC_FAIL;
496 return(-1);
497 }
498 strcpy(f->name, name);
499 f->id = id;
500 LockMutex(&envs_lock);
501 f1 = find_jl_env(env)->file;
502 f->next = f1;
503 find_jl_env(env)->file = f;
504 UnlockMutex(&envs_lock);
505 return(0);
506 }
507
508 static char *
find_file_name_from_id(env,id)509 find_file_name_from_id(env, id)
510 struct wnn_env_int *env;
511 register int id;
512 {
513 register struct wnn_file_name_id *f;
514 f = find_jl_env(env)->file;
515 for(;f; f = f->next){
516 if(f->id == id){
517 return(f->name);
518 }
519 }
520 /* env_wnn_errorno_set=WNN_FILE_NOT_READ_FROM_CLIENT; */
521 return(NULL);
522 }
523
524 static int
delete_file_from_env(env,id)525 delete_file_from_env(env, id)
526 struct wnn_env_int *env;
527 register int id;
528 {
529 struct wnn_file_name_id *f;
530 register struct wnn_file_name_id **prev;
531 register struct wnn_jl_env *jl_env_p;
532
533 LockMutex(&envs_lock);
534 jl_env_p = find_jl_env(env);
535 if (!jl_env_p->file) {
536 UnlockMutex(&envs_lock);
537 return(0);
538 }
539 for(prev = &jl_env_p->file; (f = *prev); prev = &f->next){
540 if (f->id == id) {
541 *prev = f->next;
542 free(f);
543 UnlockMutex(&envs_lock);
544 return(0);
545 }
546 }
547 UnlockMutex(&envs_lock);
548 env_wnn_errorno_set=WNN_FILE_NOT_READ_FROM_CLIENT;
549 return(-1);
550 }
551
552 /*
553 * Libraries which handle Connection To Jserver
554 */
555
556 struct wnn_env *
jl_connect_lang(env_n,server_n,lang,wnnrc_n,error_handler,message_handler,timeout)557 jl_connect_lang(env_n, server_n, lang, wnnrc_n, error_handler, message_handler, timeout)
558 register char *env_n, *server_n, *wnnrc_n, *lang;
559 int (*error_handler)(), (*message_handler)();
560 int timeout;
561 {
562 register WNN_JSERVER_ID *js = NULL;
563 struct wnn_env_int *env;
564 int env_exist, cnt;
565 char p_lang[16];
566 register char *p, *l;
567 static int initialized_envs = 0;
568 extern char *getenv();
569
570 DoOnce( &once, _InitMutexs );
571 LockMutex(&open_lock);
572 if (!initialized_envs) {
573 initialize_envs();
574 initialized_envs = 1;
575 }
576
577 wnn_errorno = 0;
578 /* if lang not specified use $LANG */
579 if(!lang || !*lang){
580 lang = getenv("LANG");
581 }
582 if (!lang || !*lang){
583 /* Sorry! Default is Japanese. :-) */
584 strcpy(p_lang, "ja_JP");
585
586 } else {
587 /* Use only [language]_[teritorry] */
588 for(p = p_lang, l = lang, cnt = 0;
589 (*l != '@') && (*l != '.') && (*l != 0) &&
590 (cnt < sizeof(p_lang) - 1)
591 ; p++, l++, cnt++)
592 *p = *l;
593 *p = 0;
594 }
595
596 LockMutex(&envs_lock);
597 /* To See serverdefs file when server_n is not specified. */
598 if(!server_n || !*server_n){
599 /* find server machine name from table by lang */
600 if ((server_n = wnn_get_machine_of_serverdefs(p_lang))) {
601 if((js = find_same_env_server(env_n, server_n, p_lang)) == NULL){
602 if((js = js_open_lang(server_n, p_lang, timeout)) == NULL){
603 server_n = NULL;
604 }
605 }
606 }
607 if (!server_n || !*server_n) {
608 server_n = "unix";
609 }
610 }
611
612 if (js == NULL) {
613 if((js = find_same_env_server(env_n, server_n, p_lang)) == NULL){
614 if((js = js_open_lang(server_n, p_lang, timeout)) == NULL){
615 UnlockMutex(&envs_lock);
616 UnlockMutex(&open_lock);
617 return(NULL);
618 }
619 /* js_hinsi_list(js); */
620 }
621 }
622 if ((env_exist = js_env_exist(js, env_n)) < 0) {
623 UnlockMutex(&envs_lock);
624 UnlockMutex(&open_lock);
625 return (NULL);
626 }
627 if((env = find_same_env(js, env_n, p_lang)) == NULL){ /* Incr ref_cnt */
628 if((env = (WNN_ENV_INT *)js_connect_lang(js, env_n, p_lang)) == NULL){
629 UnlockMutex(&envs_lock);
630 UnlockMutex(&open_lock);
631 return(NULL);
632 }
633 InitMutex(&(env->env_lock));
634 # ifdef KOREAN
635 if(!strncmp(lang, WNN_K_LANG, 5)) {
636 w_char tmp[8];
637 _Sstrcpy(tmp, "Ӥ�"); kwnn_tankan = jl_hinsi_number_e_body(env, tmp);
638 _Sstrcpy(tmp, "�ѱ�"); kwnn_hangul = jl_hinsi_number_e_body(env, tmp);
639 _Sstrcpy(tmp, "٣��"); kwnn_meisi = jl_hinsi_number_e_body(env, tmp);
640 _Sstrcpy(tmp, "ݾ����"); kwnn_fuzokugo = jl_hinsi_number_e_body(env, tmp);
641 }
642 # endif /* KOREAN */
643 if(!strncmp(lang, WNN_J_LANG, 5)) {
644 w_char tmp[8];
645 _Sstrcpy(tmp, WNN_HINSI_RENDAKU);
646 wnn_rendaku = jl_hinsi_number_e_body(env, tmp);
647 _Sstrcpy(tmp, WNN_HINSI_SETTOUO);
648 wnn_settou = jl_hinsi_number_e_body(env, tmp);
649 _Sstrcpy(tmp, WNN_HINSI_MEISI);
650 wnn_meisi = jl_hinsi_number_e_body(env, tmp);
651 }
652 add_new_env(js, env, env_n, server_n, p_lang);
653 }
654 UnlockMutex(&envs_lock);
655 if(env_exist == 0 && wnnrc_n){
656 jl_set_env_wnnrc(env, wnnrc_n, error_handler, message_handler);
657 } else {
658 unsigned long mask = WNN_ENV_BUNSETSUGIRI_LEARN_MASK |
659 WNN_ENV_MUHENKAN_LEARN_MASK;
660 struct wnn_henkan_env henv;
661 if(wnnrc_n)
662 jl_set_env_wnnrc1_body(env, wnnrc_n, error_handler,
663 message_handler, 0, 1);
664 if(js_get_henkan_env(env, &henv) == 0) {
665 env->orig.muhenkan_mode = henv.muhenkan_flag;
666 env->orig.bunsetsugiri_mode = henv.bunsetsugiri_flag;
667 } else {
668 env->orig.muhenkan_mode = WNN_DIC_RDONLY;
669 env->orig.bunsetsugiri_mode = WNN_DIC_RDONLY;
670 }
671 }
672 UnlockMutex(&open_lock);
673 return((struct wnn_env *)env);
674 }
675
676
677 static void
jl_disconnect_body(env)678 jl_disconnect_body(env)
679 register struct wnn_env_int *env;
680 {
681 int ret;
682
683 env_wnn_errorno_set = 0;
684 LockMutex(&envs_lock);
685 if((ret = delete_env(env)) < 0){
686 UnlockMutex(&envs_lock);
687 return;
688 } else if (ret) {
689 js_disconnect((WNN_ENV *)env);
690 }
691 if(!find_same_server_from_id(env->orig.js_id)){
692 js_close(env->orig.js_id);
693 env->orig.js_id = 0;
694 }
695 UnlockMutex(&envs_lock);
696 }
697
698 void
jl_disconnect(env)699 jl_disconnect(env)
700 register struct wnn_env *env;
701 {
702 if(!env) return;
703 LockMutex(&ENV_LOCK(env));
704 jl_disconnect_body((WNN_ENV_INT *)env);
705 UnlockMutex(&ENV_LOCK(env));
706 }
707
708 int
jl_isconnect_e(env)709 jl_isconnect_e(env)
710 register struct wnn_env *env;
711 {
712 if(!env) return(0);
713 LockMutex(&ENV_LOCK(env));
714 if (js_isconnect(env) == 0) {
715 UnlockMutex(&ENV_LOCK(env));
716 return(1);
717 } else {
718 UnlockMutex(&ENV_LOCK(env));
719 return (0);
720 }
721 }
722
723 int
jl_isconnect(buf)724 jl_isconnect(buf)
725 register struct wnn_buf *buf;
726 {
727 int x;
728
729 if(!buf) return(0);
730 LockMutex(&BUF_LOCK(buf));
731 x = jl_isconnect_e(buf->env);
732 UnlockMutex(&BUF_LOCK(buf));
733 return x;
734 }
735
736 /* JSERVER �������� env �� disconnect ���Ʋ�� */
737 static void
jl_disconnect_if_server_dead_body(env)738 jl_disconnect_if_server_dead_body(env)
739 register struct wnn_env *env;
740 {
741 register struct wnn_env_int *same_env;
742 int ret;
743
744 LockMutex(&envs_lock);
745 if((ret = delete_env((WNN_ENV_INT *)env)) < 0){
746 UnlockMutex(&envs_lock);
747 return;
748 } else if (ret) {
749 js_disconnect(env);
750 }
751
752 while ((same_env = find_env_of_same_js_id(env->js_id)) != 0) {
753 if(delete_env(same_env)){
754 LockMutex(&(same_env->env_lock));
755 js_disconnect((WNN_ENV *)same_env);
756 UnlockMutex(&(same_env->env_lock));
757 }
758 }
759 UnlockMutex(&envs_lock);
760
761 js_close(env->js_id);
762
763 /* jserver ��������Ǥ� js_id ���Ȥ���ؿ���¸�ߤ���Τǡ�
764 NULL �ݥ���������ϹԤ鷺��js_dead �ե饰�ˤ�� jserver ��
765 ���Ǥ��뤫�ɤ����Υ����å���Ԥ� */
766 /* env->js_id = 0; */
767 }
768
769
770 void
jl_disconnect_if_server_dead(env)771 jl_disconnect_if_server_dead(env)
772 register struct wnn_env *env;
773 {
774 if(!env) return;
775 LockMutex(&ENV_LOCK(env));
776 jl_disconnect_if_server_dead_body((WNN_ENV_INT *)env);
777 UnlockMutex(&ENV_LOCK(env));
778 }
779
780 struct wnn_buf *
jl_open_lang(env_n,server_n,lang,wnnrc_n,error_handler,message_handler,timeout)781 jl_open_lang(env_n, server_n, lang, wnnrc_n, error_handler, message_handler, timeout)
782 char *env_n, *server_n, *wnnrc_n, *lang;
783 int (*error_handler)(), (*message_handler)();
784 int timeout;
785 {
786 register int k, dmy;
787 register struct wnn_buf_mt *buf;
788 struct wnn_env *env;
789
790 wnn_errorno = 0;
791 if(rb.size == 0) rb.buf = (char *)malloc((unsigned)(rb.size = 1024));
792
793 #define ALLOC_SET(pter, type, size, size_var) \
794 ((pter) = ((type *)malloc((unsigned)(sizeof(type) * ((size_var) = (size))))))
795
796 if(!ALLOC_SET(buf, struct wnn_buf_mt, 1, dmy)){
797 wnn_errorno=WNN_ALLOC_FAIL;return NULL;
798 }
799
800 buf->orig.bun_suu = 0;
801 buf->orig.zenkouho_suu = 0;
802 buf->orig.zenkouho_daip = 0;
803 buf->orig.c_zenkouho = -1;
804 buf->orig.zenkouho_bun = -1;
805 buf->orig.zenkouho_end_bun = -1;
806 buf->orig.free_heap = NULL;
807 buf->orig.heap = NULL;
808 buf->orig.zenkouho_dai_suu = 0;
809 buf->orig.env = NULL;
810 /*
811 * Hideyuki Kishiba (Sep. 20, 1994)
812 * ���ѣƣɴط���������ѹ�¤�Τ���������
813 */
814 buf->orig.fi_rb.size = buf->orig.fi_rb.num = 0;
815 buf->orig.fi_rb.fi_buf = NULL;
816 /* ľ�������������ν���� */
817 for(k = 0; k < WNN_PREV_BUN_SUU; k++) {
818 buf->orig.prev_bun[k].dic_no = -2;
819 buf->orig.prev_bun[k].real_kanjilen = 0;
820 buf->orig.prev_bun[k].kouho[0] = 0;
821 }
822
823 if(!ALLOC_SET(buf->orig.bun, WNN_BUN *, DEFAULT_BUN_LEN, buf->orig.msize_bun) ||
824 !ALLOC_SET(buf->orig.zenkouho_dai, int, DEFAULT_ZENKOUHO_LEN + 1, buf->orig.msize_zenkouho) ||
825 !ALLOC_SET(buf->orig.zenkouho, WNN_BUN *, DEFAULT_ZENKOUHO_LEN, buf->orig.msize_zenkouho) ||
826 !ALLOC_SET(buf->orig.down_bnst, WNN_BUN *, DEFAULT_BUN_LEN, buf->orig.msize_bun)
827 ){
828 wnn_errorno=WNN_ALLOC_FAIL;return NULL;
829 }
830
831 for(k = 0 ; k < DEFAULT_BUN_LEN ; k++){
832 buf->orig.down_bnst[k] = NULL;
833 }
834
835 if(alloc_heap(buf, DEFAULT_HEAP_LEN) == -1){
836 return NULL;
837 }
838
839 env = jl_connect_lang(env_n, server_n, lang, wnnrc_n, error_handler, message_handler, timeout);
840 buf->orig.env = env;
841 InitMutex(&BUF_LOCK(buf));
842
843 return((struct wnn_buf *)buf);
844 }
845
846
847 static void
_Sstrcpy(ws,s)848 _Sstrcpy(ws, s)
849 w_char *ws;
850 unsigned char *s;
851 {
852 register int eesiz = -1;
853 register unsigned char x;
854 register w_char *ie;
855 register unsigned char *ee;
856 register int cs_id, non_limit = 1;
857 int _etc_cs[3];
858 int cs_mask[3];
859
860 _etc_cs[0] = 2;
861 _etc_cs[1] = 1;
862 _etc_cs[2] = 2;
863 cs_mask[0] = 0x8080;
864 cs_mask[1] = 0x0080;
865 cs_mask[2] = 0x8000;
866 ie=ws;ee=s;
867
868 for(;(non_limit?(*ee):(eesiz>0));){
869 x = *ee++;
870 if(x > 0x9f || x == 0x8e || x == 0x8f){
871 cs_id = ((x == 0x8e)? 1 : ((x == 0x8f)? 2: 0));
872 if (cs_id == 1 || cs_id == 2) x = *ee++;
873 if (_etc_cs[cs_id] <= 0) continue;
874 if (_etc_cs[cs_id] > 1) {
875 *ie = (w_char)(x & 0x7f) << 8;
876 x = *ee++;
877 } else {
878 *ie = (w_char)0;
879 }
880 *ie |= (x & 0x7f);
881 *ie++ |= cs_mask[cs_id];
882 eesiz -= _etc_cs[cs_id] + 1;
883 }else{
884 *ie++ = x;
885 eesiz--;
886 }
887 }
888
889 non_limit = ((char *)ie - (char *)ws) / sizeof(w_char);
890 ws[non_limit] = 0;
891 }
892
893 static int
alloc_heap(buf,len)894 alloc_heap(buf, len)
895 struct wnn_buf_mt *buf;
896 register int len;
897 {
898 char **c;
899 register WNN_BUN *d;
900
901 if((c =(char **)malloc((unsigned)(len * sizeof(WNN_BUN) + sizeof(char *)))) == NULL){
902 buf_wnn_errorno_set=WNN_ALLOC_FAIL;
903 return(-1);
904 }
905
906 *c = buf->orig.heap;
907 buf->orig.heap = (char *)c;
908 d = (WNN_BUN *)(c + 1);
909 for(--len; len > 0 ; len--, d++){
910 d->free_next = d + 1;
911 }
912 d->free_next = buf->orig.free_heap;
913 buf->orig.free_heap = (WNN_BUN *)(c + 1);
914 return(0);
915 }
916
917 void
jl_close(buf)918 jl_close(buf)
919 register struct wnn_buf *buf;
920 {
921 register char *c, *next;
922 struct wnn_buf_mt tmpbuf;
923
924 if(buf == NULL) return;
925 tmpbuf = *(WNN_BUF_MT *)buf;
926 LockMutex(&(tmpbuf.buf_lock));
927 if(buf->env){
928 LockMutex(&(envmt->env_lock));
929 buf_wnn_errorno_set = 0;
930 jl_disconnect_body((WNN_ENV_INT *)buf->env);
931 UnlockMutex(&(envmt->env_lock));
932 buf->env = 0;
933 }
934
935 if(buf->bun) free((char *)buf->bun);
936 if(buf->zenkouho) free((char *)buf->zenkouho);
937 if(buf->zenkouho_dai) free((char *)buf->zenkouho_dai);
938 if(buf->down_bnst) free((char *)buf->down_bnst);
939 for(c = buf->heap; c; c = next) {
940 next = *(char **)c;
941 free(c);
942 }
943 free((char *)buf);
944 UnlockMutex(&(tmpbuf.buf_lock));
945 }
946
947 /*
948 * Conversion Libraries
949 */
950
951 /*:::DOC_START
952 *
953 * Function Name: jl_ren_conv
954 * Description : Ϣʸ���Ѵ���Ԥ�
955 * Parameter :
956 * buf : (InOut) �Хåե��ؤΥݥ���
957 * yomi : (In) �Ѵ��ɤ�ʸ����ؤΥݥ���
958 * bun_no : (In) �������ʸ�����Ƭʸ���ֹ�
959 * bun_no2 : (In) �������ʸ��κǽ�ʸ���ľ���ʸ���ֹ�
960 * use_maep : (In) �������³��ʻȤ����ݡ˥ե饰
961 *
962 * Return value : -1==ERROR, else �Ѵ�ʸ���
963 *
964 * Author : Hideyuki Kishiba
965 *
966 * Revision history:
967 * 16-May-96: �߾�: ���Ѻѣƣɴط��ǡ���������
968 *
969 *:::DOC_END
970 */
971 int
jl_ren_conv(buf,yomi,bun_no,bun_no2,use_maep)972 jl_ren_conv(buf, yomi, bun_no, bun_no2, use_maep)
973 register struct wnn_buf *buf;
974 register w_char *yomi;
975 int bun_no, bun_no2;
976 int use_maep;
977 {
978 int x;
979
980 if(!buf) return(-1);
981 LockMutex(&BUF_LOCK(buf));
982 buf_wnn_errorno_set = 0;
983
984 /* ���Ѻѣƣɴط��ǡ������������롣 05/16/96 H.Kishiba */
985 buf->fi_rb.num = 0;
986
987 if(bun_no < 0) {
988 UnlockMutex(&BUF_LOCK(buf));
989 return(-1);
990 }
991
992 x = ren_conv_sub((WNN_BUF_MT *)buf, yomi, bun_no, bun_no2, use_maep,
993 0, 0, NULL, 0);
994 UnlockMutex(&BUF_LOCK(buf));
995 return x;
996 } /* End of jl_ren_conv */
997
998 /*:::DOC_START
999 *
1000 * Function Name: jl_ren_conv_with_hinsi_name
1001 * Description : �Ѵ��˻��Ѥ����ʻ����ꤷ��Ϣʸ���Ѵ���Ԥ�
1002 * Parameter :
1003 * buf : (InOut) �Хåե��ؤΥݥ���
1004 * yomi : (In) �Ѵ��ɤ�ʸ����ؤΥݥ���
1005 * bun_no : (In) �������ʸ�����Ƭʸ���ֹ�
1006 * bun_no2 : (In) �������ʸ��κǽ�ʸ���ľ���ʸ���ֹ�
1007 * use_maep : (In) �������³��ʻȤ����ݡ˥ե饰
1008 * nhinsi : (In) �ʻ�����Ѵ����λ����ʻ��
1009 * hlist : (In) �ʻ�����Ѵ����λ����ʻ�̾����ؤΥݥ���
1010 *
1011 * Return value : -1==ERROR, else �Ѵ�ʸ���
1012 *
1013 * Author : Hideyuki Kishiba
1014 *
1015 * Revision history:
1016 * 16-May-96: �߾�: ���Ѻѣƣɴط��ǡ���������
1017 *
1018 *:::DOC_END
1019 */
1020 int
jl_ren_conv_with_hinsi_name(buf,yomi,bun_no,bun_no2,use_maep,nhinsi,hname)1021 jl_ren_conv_with_hinsi_name(buf, yomi, bun_no, bun_no2, use_maep, nhinsi, hname)
1022 register struct wnn_buf *buf;
1023 register w_char *yomi;
1024 int bun_no, bun_no2;
1025 int use_maep, nhinsi;
1026 char **hname;
1027 {
1028 int x, i, hsize, *hno = NULL;
1029 w_char tmp[64];
1030
1031 if(!buf) return(-1);
1032 LockMutex(&BUF_LOCK(buf));
1033 buf_wnn_errorno_set = 0;
1034
1035 /* ���Ѻѣƣɴط��ǡ������������롣 05/16/96 H.Kishiba */
1036 buf->fi_rb.num = 0;
1037
1038 if(bun_no < 0) {
1039 UnlockMutex(&BUF_LOCK(buf));
1040 return(-1);
1041 }
1042 if(nhinsi) {
1043 hsize = abs(nhinsi);
1044 hno = (int *)malloc(hsize * sizeof(int));
1045 for(i = 0; i < hsize; i++) {
1046 _Sstrcpy(tmp, hname[i]);
1047 if((hno[i] = jl_hinsi_number_e(buf->env, tmp)) == -1) {
1048 free((char *)hno);
1049 UnlockMutex(&BUF_LOCK(buf));
1050 return(-1);
1051 }
1052 }
1053 }
1054
1055 x = ren_conv_sub((WNN_BUF_MT *)buf, yomi, bun_no, bun_no2, use_maep,
1056 0, nhinsi, hno, 0);
1057 if(nhinsi) free((char *)hno);
1058 UnlockMutex(&BUF_LOCK(buf));
1059 return x;
1060 } /* End of jl_ren_conv_with_hinsi_name */
1061
1062 /*:::DOC_START
1063 *
1064 * Function Name: jl_fi_ren_conv
1065 * Description : Ϣʸ��ƣ��Ѵ���Ԥ�
1066 * Parameter :
1067 * buf : (InOut) �Хåե��ؤΥݥ���
1068 * yomi : (In) �Ѵ��ɤ�ʸ����ؤΥݥ���
1069 * bun_no : (In) �������ʸ�����Ƭʸ���ֹ�
1070 * bun_no2 : (In) �������ʸ��κǽ�ʸ���ľ���ʸ���ֹ�
1071 * use_maep : (In) �������³��ʻȤ����ݡ˥ե饰
1072 *
1073 * Return value : -1==ERROR, else �Ѵ�ʸ���
1074 *
1075 * Author : Hideyuki Kishiba
1076 *
1077 * Revision history:
1078 * 16-May-96: �߾�: ���Ѻѣƣɴط��ǡ���������
1079 *
1080 *:::DOC_END
1081 */
1082 int
jl_fi_ren_conv(buf,yomi,bun_no,bun_no2,use_maep)1083 jl_fi_ren_conv(buf, yomi, bun_no, bun_no2, use_maep)
1084 register struct wnn_buf *buf;
1085 register w_char *yomi;
1086 int bun_no, bun_no2;
1087 int use_maep;
1088 {
1089 int x;
1090
1091 if(!buf) return(-1);
1092 LockMutex(&BUF_LOCK(buf));
1093 buf_wnn_errorno_set = 0;
1094
1095 /* ���Ѻѣƣɴط��ǡ������������롣 05/16/96 H.Kishiba */
1096 buf->fi_rb.num = 0;
1097
1098 if(bun_no < 0) {
1099 UnlockMutex(&BUF_LOCK(buf));
1100 return(-1);
1101 }
1102
1103 x = ren_conv_sub((WNN_BUF_MT *)buf, yomi, bun_no, bun_no2, use_maep,
1104 0, 0, NULL, 1);
1105 UnlockMutex(&BUF_LOCK(buf));
1106 return x;
1107 } /* End of jl_fi_ren_conv */
1108
1109 /*:::DOC_START
1110 *
1111 * Function Name: ren_conv_sub
1112 * Description : Ϣʸ���Ѵ��Υ��֥롼����ؿ����Σ�
1113 * Parameter :
1114 * buf : (InOut) �Хåե��ؤΥݥ���
1115 * yomi : (In) �Ѵ��ɤ�ʸ����ؤΥݥ���
1116 * bun_no : (In) �������ʸ�����Ƭʸ���ֹ�
1117 * bun_no2 : (In) �������ʸ��κǽ�ʸ���ľ���ʸ���ֹ�
1118 * use_maep : (In) �������³��ʻȤ����ݡ˥ե饰
1119 * fuku : (In) ʣ���ͥ���Ѵ��ե饰
1120 * nhinsi : (In) �ʻ�����Ѵ����λ����ʻ��
1121 * hlist : (In) �ʻ�����Ѵ����λ����ʻ��ֹ�����ؤΥݥ���
1122 * fi_flag : (In) ���Ѥ����ƣɴط������ʼ������ʤ���
1123 * �������˥ե饰
1124 *
1125 * Return value : -1==ERROR, else �Ѵ�ʸ���
1126 *
1127 * Author : Hideyuki Kishiba
1128 *
1129 * Revision history:
1130 *
1131 *:::DOC_END
1132 */
1133 static int
ren_conv_sub(buf,yomi,bun_no,bun_no2,use_maep,fuku,nhinsi,hlist,fi_flag)1134 ren_conv_sub(buf, yomi, bun_no, bun_no2, use_maep, fuku, nhinsi, hlist, fi_flag)
1135 register struct wnn_buf *buf;
1136 w_char *yomi;
1137 register int bun_no, bun_no2;
1138 int use_maep, fuku, nhinsi, *hlist, fi_flag;
1139 {
1140 int x;
1141
1142 if(bun_no2 >= buf->bun_suu || bun_no2 < 0) bun_no2 = buf->bun_suu;
1143 free_down(buf, bun_no, bun_no2);
1144 x = ren_conv1((WNN_BUF_MT *)buf, yomi, bun_no, bun_no2, use_maep,
1145 fuku, nhinsi, hlist, fi_flag);
1146 return x;
1147 } /* End of ren_conv_sub */
1148
1149 /*:::DOC_START
1150 *
1151 * Function Name: ren_conv1
1152 * Description : Ϣʸ���Ѵ��Υ��֥롼����ؿ����Σ�
1153 * Parameter :
1154 * buf : (InOut) �Хåե��ؤΥݥ���
1155 * yomi : (In) �Ѵ��ɤ�ʸ����ؤΥݥ���
1156 * bun_no : (In) �������ʸ�����Ƭʸ���ֹ�
1157 * bun_no2 : (In) �������ʸ��κǽ�ʸ���ľ���ʸ���ֹ�
1158 * use_maep : (In) �������³��ʻȤ����ݡ˥ե饰
1159 * fuku : (In) ʣ���ͥ���Ѵ��ե饰
1160 * nhinsi : (In) �ʻ�����Ѵ����λ����ʻ��
1161 * hlist : (In) �ʻ�����Ѵ����λ����ʻ��ֹ�����ؤΥݥ���
1162 * fi_flag : (In) ���Ѥ����ƣɴط������ʼ������ʤ���
1163 * �������˥ե饰
1164 *
1165 * Return value : -1==ERROR, else �Ѵ�ʸ���
1166 *
1167 * Author : Hideyuki Kishiba
1168 *
1169 * Revision history:
1170 *
1171 *:::DOC_END
1172 */
1173 static int
ren_conv1(buf,yomi,bun_no,bun_no2,use_maep,fuku,nhinsi,hlist,fi_flag)1174 ren_conv1(buf, yomi, bun_no, bun_no2, use_maep, fuku, nhinsi, hlist, fi_flag)
1175 register struct wnn_buf_mt *buf;
1176 w_char *yomi;
1177 register int bun_no, bun_no2;
1178 int use_maep, fuku, nhinsi, *hlist, fi_flag;
1179 {
1180 int dcnt;
1181 struct wnn_dai_bunsetsu *dp;
1182 int size;
1183 w_char yomi1[LENGTHBUNSETSU];
1184
1185 if (yomi == NULL || *yomi == (w_char)0) return(0);
1186 if(bun_no2 >= buf->orig.bun_suu || bun_no2 < 0)
1187 bun_no2 = buf->orig.bun_suu;
1188
1189 if (use_maep & WNN_USE_MAE && bun_no > 0) {
1190 dumbhinsi = buf->orig.bun[bun_no - 1]->hinsi;
1191 jl_get_yomi_body(buf, bun_no - 1, bun_no, yomi1);
1192 mae_fzk = yomi1 + buf->orig.bun[bun_no - 1]->jirilen;
1193 } else {
1194 dumbhinsi = WNN_BUN_SENTOU;
1195 mae_fzk = (w_char *)0;
1196 }
1197 if(use_maep & WNN_USE_ATO && bun_no2 < buf->orig.bun_suu){
1198 syuutanv = buf->orig.bun[bun_no2]->kangovect;
1199 syuutanv1 = WNN_VECT_KANREN;
1200 }else{
1201 syuutanv = WNN_VECT_KANREN;
1202 syuutanv1 = WNN_VECT_NO;
1203 if(bun_no2 < buf->orig.bun_suu){
1204 buf->orig.bun[bun_no2]->dai_top = 1;
1205 }
1206 }
1207 if(!(buf->orig.env)) return(-1);
1208 LockMutex(&(envmt->env_lock));
1209 if(fuku == 0 && nhinsi == 0) {
1210 if(fi_flag == 0) {
1211 /* Ϣʸ���Ѵ� */
1212 if((dcnt = js_kanren(buf->orig.env, yomi, dumbhinsi, mae_fzk,
1213 syuutanv, syuutanv1, WNN_VECT_BUNSETSU,
1214 &buf_rb)) < 0){
1215 buf_wnn_errorno_copy(buf);
1216 if_dead_disconnect_b(buf);
1217 UnlockMutex(&(envmt->env_lock));
1218 return(-1);
1219 }
1220 } else {
1221 /* Ϣʸ��ƣ��Ѵ� */
1222 if((dcnt = js_fi_kanren(buf->orig.env, yomi, dumbhinsi, mae_fzk,
1223 syuutanv, syuutanv1, WNN_VECT_BUNSETSU,
1224 buf->orig.prev_bun, &buf_rb, &(buf->orig.fi_rb))) < 0){
1225 buf_wnn_errorno_copy(buf);
1226 if_dead_disconnect_b(buf);
1227 UnlockMutex(&(envmt->env_lock));
1228 return(-1);
1229 }
1230 }
1231 } else {
1232 /* �Ѵ��Ķ�����Ϣʸ���Ѵ� */
1233 if((dcnt = js_henkan_with_data(buf->orig.env, fuku, nhinsi, hlist,
1234 WNN_KANREN, yomi, dumbhinsi, mae_fzk,
1235 syuutanv, syuutanv1, WNN_VECT_BUNSETSU, &buf_rb)) < 0) {
1236 buf_wnn_errorno_copy(buf);
1237 if_dead_disconnect_b(buf);
1238 UnlockMutex(&(envmt->env_lock));
1239 return(-1);
1240 }
1241 }
1242
1243 dp = (struct wnn_dai_bunsetsu *)buf_rb.buf;
1244
1245 free_bun(buf, bun_no, bun_no2);
1246
1247 if(use_maep & WNN_USE_ATO && bun_no2 < buf->orig.bun_suu){
1248 buf->orig.bun[bun_no2]->dai_top =
1249 (dp[dcnt-1].sbn[dp[dcnt-1].sbncnt-1].status_bkwd == WNN_CONNECT_BK)? 0:1;
1250 }
1251
1252 size = insert_dai(buf, BUN, bun_no, bun_no2, dp, dcnt, 0, fuku, nhinsi, hlist);
1253 if(buf->orig.zenkouho_end_bun > bun_no && buf->orig.zenkouho_bun < bun_no2){
1254 free_zenkouho(buf);
1255 }else if(buf->orig.zenkouho_bun >= bun_no2){
1256 buf->orig.zenkouho_bun += size - bun_no2;
1257 buf->orig.zenkouho_end_bun += size - bun_no2;
1258
1259 }
1260 UnlockMutex(&(envmt->env_lock));
1261 return(buf->orig.bun_suu);
1262 } /* End of ren_conv1 */
1263
1264 /*:::DOC_START
1265 *
1266 * Function Name: jl_tan_conv
1267 * Description : ñʸ���Ѵ���Ԥ�
1268 * Parameter :
1269 * buf : (InOut) �Хåե��ؤΥݥ���
1270 * yomi : (In) �Ѵ��ɤ�ʸ����ؤΥݥ���
1271 * bun_no : (In) �������ʸ�����Ƭʸ���ֹ�
1272 * bun_no2 : (In) �������ʸ��κǽ�ʸ���ľ���ʸ���ֹ�
1273 * use_maep : (In) �������³��ʻȤ����ݡ˥ե饰
1274 * ich_shop : (In) �ʾ�ʸ���ʸ����Ѵ��ե饰
1275 *
1276 * Return value : -1==ERROR, else �Ѵ�ʸ���
1277 *
1278 * Author : Hideyuki Kishiba
1279 *
1280 * Revision history:
1281 * 16-May-96: �߾�: ���Ѻѣƣɴط��ǡ���������
1282 *
1283 *:::DOC_END
1284 */
1285 int
jl_tan_conv(buf,yomi,bun_no,bun_no2,use_maep,ich_shop)1286 jl_tan_conv(buf, yomi, bun_no, bun_no2, use_maep, ich_shop)
1287 register struct wnn_buf *buf;
1288 w_char *yomi;
1289 register int bun_no, bun_no2;
1290 int use_maep, ich_shop;
1291 {
1292 int x;
1293
1294 if(!buf) return(-1);
1295 LockMutex(&BUF_LOCK(buf));
1296 buf_wnn_errorno_set = 0;
1297
1298 /* ���Ѻѣƣɴط��ǡ������������롣 05/16/96 H.Kishiba */
1299 buf->fi_rb.num = 0;
1300
1301 if(bun_no < 0) {
1302 UnlockMutex(&BUF_LOCK(buf));
1303 return(-1);
1304 }
1305
1306 if(tan_conv_sub((WNN_BUF_MT *)buf, yomi, bun_no, bun_no2, use_maep,
1307 ich_shop, 0, 0, NULL) == -1) {
1308 UnlockMutex(&BUF_LOCK(buf));
1309 return(-1);
1310 }
1311 x = buf->bun_suu;
1312 UnlockMutex(&BUF_LOCK(buf));
1313 return x;
1314 } /* End of jl_tan_conv */
1315
1316 /*:::DOC_START
1317 *
1318 * Function Name: jl_tan_conv_hinsi_flag
1319 * Description : �Ѵ��˻��Ѥ����ʻ����ꤷ��ñʸ���Ѵ���Ԥ�
1320 * Parameter :
1321 * buf : (InOut) �Хåե��ؤΥݥ���
1322 * yomi : (In) �Ѵ��ɤ�ʸ����ؤΥݥ���
1323 * bun_no : (In) �������ʸ�����Ƭʸ���ֹ�
1324 * bun_no2 : (In) �������ʸ��κǽ�ʸ���ľ���ʸ���ֹ�
1325 * use_maep : (In) �������³��ʻȤ����ݡ˥ե饰
1326 * ich_shop : (In) �ʾ�ʸ���ʸ����Ѵ��ե饰
1327 * hinsi_op : (In) �ʻ�����Ѵ����λ����ʻ�ե饰
1328 *
1329 * Return value : -1==ERROR, else �Ѵ�ʸ���
1330 *
1331 * Author : Hideyuki Kishiba
1332 *
1333 * Revision history:
1334 * 16-May-96: �߾�: ���Ѻѣƣɴط��ǡ���������
1335 *
1336 *:::DOC_END
1337 */
1338 int
jl_tan_conv_hinsi_flag(buf,yomi,bun_no,bun_no2,use_maep,ich_shop,hinsi_op)1339 jl_tan_conv_hinsi_flag(buf, yomi, bun_no, bun_no2, use_maep, ich_shop, hinsi_op)
1340 register struct wnn_buf *buf;
1341 w_char *yomi;
1342 register int bun_no, bun_no2;
1343 int use_maep, ich_shop, hinsi_op;
1344 {
1345 int x, hno;
1346 w_char tmp[64];
1347
1348 if(!buf) return(-1);
1349 LockMutex(&BUF_LOCK(buf));
1350 buf_wnn_errorno_set = 0;
1351
1352 /* ���Ѻѣƣɴط��ǡ������������롣 05/16/96 H.Kishiba */
1353 buf->fi_rb.num = 0;
1354
1355 if(bun_no < 0) {
1356 UnlockMutex(&BUF_LOCK(buf));
1357 return(-1);
1358 }
1359 if(strncmp(js_get_lang(buf->env), WNN_J_LANG, 5)) {
1360 UnlockMutex(&BUF_LOCK(buf));
1361 return(-1);
1362 }
1363 if(hinsi_op == WNN_ZIP)
1364 _Sstrcpy(tmp, WNN_HINSI_ZIPCODE);
1365 else if(hinsi_op == WNN_TEL)
1366 _Sstrcpy(tmp, WNN_HINSI_TELNO);
1367 else if(hinsi_op == WNN_TANKAN)
1368 _Sstrcpy(tmp, WNN_HINSI_TANKAN);
1369 else {
1370 UnlockMutex(&BUF_LOCK(buf));
1371 return(-1);
1372 }
1373 if((hno = jl_hinsi_number_e(buf->env, tmp)) == -1) {
1374 UnlockMutex(&BUF_LOCK(buf));
1375 return(-1);
1376 }
1377
1378 if(tan_conv_sub((WNN_BUF_MT *)buf, yomi, bun_no, bun_no2, use_maep,
1379 ich_shop, 0, 1, &hno) == -1) {
1380 UnlockMutex(&BUF_LOCK(buf));
1381 return(-1);
1382 }
1383 x = buf->bun_suu;
1384 UnlockMutex(&BUF_LOCK(buf));
1385 return x;
1386 } /* jl_tan_conv_hinsi_flag */
1387
1388 /*:::DOC_START
1389 *
1390 * Function Name: jl_tan_conv_with_hinsi_name
1391 * Description : �Ѵ��˻��Ѥ����ʻ����ꤷ��ñʸ���Ѵ���Ԥ�
1392 * Parameter :
1393 * buf : (InOut) �Хåե��ؤΥݥ���
1394 * yomi : (In) �Ѵ��ɤ�ʸ����ؤΥݥ���
1395 * bun_no : (In) �������ʸ�����Ƭʸ���ֹ�
1396 * bun_no2 : (In) �������ʸ��κǽ�ʸ���ľ���ʸ���ֹ�
1397 * use_maep : (In) �������³��ʻȤ����ݡ˥ե饰
1398 * ich_shop : (In) �ʾ�ʸ���ʸ����Ѵ��ե饰
1399 * nhinsi : (In) �ʻ�����Ѵ����λ����ʻ��
1400 * hlist : (In) �ʻ�����Ѵ����λ����ʻ�̾����ؤΥݥ���
1401 *
1402 * Return value : -1==ERROR, else �Ѵ�ʸ���
1403 *
1404 * Author : Hideyuki Kishiba
1405 *
1406 * Revision history:
1407 * 16-May-96: �߾�: ���Ѻѣƣɴط��ǡ���������
1408 *
1409 *:::DOC_END
1410 */
1411 int
jl_tan_conv_with_hinsi_name(buf,yomi,bun_no,bun_no2,use_maep,ich_shop,nhinsi,hname)1412 jl_tan_conv_with_hinsi_name(buf, yomi, bun_no, bun_no2, use_maep, ich_shop, nhinsi, hname)
1413 register struct wnn_buf *buf;
1414 w_char *yomi;
1415 register int bun_no, bun_no2;
1416 int use_maep, ich_shop, nhinsi;
1417 char **hname;
1418 {
1419 int i, x, hsize, *hno = NULL;
1420 w_char tmp[64];
1421
1422 if(!buf) return(-1);
1423 LockMutex(&BUF_LOCK(buf));
1424 buf_wnn_errorno_set = 0;
1425
1426 /* ���Ѻѣƣɴط��ǡ������������롣 05/16/96 H.Kishiba */
1427 buf->fi_rb.num = 0;
1428
1429 if(bun_no < 0) {
1430 UnlockMutex(&BUF_LOCK(buf));
1431 return(-1);
1432 }
1433 /* if(strncmp(js_get_lang(buf->env), WNN_J_LANG, 5) || nhinsi == 0) {
1434 UnlockMutex(&BUF_LOCK(buf));
1435 return(-1);
1436 } */
1437 if(nhinsi) {
1438 hsize = abs(nhinsi);
1439 hno = (int *)malloc(hsize * sizeof(int));
1440 for(i = 0; i < hsize; i++) {
1441 _Sstrcpy(tmp, hname[i]);
1442 if((hno[i] = jl_hinsi_number_e(buf->env, tmp)) == -1) {
1443 free((char *)hno);
1444 UnlockMutex(&BUF_LOCK(buf));
1445 return(-1);
1446 }
1447 }
1448 }
1449
1450 if(tan_conv_sub((WNN_BUF_MT *)buf, yomi, bun_no, bun_no2, use_maep,
1451 ich_shop, 0, nhinsi, hno) == -1) {
1452 if(nhinsi) free((char *)hno);
1453 UnlockMutex(&BUF_LOCK(buf));
1454 return(-1);
1455 }
1456 if(nhinsi) free((char *)hno);
1457 x = buf->bun_suu;
1458 UnlockMutex(&BUF_LOCK(buf));
1459 return x;
1460 } /* jl_tan_conv_with_hinsi_name */
1461
1462 /*:::DOC_START
1463 *
1464 * Function Name: tan_conv_sub
1465 * Description : ñʸ���Ѵ��Υ��֥롼����ؿ����Σ�
1466 * Parameter :
1467 * buf : (InOut) �Хåե��ؤΥݥ���
1468 * yomi : (In) �Ѵ��ɤ�ʸ����ؤΥݥ���
1469 * bun_no : (In) �������ʸ�����Ƭʸ���ֹ�
1470 * bun_no2 : (In) �������ʸ��κǽ�ʸ���ľ���ʸ���ֹ�
1471 * use_maep : (In) �������³��ʻȤ����ݡ˥ե饰
1472 * ich_shop : (In) �ʾ�ʸ���ʸ����Ѵ��ե饰
1473 * fuku : (In) ʣ���ͥ���Ѵ��ե饰
1474 * nhinsi : (In) �ʻ�����Ѵ����λ����ʻ��
1475 * hlist : (In) �ʻ�����Ѵ����λ����ʻ��ֹ�����ؤΥݥ���
1476 *
1477 * Return value : -1==ERROR, else �Ѵ�ʸ���
1478 *
1479 * Author : Hideyuki Kishiba
1480 *
1481 * Revision history:
1482 *
1483 *:::DOC_END
1484 */
1485 static int
tan_conv_sub(buf,yomi,bun_no,bun_no2,use_maep,ich_shop,fuku,nhinsi,hlist)1486 tan_conv_sub(buf, yomi, bun_no, bun_no2, use_maep, ich_shop, fuku, nhinsi, hlist)
1487 register struct wnn_buf *buf;
1488 w_char *yomi;
1489 register int bun_no, bun_no2;
1490 int use_maep, ich_shop, fuku, nhinsi, *hlist;
1491 {
1492 int x;
1493
1494 if(bun_no2 >= buf->bun_suu || bun_no2 < 0) bun_no2 = buf->bun_suu;
1495 free_down(buf, bun_no, bun_no2);
1496 x = tan_conv1((WNN_BUF_MT *)buf, yomi, bun_no, bun_no2, use_maep,
1497 ich_shop, fuku, nhinsi, hlist);
1498 return x;
1499 } /* End of tan_conv_sub */
1500
1501 /*:::DOC_START
1502 *
1503 * Function Name: tan_conv1
1504 * Description : ñʸ���Ѵ��Υ��֥롼����ؿ����Σ�
1505 * Parameter :
1506 * buf : (InOut) �Хåե��ؤΥݥ���
1507 * yomi : (In) �Ѵ��ɤ�ʸ����ؤΥݥ���
1508 * bun_no : (In) �������ʸ�����Ƭʸ���ֹ�
1509 * bun_no2 : (In) �������ʸ��κǽ�ʸ���ľ���ʸ���ֹ�
1510 * use_maep : (In) �������³��ʻȤ����ݡ˥ե饰
1511 * ich_shop : (In) �ʾ�ʸ���ʸ����Ѵ��ե饰
1512 * fuku : (In) ʣ���ͥ���Ѵ��ե饰
1513 * nhinsi : (In) �ʻ�����Ѵ����λ����ʻ��
1514 * hlist : (In) �ʻ�����Ѵ����λ����ʻ��ֹ�����ؤΥݥ���
1515 *
1516 * Return value : -1==ERROR, else �Ѵ�ʸ���
1517 *
1518 * Author : Hideyuki Kishiba
1519 *
1520 * Revision history:
1521 *
1522 *:::DOC_END
1523 */
1524 static int
tan_conv1(buf,yomi,bun_no,bun_no2,use_maep,ich_shop,fuku,nhinsi,hlist)1525 tan_conv1(buf, yomi, bun_no, bun_no2, use_maep, ich_shop, fuku, nhinsi, hlist)
1526 register struct wnn_buf_mt *buf;
1527 w_char *yomi;
1528 register int bun_no, bun_no2;
1529 int use_maep, ich_shop, fuku, nhinsi, *hlist;
1530 {
1531 int dcnt;
1532 struct wnn_dai_bunsetsu *dp;
1533 struct wnn_sho_bunsetsu *sp;
1534 int ret;
1535 w_char yomi1[LENGTHBUNSETSU];
1536
1537 if (yomi == NULL || *yomi == (w_char)0) return(0);
1538 if(bun_no2 >= buf->orig.bun_suu || bun_no2 < 0) bun_no2 = buf->orig.bun_suu;
1539
1540 if (use_maep & WNN_USE_MAE && bun_no > 0) {
1541 dumbhinsi = buf->orig.bun[bun_no - 1]->hinsi;
1542 jl_get_yomi_body(buf, bun_no - 1, bun_no, yomi1);
1543 mae_fzk = yomi1 + buf->orig.bun[bun_no - 1]->jirilen;
1544 } else {
1545 dumbhinsi = WNN_BUN_SENTOU;
1546 mae_fzk = (w_char *)0;
1547 }
1548 if(use_maep & WNN_USE_ATO && bun_no2 < buf->orig.bun_suu){
1549 syuutanv = buf->orig.bun[bun_no2]->kangovect;
1550 syuutanv1 = WNN_VECT_KANTAN;
1551 }else{
1552 syuutanv = WNN_VECT_KANTAN;
1553 syuutanv1 = WNN_VECT_NO;
1554 if(bun_no2 < buf->orig.bun_suu){
1555 buf->orig.bun[bun_no2]->dai_top = 1;
1556 }
1557 }
1558 if(!(buf->orig.env)) return(-1);
1559 LockMutex(&(envmt->env_lock));
1560 if(ich_shop == WNN_SHO){
1561 if(fuku == 0 && nhinsi == 0) {
1562 /* ��ʸ��ñʸ���Ѵ� */
1563 if((dcnt = js_kantan_sho(buf->orig.env, yomi, dumbhinsi, mae_fzk,
1564 syuutanv, syuutanv1, &buf_rb)) < 0){
1565 buf_wnn_errorno_copy(buf);
1566 if_dead_disconnect_b(buf);
1567 UnlockMutex(&(envmt->env_lock));
1568 return(-1);
1569 }
1570 } else {
1571 /* �Ѵ��Ķ����꾮ʸ��ñʸ���Ѵ� */
1572 if((dcnt = js_henkan_with_data(buf->orig.env, fuku, nhinsi, hlist,
1573 WNN_KANTAN_SHO, yomi, dumbhinsi, mae_fzk,
1574 syuutanv, syuutanv1, WNN_VECT_BUNSETSU, &buf_rb)) < 0) {
1575 buf_wnn_errorno_copy(buf);
1576 if_dead_disconnect_b(buf);
1577 UnlockMutex(&(envmt->env_lock));
1578 return(-1);
1579 }
1580 }
1581 sp = (struct wnn_sho_bunsetsu *)buf_rb.buf;
1582 if(use_maep & WNN_USE_ATO && bun_no2 < buf->orig.bun_suu){
1583 buf->orig.bun[bun_no2]->dai_top =
1584 (sp[dcnt-1].status_bkwd == WNN_CONNECT_BK)? 0:1;
1585 }
1586 free_bun(buf, bun_no, bun_no2);
1587 ret = insert_sho(buf, BUN, bun_no, bun_no2, sp, dcnt, 0, fuku, nhinsi, hlist);
1588 } else {
1589 if(fuku == 0 && nhinsi == 0) {
1590 /* ��ʸ��ñʸ���Ѵ� */
1591 if((dcnt = js_kantan_dai(buf->orig.env, yomi, dumbhinsi, mae_fzk,
1592 syuutanv, syuutanv1, &buf_rb)) < 0){
1593 buf_wnn_errorno_copy(buf);
1594 if_dead_disconnect_b(buf);
1595 UnlockMutex(&(envmt->env_lock));
1596 return(-1);
1597 }
1598 } else {
1599 /* �Ѵ��Ķ�������ʸ��ñʸ���Ѵ� */
1600 if((dcnt = js_henkan_with_data(buf->orig.env, fuku, nhinsi, hlist,
1601 WNN_KANTAN_DAI, yomi, dumbhinsi, mae_fzk,
1602 syuutanv, syuutanv1, WNN_VECT_BUNSETSU, &buf_rb)) < 0) {
1603 buf_wnn_errorno_copy(buf);
1604 if_dead_disconnect_b(buf);
1605 UnlockMutex(&(envmt->env_lock));
1606 return(-1);
1607 }
1608 }
1609 dp = (struct wnn_dai_bunsetsu *)buf_rb.buf;
1610 if(use_maep & WNN_USE_ATO && bun_no2 < buf->orig.bun_suu){
1611 buf->orig.bun[bun_no2]->dai_top =
1612 (dp[dcnt-1].sbn[dp[dcnt-1].sbncnt-1].status_bkwd == WNN_CONNECT_BK)? 0:1;
1613 }
1614 free_bun(buf, bun_no, bun_no2);
1615 ret = insert_dai(buf, BUN, bun_no, bun_no2, dp, dcnt, 0, fuku, nhinsi, hlist);
1616 }
1617 if(buf->orig.zenkouho_end_bun > bun_no && buf->orig.zenkouho_bun < bun_no2){
1618 free_zenkouho(buf);
1619 }else if(buf->orig.zenkouho_bun >= bun_no2){
1620 buf->orig.zenkouho_bun += ret - bun_no2;
1621 buf->orig.zenkouho_end_bun += ret - bun_no2;
1622 }
1623 UnlockMutex(&(envmt->env_lock));
1624 return(ret);
1625 } /* End of tan_conv1 */
1626
1627 /*:::DOC_START
1628 *
1629 * Function Name: jl_nobi_conv
1630 * Description : ����Ѵ���Ԥ�
1631 * Parameter :
1632 * buf : (InOut) �Хåե��ؤΥݥ���
1633 * bun_no : (In) �Ѵ�ʸ�����Ƭʸ���ֹ�
1634 * ichbn_len : (In) ���ʸ���ܤ�Ĺ��
1635 * bun_no2 : (In) �Ѵ�ʸ��κǽ�ʸ���ľ���ʸ���ֹ�
1636 * use_maep : (In) �������³��ʻȤ����ݡ˥ե饰
1637 * ich_shop : (In) ��ʸ���ܤ�ʾ�ʸ���ʸ����Ѵ�����ե饰
1638 *
1639 * Return value : -1==ERROR, else �Ѵ�ʸ���
1640 *
1641 * Author : Hideyuki Kishiba
1642 *
1643 * Revision history:
1644 *
1645 *:::DOC_END
1646 */
1647 int
jl_nobi_conv(buf,bun_no,ichbn_len,bun_no2,use_maep,ich_shop)1648 jl_nobi_conv(buf, bun_no, ichbn_len, bun_no2, use_maep, ich_shop)
1649 register struct wnn_buf *buf;
1650 int ichbn_len, use_maep, ich_shop;
1651 register int bun_no, bun_no2;
1652 {
1653 int x;
1654
1655 if(!buf) return(-1);
1656 LockMutex(&BUF_LOCK(buf));
1657 buf_wnn_errorno_set = 0;
1658 if(bun_no < 0) {
1659 UnlockMutex(&BUF_LOCK(buf));
1660 return(-1);
1661 }
1662
1663 if(nobi_conv_sub(buf, bun_no, ichbn_len, bun_no2, use_maep, ich_shop,
1664 0, NULL, 0) == -1) {
1665 UnlockMutex(&BUF_LOCK(buf));
1666 return(-1);
1667 }
1668 x = buf->bun_suu;
1669 UnlockMutex(&BUF_LOCK(buf));
1670 return x;
1671 } /* End of jl_nobi_conv */
1672
1673 /*:::DOC_START
1674 *
1675 * Function Name: jl_nobi_conv_hinsi_flag
1676 * Description : �Ѵ��˻��Ѥ����ʻ����ꤷ�Ʊ���Ѵ���Ԥ�
1677 * Parameter :
1678 * buf : (InOut) �Хåե��ؤΥݥ���
1679 * bun_no : (In) �Ѵ�ʸ�����Ƭʸ���ֹ�
1680 * ichbn_len : (In) ���ʸ���ܤ�Ĺ��
1681 * bun_no2 : (In) �Ѵ�ʸ��κǽ�ʸ���ľ���ʸ���ֹ�
1682 * use_maep : (In) �������³��ʻȤ����ݡ˥ե饰
1683 * ich_shop : (In) ��ʸ���ܤ�ʾ�ʸ���ʸ����Ѵ�����ե饰
1684 * hinsi_op : (In) �ʻ�����Ѵ����λ����ʻ�ե饰
1685 *
1686 * Return value : -1==ERROR, else �Ѵ�ʸ���
1687 *
1688 * Author : Hideyuki Kishiba
1689 *
1690 * Revision history:
1691 *
1692 *:::DOC_END
1693 */
1694 int
jl_nobi_conv_hinsi_flag(buf,bun_no,ichbn_len,bun_no2,use_maep,ich_shop,hinsi_op)1695 jl_nobi_conv_hinsi_flag(buf, bun_no, ichbn_len, bun_no2, use_maep, ich_shop, hinsi_op)
1696 register struct wnn_buf *buf;
1697 int ichbn_len, use_maep, ich_shop, hinsi_op;
1698 register int bun_no, bun_no2;
1699 {
1700 int x, hno;
1701 w_char tmp[64];
1702
1703 if(!buf) return(-1);
1704 LockMutex(&BUF_LOCK(buf));
1705 buf_wnn_errorno_set = 0;
1706 if(bun_no < 0) {
1707 UnlockMutex(&BUF_LOCK(buf));
1708 return(-1);
1709 }
1710 if(strncmp(js_get_lang(buf->env), WNN_J_LANG, 5)) {
1711 UnlockMutex(&BUF_LOCK(buf));
1712 return(-1);
1713 }
1714 if(hinsi_op == WNN_ZIP)
1715 _Sstrcpy(tmp, WNN_HINSI_ZIPCODE);
1716 else if(hinsi_op == WNN_TEL)
1717 _Sstrcpy(tmp, WNN_HINSI_TELNO);
1718 else if(hinsi_op == WNN_TANKAN)
1719 _Sstrcpy(tmp, WNN_HINSI_TANKAN);
1720 else {
1721 UnlockMutex(&BUF_LOCK(buf));
1722 return(-1);
1723 }
1724 if((hno = jl_hinsi_number_e(buf->env, tmp)) == -1) {
1725 UnlockMutex(&BUF_LOCK(buf));
1726 return(-1);
1727 }
1728
1729 if(nobi_conv_sub(buf, bun_no, ichbn_len, bun_no2, use_maep, ich_shop,
1730 1, &hno, 0) == -1) {
1731 UnlockMutex(&BUF_LOCK(buf));
1732 return(-1);
1733 }
1734 x = buf->bun_suu;
1735 UnlockMutex(&BUF_LOCK(buf));
1736 return x;
1737 } /* jl_nobi_conv_hinsi_flag */
1738
1739 /*:::DOC_START
1740 *
1741 * Function Name: jl_nobi_conv_with_hinsi_name
1742 * Description : �Ѵ��˻��Ѥ����ʻ����ꤷ�Ʊ���Ѵ���Ԥ�
1743 * Parameter :
1744 * buf : (InOut) �Хåե��ؤΥݥ���
1745 * bun_no : (In) �Ѵ�ʸ�����Ƭʸ���ֹ�
1746 * ichbn_len : (In) ���ʸ���ܤ�Ĺ��
1747 * bun_no2 : (In) �Ѵ�ʸ��κǽ�ʸ���ľ���ʸ���ֹ�
1748 * use_maep : (In) �������³��ʻȤ����ݡ˥ե饰
1749 * ich_shop : (In) ��ʸ���ܤ�ʾ�ʸ���ʸ����Ѵ�����ե饰
1750 * nhinsi : (In) �ʻ�����Ѵ����λ����ʻ��
1751 * hname : (In) �ʻ�����Ѵ����λ����ʻ�̾����ؤΥݥ���
1752 *
1753 * Return value : -1==ERROR, else �Ѵ�ʸ���
1754 *
1755 * Author : Hideyuki Kishiba
1756 *
1757 * Revision history:
1758 *
1759 *:::DOC_END
1760 */
1761 int
jl_nobi_conv_with_hinsi_name(buf,bun_no,ichbn_len,bun_no2,use_maep,ich_shop,nhinsi,hname)1762 jl_nobi_conv_with_hinsi_name(buf, bun_no, ichbn_len, bun_no2, use_maep, ich_shop, nhinsi, hname)
1763 register struct wnn_buf *buf;
1764 int ichbn_len, use_maep, ich_shop, nhinsi;
1765 register int bun_no, bun_no2;
1766 char **hname;
1767 {
1768 int x, i, hsize, *hno = NULL;
1769 w_char tmp[64];
1770
1771 if(!buf) return(-1);
1772 LockMutex(&BUF_LOCK(buf));
1773 buf_wnn_errorno_set = 0;
1774 if(bun_no < 0) {
1775 UnlockMutex(&BUF_LOCK(buf));
1776 return(-1);
1777 }
1778 /* if(strncmp(js_get_lang(buf->env), WNN_J_LANG, 5) || nhinsi == 0) {
1779 UnlockMutex(&BUF_LOCK(buf));
1780 return(-1);
1781 } */
1782 if(nhinsi) {
1783 hsize = abs(nhinsi);
1784 hno = (int *)malloc(hsize * sizeof(int));
1785 for(i = 0; i < hsize; i++) {
1786 _Sstrcpy(tmp, hname[i]);
1787 if((hno[i] = jl_hinsi_number_e(buf->env, tmp)) == -1) {
1788 free((char *)hno);
1789 UnlockMutex(&BUF_LOCK(buf));
1790 return(-1);
1791 }
1792 }
1793 }
1794
1795 if(nobi_conv_sub(buf, bun_no, ichbn_len, bun_no2, use_maep, ich_shop,
1796 nhinsi, hno, 0) == -1) {
1797 if(nhinsi) free((char *)hno);
1798 UnlockMutex(&BUF_LOCK(buf));
1799 return(-1);
1800 }
1801 if(nhinsi) free((char *)hno);
1802 x = buf->bun_suu;
1803 UnlockMutex(&BUF_LOCK(buf));
1804 return x;
1805 } /* End of jl_nobi_conv_with_hinsi_name */
1806
1807 /*:::DOC_START
1808 *
1809 * Function Name: jl_fi_nobi_conv
1810 * Description : �ƣɱ���Ѵ���Ԥ�
1811 * Parameter :
1812 * buf : (InOut) �Хåե��ؤΥݥ���
1813 * bun_no : (In) �Ѵ�ʸ�����Ƭʸ���ֹ�
1814 * ichbn_len : (In) ���ʸ���ܤ�Ĺ��
1815 * bun_no2 : (In) �Ѵ�ʸ��κǽ�ʸ���ľ���ʸ���ֹ�
1816 * use_maep : (In) �������³��ʻȤ����ݡ˥ե饰
1817 * ich_shop : (In) ��ʸ���ܤ�ʾ�ʸ���ʸ����Ѵ�����ե饰
1818 *
1819 * Return value : -1==ERROR, else �Ѵ�ʸ���
1820 *
1821 * Author : Hideyuki Kishiba
1822 *
1823 * Revision history:
1824 *
1825 *:::DOC_END
1826 */
1827 int
jl_fi_nobi_conv(buf,bun_no,ichbn_len,bun_no2,use_maep,ich_shop)1828 jl_fi_nobi_conv(buf, bun_no, ichbn_len, bun_no2, use_maep, ich_shop)
1829 register struct wnn_buf *buf;
1830 int ichbn_len, use_maep, ich_shop;
1831 register int bun_no, bun_no2;
1832 {
1833 int x;
1834
1835 if(!buf) return(-1);
1836 LockMutex(&BUF_LOCK(buf));
1837 buf_wnn_errorno_set = 0;
1838 if(bun_no < 0) {
1839 UnlockMutex(&BUF_LOCK(buf));
1840 return(-1);
1841 }
1842
1843 if(nobi_conv_sub(buf, bun_no, ichbn_len, bun_no2, use_maep, ich_shop,
1844 0, NULL, 1) == -1) {
1845 UnlockMutex(&BUF_LOCK(buf));
1846 return(-1);
1847 }
1848 x = buf->bun_suu;
1849 UnlockMutex(&BUF_LOCK(buf));
1850 return x;
1851 } /* End of jl_fi_nobi_conv */
1852
1853 /*:::DOC_START
1854 *
1855 * Function Name: nobi_conv_sub
1856 * Description : ����Ѵ��Υ��֥롼����ؿ�
1857 * Parameter :
1858 * buf : (InOut) �Хåե��ؤΥݥ���
1859 * bun_no : (In) �Ѵ�ʸ�����Ƭʸ���ֹ�
1860 * ichbn_len : (In) ���ʸ���ܤ�Ĺ��
1861 * bun_no2 : (In) �Ѵ�ʸ��κǽ�ʸ���ľ���ʸ���ֹ�
1862 * use_maep : (In) �������³��ʻȤ����ݡ˥ե饰
1863 * ich_shop : (In) ��ʸ���ܤ�ʾ�ʸ���ʸ����Ѵ�����ե饰
1864 * nhinsi : (In) �ʻ�����Ѵ����λ����ʻ��
1865 * hlist : (In) �ʻ�����Ѵ����λ����ʻ��ֹ�����ؤΥݥ���
1866 * fi_flag : (In) ���Ѥ����ƣɴط������ʼ������ʤ���
1867 * �������˥ե饰
1868 *
1869 * Return value : 0==SUCCESS, -1==ERROR
1870 *
1871 * Author : Hideyuki Kishiba
1872 *
1873 * Revision history:
1874 *
1875 *:::DOC_END
1876 */
1877 static int
nobi_conv_sub(buf,bun_no,ichbn_len,bun_no2,use_maep,ich_shop,nhinsi,hlist,fi_flag)1878 nobi_conv_sub(buf, bun_no, ichbn_len, bun_no2, use_maep, ich_shop, nhinsi, hlist, fi_flag)
1879 register struct wnn_buf *buf;
1880 int ichbn_len, use_maep, ich_shop, nhinsi, *hlist, fi_flag;
1881 register int bun_no, bun_no2;
1882 {
1883 w_char yomi[LENGTHCONV], ytmp;
1884 int ret;
1885 int len1;
1886 register WNN_BUN *b1; /* �ؽ������ޤ������褦���ѹ����ޤ�����H.T. */
1887
1888 if(bun_no2 >= buf->bun_suu || bun_no2 < 0) bun_no2 = buf->bun_suu;
1889
1890 len1 = jl_get_yomi_body((WNN_BUF_MT *)buf, bun_no, bun_no2, yomi);
1891 ytmp = yomi[ichbn_len];
1892 if(len1 < ichbn_len){
1893 ichbn_len = len1;
1894 }
1895 yomi[ichbn_len] = 0;
1896
1897 if(buf->bun[bun_no]->nobi_top != 1){ /* need to add down_bnst */
1898 if(buf->bun[bun_no]) add_down_bnst((WNN_BUF_MT *)buf, bun_no,
1899 buf->bun[bun_no]);
1900 if(bun_no + 1 < buf->bun_suu){
1901 add_down_bnst((WNN_BUF_MT *)buf, bun_no, buf->bun[bun_no + 1]);
1902 /* ���� bun_no �� down_bnst �˲ä���褦���ѹ� */
1903 }
1904 }
1905 b1 = buf->down_bnst[bun_no];
1906 buf->down_bnst[bun_no] = NULL;
1907 free_down((WNN_BUF_MT *)buf, bun_no, bun_no2);
1908
1909 if((ret = tan_conv1((WNN_BUF_MT *)buf, yomi, bun_no, bun_no2,
1910 use_maep & WNN_USE_MAE, ich_shop,
1911 0, nhinsi, hlist)) == -1)
1912 return(-1);
1913
1914 yomi[ichbn_len] = ytmp;
1915 if(ytmp){
1916 int maep;
1917 if(ich_shop){
1918 maep = use_maep & ~WNN_USE_MAE;
1919 }else{
1920 maep = use_maep | WNN_USE_MAE;
1921 }
1922 if(ren_conv1((WNN_BUF_MT *)buf, yomi + ichbn_len, ret, ret,
1923 maep, 0, 0, NULL, fi_flag) == -1)
1924 return(-1);
1925 }
1926 buf->bun[bun_no]->nobi_top = 1;
1927 buf->down_bnst[bun_no] = b1;
1928 return(0);
1929 } /* End of nobi_conv_sub */
1930
1931 int
jl_nobi_conv_e2(buf,env,bun_no,ichbn_len,bun_no2,use_maep,ich_shop)1932 jl_nobi_conv_e2(buf, env, bun_no, ichbn_len, bun_no2, use_maep, ich_shop)
1933 register struct wnn_buf *buf;
1934 struct wnn_env *env;
1935 int ichbn_len, use_maep, ich_shop;
1936 register int bun_no, bun_no2;
1937 {
1938 w_char yomi[LENGTHCONV], ytmp;
1939 int ret;
1940 int len1;
1941 int x;
1942
1943 if(!buf) return(-1);
1944 LockMutex(&BUF_LOCK(buf));
1945 buf_wnn_errorno_set = 0;
1946 if(bun_no < 0) {
1947 UnlockMutex(&BUF_LOCK(buf));
1948 return(-1);
1949 }
1950 if(bun_no2 >= buf->bun_suu || bun_no2 < 0) bun_no2 = buf->bun_suu;
1951
1952 len1 = jl_get_yomi_body((WNN_BUF_MT *)buf, bun_no, bun_no2, yomi);
1953 ytmp = yomi[ichbn_len];
1954 if(len1 < ichbn_len){
1955 ichbn_len = len1;
1956 }
1957 yomi[ichbn_len] = 0;
1958
1959 if(buf->bun[bun_no]->nobi_top != 1){ /* need to add down_bnst */
1960 if(buf->bun[bun_no]) add_down_bnst((WNN_BUF_MT *)buf, bun_no,
1961 buf->bun[bun_no]);
1962 if(bun_no + 1 < buf->bun_suu){
1963 if(ichbn_len < jl_yomi_len_body((WNN_BUF_MT *)buf, bun_no,
1964 bun_no + 1)){
1965 add_down_bnst((WNN_BUF_MT *)buf, bun_no + 1,
1966 buf->bun[bun_no + 1]);
1967 free_down((WNN_BUF_MT *)buf, bun_no + 2, bun_no2);
1968 }else{
1969 add_down_bnst((WNN_BUF_MT *)buf, bun_no, buf->bun[bun_no + 1]);
1970 free_down((WNN_BUF_MT *)buf, bun_no + 1, bun_no2);
1971 }
1972 }
1973 }
1974
1975 if((ret = tan_conv1((WNN_BUF_MT *)buf, yomi, bun_no, bun_no2,
1976 use_maep & WNN_USE_MAE, ich_shop, 0, 0, NULL)) == -1){
1977 UnlockMutex(&BUF_LOCK(buf));
1978 return(-1);
1979 }
1980
1981 buf->env = env;
1982
1983 yomi[ichbn_len] = ytmp;
1984 if(ytmp){
1985 int maep;
1986 if(ich_shop){
1987 maep = use_maep & ~WNN_USE_MAE;
1988 }else{
1989 maep = use_maep | WNN_USE_MAE;
1990 }
1991 if(ren_conv1((WNN_BUF_MT *)buf, yomi + ichbn_len, ret, ret,
1992 maep, 0, 0, NULL, 0) == -1){
1993 UnlockMutex(&BUF_LOCK(buf));
1994 return(-1);
1995 }
1996 }
1997 buf->bun[bun_no]->nobi_top = 1;
1998 x = buf->bun_suu;
1999 UnlockMutex(&BUF_LOCK(buf));
2000
2001 return x;
2002 }
2003
2004 int
jl_kill(buf,bun_no,bun_no2)2005 jl_kill(buf, bun_no, bun_no2)
2006 struct wnn_buf *buf;
2007 register int bun_no, bun_no2;
2008 {
2009 int x;
2010
2011 if(!buf) return(0);
2012 LockMutex(&BUF_LOCK(buf));
2013 buf_wnn_errorno_set = 0;
2014 if(bun_no < 0) {
2015 UnlockMutex(&BUF_LOCK(buf));
2016 return(0);
2017 }
2018 if(bun_no2 < bun_no || bun_no2 < 0) bun_no2 = buf->bun_suu;
2019 free_zenkouho((WNN_BUF_MT *)buf); /* toriaezu */
2020 free_down((WNN_BUF_MT *)buf, bun_no, bun_no2);
2021 free_bun((WNN_BUF_MT *)buf, bun_no, bun_no2);
2022 bcopy((char *)&buf->bun[bun_no2], (char *)&buf->bun[bun_no],
2023 (buf->bun_suu - bun_no2) * sizeof(WNN_BUN *));
2024 bcopy((char *)&buf->down_bnst[bun_no2], (char *)&buf->down_bnst[bun_no],
2025 (buf->bun_suu - bun_no2) * sizeof(WNN_BUN *));
2026 buf->bun_suu -= bun_no2 - bun_no;
2027 x = buf->bun_suu;
2028 UnlockMutex(&BUF_LOCK(buf));
2029 return x;
2030 }
2031
2032 int
jl_zenkouho(buf,bun_no,use_maep,uniq_level)2033 jl_zenkouho(buf, bun_no, use_maep, uniq_level)
2034 register struct wnn_buf *buf;
2035 int bun_no, use_maep, uniq_level;
2036 {
2037 int x;
2038
2039 if(!buf) return(-1);
2040 LockMutex(&BUF_LOCK(buf));
2041 buf_wnn_errorno_set = 0;
2042 x = zen_conv_sho1(buf, bun_no, use_maep, uniq_level, 0, 0, NULL);
2043 UnlockMutex(&BUF_LOCK(buf));
2044 return x;
2045 }
2046
2047 static int
zen_conv_sho1(buf,bun_no,use_maep,uniq_level,fuku,nhinsi,hlist)2048 zen_conv_sho1(buf, bun_no, use_maep, uniq_level, fuku, nhinsi, hlist)
2049 register struct wnn_buf *buf;
2050 int bun_no, use_maep, uniq_level, fuku, nhinsi, *hlist;
2051 {
2052 register struct wnn_buf_mt *buf_m = (WNN_BUF_MT *)buf;
2053 int cnt;
2054 w_char yomi[LENGTHBUNSETSU], yomi1[LENGTHBUNSETSU];
2055 struct wnn_sho_bunsetsu *sp;
2056 register int k;
2057 int x;
2058 int nobi_top;
2059
2060 jl_get_yomi_body(buf_m, bun_no, bun_no + 1, yomi);
2061 if (use_maep & WNN_USE_MAE && bun_no > 0) {
2062 dumbhinsi = buf->bun[bun_no - 1]->hinsi;
2063 jl_get_yomi_body(buf_m, bun_no - 1, bun_no, yomi1);
2064 mae_fzk = yomi1 + buf->bun[bun_no - 1]->jirilen;
2065 } else {
2066 dumbhinsi = WNN_BUN_SENTOU;
2067 mae_fzk = (w_char *)0;
2068 }
2069 if(use_maep & WNN_USE_ATO && bun_no + 1 < buf->bun_suu){
2070 syuutanv = buf->bun[bun_no+1]->kangovect;
2071 syuutanv1 = WNN_VECT_KANZEN;
2072 buf->zenkouho_endvect = syuutanv;
2073 }else{
2074 syuutanv = WNN_VECT_KANZEN;
2075 syuutanv1 = WNN_VECT_NO;
2076 if(bun_no + 1 < buf->bun_suu){
2077 buf->bun[bun_no + 1]->dai_top = 1;
2078 }
2079 buf->zenkouho_endvect = -1;
2080 }
2081
2082 if(!(buf->env)) return(-1);
2083 LockMutex(&(envmt->env_lock));
2084 if(fuku == 0 && nhinsi == 0) {
2085 if(buf->bun[bun_no]->fukugou == 0 && buf->bun[bun_no]->num_hinsi == 0) {
2086 if((cnt = js_kanzen_sho(buf->env, yomi, dumbhinsi, mae_fzk,
2087 syuutanv, syuutanv1, &buf_rb)) < 0){
2088 buf_wnn_errorno_copy(buf_m);
2089 if_dead_disconnect_b(buf_m);
2090 UnlockMutex(&(envmt->env_lock));
2091 return(-1);
2092 }
2093 } else {
2094 fuku = buf->bun[bun_no]->fukugou;
2095 nhinsi = buf->bun[bun_no]->num_hinsi;
2096 hlist = buf->bun[bun_no]->hinsi_list;
2097 if((cnt = js_henkan_with_data(buf->env, fuku, nhinsi, hlist,
2098 WNN_KANZEN_SHO, yomi, dumbhinsi, mae_fzk, syuutanv,
2099 syuutanv1, WNN_VECT_BUNSETSU, &buf_rb)) < 0){
2100 buf_wnn_errorno_copy(buf_m);
2101 if_dead_disconnect_b(buf_m);
2102 UnlockMutex(&(envmt->env_lock));
2103 return(-1);
2104 }
2105 }
2106 } else {
2107 if((cnt = js_henkan_with_data(buf->env, fuku, nhinsi, hlist,
2108 WNN_KANZEN_SHO, yomi, dumbhinsi, mae_fzk, syuutanv,
2109 syuutanv1, WNN_VECT_BUNSETSU, &buf_rb)) < 0){
2110 buf_wnn_errorno_copy(buf_m);
2111 if_dead_disconnect_b(buf_m);
2112 UnlockMutex(&(envmt->env_lock));
2113 return(-1);
2114 }
2115 }
2116
2117 sp = (struct wnn_sho_bunsetsu *)buf_rb.buf;
2118 free_zenkouho(buf_m);
2119 nobi_top = buf->bun[bun_no]->nobi_top;
2120 /* ��ʸ�ἡ������ä����ȡ��ʻ�����Ѵ��ʾ�ʸ��ˤ���������� (cnt) ��
2121 0 �ξ����μ�����ꥹ�Ȥ�ɽ�������Τǡ������å����ɲä���������
2122 ���������褦�ˤ��롣06/05/96 H.Kishiba */
2123 if((buf->bun[bun_no]->from_zenkouho & 1) == BUN || cnt == 0){
2124 set_sho(buf->bun[bun_no], &buf->zenkouho[0]);
2125 buf->zenkouho_suu = 1;
2126 /* Connection information of Old bunsetsu
2127 * May not be correct.
2128 */
2129 k = get_c_jikouho(sp, cnt, buf->bun[bun_no]);
2130 if(k >= 0){
2131 buf->zenkouho[0]->dai_top = (sp[k].status == WNN_CONNECT)? 0:1;
2132 buf->zenkouho[0]->dai_end = (sp[k].status_bkwd == WNN_CONNECT_BK)? 0:1;
2133 }
2134 if(uniq_level || k < 0){
2135 insert_sho(buf_m, ZENKOUHO, -1, -1, sp, cnt, uniq_level, fuku, nhinsi, hlist);
2136 }else{
2137 insert_sho(buf_m, ZENKOUHO, -1, -1, sp, k, uniq_level, fuku, nhinsi, hlist);
2138 insert_sho(buf_m, ZENKOUHO, -1, -1, sp + k + 1, cnt - k - 1,
2139 uniq_level, fuku, nhinsi, hlist);
2140 }
2141 buf->c_zenkouho = 0;
2142 }else{
2143 insert_sho(buf_m, ZENKOUHO, -1, -1, sp, cnt, uniq_level, fuku, nhinsi, hlist);
2144 k = get_c_jikouho_from_zenkouho(buf_m, buf->bun[bun_no]);
2145 if(k < 0){
2146 k = 0; /* Only when the kouho has been removed from dict. */
2147 }
2148 buf->c_zenkouho = k;
2149 }
2150 buf->zenkouho_bun = bun_no;
2151 buf->zenkouho_end_bun = bun_no + 1;
2152 buf->zenkouho_daip = SHO;
2153 for(k = 0 ; k < buf->zenkouho_suu; k++){
2154 /* ������ꥹ�Ȥ���Ƭ�θ�����Ф��Ƥ�ɬ�����ӥåȤ���Ȥ��褦�ˤ���
2155 ��ʸ��Ĺ�ǽ����Ѻ�ͥ��� */
2156 if(k == 0 ||
2157 (buf->zenkouho[k]->ima && buf->zenkouho[k]->dic_no != -1)){
2158 add_down_bnst(buf_m, bun_no, buf->zenkouho[k]);
2159 }
2160 /*
2161 * ʸ�῭�Ф�/�̤��Ԥä��弡������ä����ˤϡ��������ʸ�����
2162 * �ˤ�ʸ�῭�Ф�/�̤�ξ����Ĥ��Ƥ�����ʸ���ڤ�ؽ��ǻ��Ѥ��롣
2163 */
2164 if (nobi_top) buf->zenkouho[k]->nobi_top = 1;
2165 }
2166 x = buf->c_zenkouho;
2167 UnlockMutex(&(envmt->env_lock));
2168 return x;
2169 }
2170
2171 int
jl_zenkouho_hinsi_flag(buf,bun_no,use_maep,uniq_level,hinsi_op)2172 jl_zenkouho_hinsi_flag(buf, bun_no, use_maep, uniq_level, hinsi_op)
2173 register struct wnn_buf *buf;
2174 int bun_no, use_maep, uniq_level, hinsi_op;
2175 {
2176 int x, hno;
2177 w_char tmp[64];
2178
2179 if(!buf) return(-1);
2180 LockMutex(&BUF_LOCK(buf));
2181 buf_wnn_errorno_set = 0;
2182 if(strncmp(js_get_lang(buf->env), WNN_J_LANG, 5)) {
2183 UnlockMutex(&BUF_LOCK(buf));
2184 return(-1);
2185 }
2186 if(hinsi_op == WNN_ZIP)
2187 _Sstrcpy(tmp, WNN_HINSI_ZIPCODE);
2188 else if(hinsi_op == WNN_TEL)
2189 _Sstrcpy(tmp, WNN_HINSI_TELNO);
2190 else if(hinsi_op == WNN_TANKAN)
2191 _Sstrcpy(tmp, WNN_HINSI_TANKAN);
2192 else {
2193 UnlockMutex(&BUF_LOCK(buf));
2194 return(-1);
2195 }
2196 if((hno = jl_hinsi_number_e(buf->env, tmp)) == -1) {
2197 UnlockMutex(&BUF_LOCK(buf));
2198 return(-1);
2199 }
2200 x = zen_conv_sho1(buf, bun_no, use_maep, uniq_level, 0, 1, &hno);
2201 UnlockMutex(&BUF_LOCK(buf));
2202 return x;
2203 }
2204
2205 int
jl_zenkouho_with_hinsi_name(buf,bun_no,use_maep,uniq_level,nhinsi,hname)2206 jl_zenkouho_with_hinsi_name(buf, bun_no, use_maep, uniq_level, nhinsi, hname)
2207 register struct wnn_buf *buf;
2208 int bun_no, use_maep, uniq_level, nhinsi;
2209 char **hname;
2210 {
2211 int x, i, hsize, *hno = NULL;
2212 w_char tmp[64];
2213
2214 if(!buf) return(-1);
2215 LockMutex(&BUF_LOCK(buf));
2216 buf_wnn_errorno_set = 0;
2217 /* if(strncmp(js_get_lang(buf->env), WNN_J_LANG, 5) || nhinsi == 0) {
2218 UnlockMutex(&BUF_LOCK(buf));
2219 return(-1);
2220 } */
2221 if(nhinsi){
2222 hsize = abs(nhinsi);
2223 hno = (int *)malloc(hsize * sizeof(int));
2224 for(i = 0; i < hsize; i++) {
2225 _Sstrcpy(tmp, hname[i]);
2226 if((hno[i] = jl_hinsi_number_e(buf->env, tmp)) == -1) {
2227 free((char *)hno);
2228 UnlockMutex(&BUF_LOCK(buf));
2229 return(-1);
2230 }
2231 }
2232 }
2233 x = zen_conv_sho1(buf, bun_no, use_maep, uniq_level, 0, nhinsi, hno);
2234 if(nhinsi) free((char *)hno);
2235 UnlockMutex(&BUF_LOCK(buf));
2236 return x;
2237 }
2238
2239 int
jl_zenkouho_dai(buf,bun_no,bun_no2,use_maep,uniq_level)2240 jl_zenkouho_dai(buf, bun_no, bun_no2, use_maep, uniq_level)
2241 register struct wnn_buf *buf;
2242 int bun_no, bun_no2, use_maep, uniq_level;
2243 {
2244 int x;
2245
2246 if(!buf) return(-1);
2247 LockMutex(&BUF_LOCK(buf));
2248 buf_wnn_errorno_set = 0;
2249 x = zen_conv_dai1(buf, bun_no, bun_no2, use_maep, uniq_level, 0, 0, NULL);
2250 UnlockMutex(&BUF_LOCK(buf));
2251 return x;
2252 }
2253
2254 static int
zen_conv_dai1(buf,bun_no,bun_no2,use_maep,uniq_level,fuku,nhinsi,hlist)2255 zen_conv_dai1(buf, bun_no, bun_no2, use_maep, uniq_level, fuku, nhinsi, hlist)
2256 register struct wnn_buf *buf;
2257 int bun_no, bun_no2, use_maep, uniq_level, fuku, nhinsi, *hlist;
2258 {
2259 register struct wnn_buf_mt *buf_m = (WNN_BUF_MT *)buf;
2260 int cnt;
2261 w_char yomi[LENGTHBUNSETSU], yomi1[LENGTHBUNSETSU];
2262 struct wnn_dai_bunsetsu *dp;
2263 int tmp;
2264 register int k;
2265 int x;
2266 int nobi_top;
2267
2268 if(bun_no2 > (tmp = dai_end(buf_m, bun_no)) ||
2269 bun_no2 < 0) bun_no2 = tmp;
2270 jl_get_yomi_body(buf_m, bun_no, bun_no2, yomi);
2271 if (use_maep & WNN_USE_MAE && bun_no > 0) {
2272 dumbhinsi = buf->bun[bun_no - 1]->hinsi;
2273 jl_get_yomi_body(buf_m, bun_no - 1, bun_no, yomi1);
2274 mae_fzk = yomi1 + buf->bun[bun_no - 1]->jirilen;
2275 } else {
2276 dumbhinsi = WNN_BUN_SENTOU;
2277 mae_fzk = (w_char *)0;
2278 }
2279 if(use_maep & WNN_USE_ATO && bun_no2 < buf->bun_suu){
2280 syuutanv = buf->bun[bun_no2]->kangovect;
2281 syuutanv1 = WNN_VECT_KANZEN;
2282 buf->zenkouho_endvect = syuutanv;
2283 }else{
2284 syuutanv = WNN_VECT_KANZEN;
2285 syuutanv1 = WNN_VECT_NO;
2286 if(bun_no2 < buf->bun_suu){
2287 buf->bun[bun_no2]->dai_top = 1;
2288 }
2289 buf->zenkouho_endvect = -1;
2290 }
2291 if(!(buf->env)) return(-1);
2292 LockMutex(&(envmt->env_lock));
2293 if(fuku == 0 && nhinsi == 0) {
2294 if(buf->bun[bun_no]->fukugou == 0 && buf->bun[bun_no]->num_hinsi == 0) {
2295 if((cnt = js_kanzen_dai(buf->env, yomi, dumbhinsi, mae_fzk,
2296 syuutanv, syuutanv1, &buf_rb)) < 0){
2297 buf_wnn_errorno_copy(buf_m);
2298 if_dead_disconnect_b(buf_m);
2299 UnlockMutex(&(envmt->env_lock));
2300 return(-1);
2301 }
2302 } else {
2303 fuku = buf->bun[bun_no]->fukugou;
2304 nhinsi = buf->bun[bun_no]->num_hinsi;
2305 hlist = buf->bun[bun_no]->hinsi_list;
2306 if((cnt = js_henkan_with_data(buf->env, fuku, nhinsi, hlist,
2307 WNN_KANZEN_DAI, yomi, dumbhinsi, mae_fzk, syuutanv,
2308 syuutanv1, WNN_VECT_BUNSETSU, &buf_rb)) < 0) {
2309 buf_wnn_errorno_copy(buf_m);
2310 if_dead_disconnect_b(buf_m);
2311 UnlockMutex(&(envmt->env_lock));
2312 return(-1);
2313 }
2314 }
2315 } else {
2316 if((cnt = js_henkan_with_data(buf->env, fuku, nhinsi, hlist,
2317 WNN_KANZEN_DAI, yomi, dumbhinsi, mae_fzk, syuutanv,
2318 syuutanv1, WNN_VECT_BUNSETSU, &buf_rb)) < 0) {
2319 buf_wnn_errorno_copy(buf_m);
2320 if_dead_disconnect_b(buf_m);
2321 UnlockMutex(&(envmt->env_lock));
2322 return(-1);
2323 }
2324 }
2325
2326 dp = (struct wnn_dai_bunsetsu *)buf_rb.buf;
2327
2328 free_zenkouho(buf_m);
2329 /* Wander if it is OK, that is, only when all the
2330 * zenkouho's are got from zenkouho_dai, we need not move
2331 * the current dai-bunsetsu to the top of zenkouho's
2332 */
2333 for(k = bun_no; k < bun_no2; k++){
2334 if(buf->bun[k]->from_zenkouho != ZENKOUHO_DAI)break;
2335 }
2336 if (k >= bun_no2) k--;
2337 nobi_top = buf->bun[k]->nobi_top;
2338 if(k != bun_no2){ /* move the current to the top. */
2339 make_space_for(buf_m, ZENKOUHO, buf->zenkouho_suu, buf->zenkouho_suu,
2340 bun_no2 - bun_no);
2341 set_dai(&buf->bun[bun_no], &buf->zenkouho[0], bun_no2 - bun_no);
2342 buf->zenkouho_dai[0] = 0;
2343 buf->zenkouho_dai[1] = bun_no2 - bun_no;
2344 buf->zenkouho_dai_suu = 1;
2345 buf->zenkouho_suu = bun_no2 - bun_no;
2346 k = get_c_jikouho_dai(dp, cnt, buf->bun, bun_no);
2347 if(k >= 0){
2348 buf->zenkouho[0]->dai_top =
2349 (dp[k].sbn->status == WNN_CONNECT)? 0:1;
2350 buf->zenkouho[bun_no2-bun_no-1]->dai_end =
2351 (dp[k].sbn[dp[k].sbncnt-1].status_bkwd == WNN_CONNECT_BK)? 0:1;
2352 /* KURI *//* USO*?*/
2353 } else if (cnt == 0) {
2354 /* �֡��פϸ������ 0 �ʤΤǡ�dai_top, dai_end ��
2355 ����Ū�� 1 �ˤ��� */
2356 buf->zenkouho[0]->dai_top = 1;
2357 buf->zenkouho[bun_no2-bun_no-1]->dai_end = 1;
2358 }
2359 if(uniq_level || k < 0){
2360 insert_dai(buf_m, ZENKOUHO, -1, -1, dp, cnt, uniq_level, fuku, nhinsi, hlist);
2361 }else{
2362 insert_dai(buf_m, ZENKOUHO, -1, -1, dp, k, uniq_level, fuku, nhinsi, hlist);
2363 insert_dai(buf_m, ZENKOUHO, -1, -1, dp + k + 1, cnt - k - 1,
2364 uniq_level, fuku, nhinsi, hlist);
2365 }
2366 buf->c_zenkouho = 0;
2367 }else{
2368 insert_dai(buf_m, ZENKOUHO, -1, -1, dp, cnt, uniq_level, fuku, nhinsi, hlist);
2369 k = get_c_jikouho_from_zenkouho_dai(buf_m, buf->bun[bun_no]);
2370 if(k < 0){
2371 k = 0; /* Only when the kouho has been removed from dict. */
2372 }
2373 buf->c_zenkouho = k;
2374 }
2375 buf->zenkouho_bun = bun_no;
2376 buf->zenkouho_end_bun = bun_no2;
2377 buf->zenkouho_daip = DAI;
2378 for(k = 0 ; k < buf->zenkouho_suu; k++){
2379 /* ������ꥹ�Ȥ���Ƭ�θ�����Ф��Ƥ�ɬ�����ӥåȤ���Ȥ��褦�ˤ���
2380 ��ʸ��Ĺ�ǽ����Ѻ�ͥ��� */
2381 if(k == 0 ||
2382 (buf->zenkouho[k]->ima && buf->zenkouho[k]->dic_no != -1)) {
2383 add_down_bnst(buf_m, bun_no, buf->zenkouho[k]);
2384 }
2385 /*
2386 * ʸ�῭�Ф�/�̤��Ԥä��弡������ä����ˤϡ��������ʸ�����
2387 * �ˤ�ʸ�῭�Ф�/�̤�ξ����Ĥ��Ƥ�����ʸ���ڤ�ؽ��ǻ��Ѥ��롣
2388 */
2389 if (nobi_top) buf->zenkouho[k]->nobi_top = 1;
2390 }
2391 x = buf->c_zenkouho;
2392 UnlockMutex(&(envmt->env_lock));
2393 return x;
2394 }
2395
2396 int
jl_zenkouho_dai_hinsi_flag(buf,bun_no,bun_no2,use_maep,uniq_level,hinsi_op)2397 jl_zenkouho_dai_hinsi_flag(buf, bun_no, bun_no2, use_maep, uniq_level, hinsi_op)
2398 register struct wnn_buf *buf;
2399 int bun_no, bun_no2, use_maep, uniq_level, hinsi_op;
2400 {
2401 int x, hno;
2402 w_char tmp[64];
2403
2404 if(!buf) return(-1);
2405 LockMutex(&BUF_LOCK(buf));
2406 buf_wnn_errorno_set = 0;
2407 if(strncmp(js_get_lang(buf->env), WNN_J_LANG, 5)) {
2408 UnlockMutex(&BUF_LOCK(buf));
2409 return(-1);
2410 }
2411 if(hinsi_op == WNN_ZIP)
2412 _Sstrcpy(tmp, WNN_HINSI_ZIPCODE);
2413 else if(hinsi_op == WNN_TEL)
2414 _Sstrcpy(tmp, WNN_HINSI_TELNO);
2415 else if(hinsi_op == WNN_TANKAN)
2416 _Sstrcpy(tmp, WNN_HINSI_TANKAN);
2417 else {
2418 UnlockMutex(&BUF_LOCK(buf));
2419 return(-1);
2420 }
2421 if((hno = jl_hinsi_number_e(buf->env, tmp)) == -1) {
2422 UnlockMutex(&BUF_LOCK(buf));
2423 return(-1);
2424 }
2425 x = zen_conv_dai1(buf, bun_no, bun_no2, use_maep, uniq_level, 0, 1, &hno);
2426 UnlockMutex(&BUF_LOCK(buf));
2427 return x;
2428 }
2429
2430 int
jl_zenkouho_dai_with_hinsi_name(buf,bun_no,bun_no2,use_maep,uniq_level,nhinsi,hname)2431 jl_zenkouho_dai_with_hinsi_name(buf, bun_no, bun_no2, use_maep, uniq_level, nhinsi, hname)
2432 register struct wnn_buf *buf;
2433 int bun_no, bun_no2, use_maep, uniq_level, nhinsi;
2434 char **hname;
2435 {
2436 int x, i, hsize, *hno = NULL;
2437 w_char tmp[64];
2438
2439 if(!buf) return(-1);
2440 LockMutex(&BUF_LOCK(buf));
2441 buf_wnn_errorno_set = 0;
2442 /* if(strncmp(js_get_lang(buf->env), WNN_J_LANG, 5) || nhinsi == 0) {
2443 UnlockMutex(&BUF_LOCK(buf));
2444 return(-1);
2445 } */
2446 if(nhinsi){
2447 hsize = abs(nhinsi);
2448 hno = (int *)malloc(hsize * sizeof(int));
2449 for(i = 0; i < hsize; i++) {
2450 _Sstrcpy(tmp, hname[i]);
2451 if((hno[i] = jl_hinsi_number_e(buf->env, tmp)) == -1) {
2452 free((char *)hno);
2453 UnlockMutex(&BUF_LOCK(buf));
2454 return(-1);
2455 }
2456 }
2457 }
2458 x = zen_conv_dai1(buf, bun_no, bun_no2, use_maep, uniq_level, 0, nhinsi, hno);
2459 if(nhinsi) free((char *)hno);
2460 UnlockMutex(&BUF_LOCK(buf));
2461 return x;
2462 }
2463
2464 int
jl_set_jikouho(buf,offset)2465 jl_set_jikouho(buf, offset)
2466 register struct wnn_buf *buf;
2467 register int offset;
2468 {
2469 if(!buf) return(-1);
2470 LockMutex(&BUF_LOCK(buf));
2471 buf_wnn_errorno_set = 0;
2472 if(buf->zenkouho_suu <= 0) {
2473 UnlockMutex(&BUF_LOCK(buf));
2474 return(-1);
2475 }
2476 if(buf->zenkouho_daip == DAI){
2477 UnlockMutex(&BUF_LOCK(buf));
2478 return(-1);
2479 }
2480 offset = (offset + buf->zenkouho_suu) % buf->zenkouho_suu;
2481 if(buf->zenkouho_bun+1 < buf->bun_suu && buf->zenkouho_endvect != -1)
2482 buf->bun[buf->zenkouho_bun+1]->dai_top = buf->zenkouho[offset]->dai_end;
2483 free_sho((WNN_BUF_MT *)buf, &buf->bun[buf->zenkouho_bun]);
2484 set_sho(buf->zenkouho[offset], &buf->bun[buf->zenkouho_bun]);
2485 buf->c_zenkouho = offset;
2486 UnlockMutex(&BUF_LOCK(buf));
2487 return(offset);
2488 }
2489
2490
2491 int
jl_set_jikouho_dai(buf,offset)2492 jl_set_jikouho_dai(buf, offset)
2493 register struct wnn_buf *buf;
2494 int offset;
2495 {
2496 register int st, end, bun, k;
2497
2498 if(!buf) return(-1);
2499 LockMutex(&BUF_LOCK(buf));
2500 buf_wnn_errorno_set = 0;
2501 if(buf->zenkouho_suu <= 0) {
2502 UnlockMutex(&BUF_LOCK(buf));
2503 return(-1);
2504 }
2505 if(buf->zenkouho_daip == SHO){
2506 UnlockMutex(&BUF_LOCK(buf));
2507 return(-1);
2508 }
2509 offset = (offset + buf->zenkouho_dai_suu) % buf->zenkouho_dai_suu;
2510 if(buf->zenkouho_end_bun < buf->bun_suu && buf->zenkouho_endvect != -1)
2511 buf->bun[buf->zenkouho_end_bun]->dai_top =
2512 buf->zenkouho[buf->zenkouho_dai[offset+1]-1]->dai_end;
2513 free_bun((WNN_BUF_MT *)buf, buf->zenkouho_bun, buf->zenkouho_end_bun);
2514 st = buf->zenkouho_dai[offset];
2515 end = buf->zenkouho_dai[offset + 1];
2516 make_space_for((WNN_BUF_MT *)buf, BUN, buf->zenkouho_bun,
2517 buf->zenkouho_end_bun, end - st);
2518 for(bun = buf->zenkouho_bun, k = st; k < end;){
2519 set_sho(buf->zenkouho[k++], &buf->bun[bun++]);
2520 }
2521 buf->zenkouho_end_bun = buf->zenkouho_bun + end - st;
2522 buf->c_zenkouho = offset;
2523 UnlockMutex(&BUF_LOCK(buf));
2524 return(offset);
2525 }
2526
2527 /*:::DOC_START
2528 *
2529 * Function Name: do_autolearning
2530 * Description : ��ư�ؽ���Ԥ�
2531 * js_auto_word_add()��Ƥ�
2532 * Parameter :
2533 * buf : (In) wnn_buf��¤�ΤؤΥݥ���
2534 * type : (In) �ؽ����륿����(��������/ʸ���ڤ�)
2535 * yomi : (In) �ɤ�
2536 * kanji : (In) ����
2537 * hinsi : (In) �ʻ�
2538 *
2539 * Return value : 0==SUCCESS, -1==ERROR
2540 *
2541 * Author : Seiji KUWARI
2542 *
2543 * Revision history:
2544 * 15-May-96: �߾�: js_autolearning_word_add() �����顼�Ǥ� env ��
2545 * �ؽ�������ѹ����ʤ�
2546 *
2547 *:::DOC_END
2548 */
2549 static int
do_autolearning(env,type,yomi,kanji,hinsi)2550 do_autolearning(env, type, yomi, kanji, hinsi)
2551 struct wnn_env *env;
2552 int type;
2553 w_char *yomi, *kanji;
2554 int hinsi;
2555 {
2556 int ret;
2557
2558 if ((ret = js_autolearning_word_add(env, type, yomi, kanji, NULL, hinsi,
2559 0)) == -1) {
2560 if (env_wnn_errorno_eql == WNN_JSERVER_DEAD) {
2561 jl_disconnect_body(env);
2562 }
2563 return(-1);
2564 }
2565 return(ret);
2566 }
2567
2568 #ifdef KOREAN
2569 /* ñ���ؽ�
2570 * ñ��������������ϡ��������δ���ʸ����Ȥ��碌�Ƽ�����Ͽ���롣
2571 * ����ʸ��פǡ�����ʸ�פ�����ˤ��äơ��ֽ�פ���ñ���ξ��ϡ�����ʸ���
2572 * ������Ͽ���롣
2573 * ���ϡ��ʻ��̾��Ȥ�����Ͽ���Ƥ��롣
2574 */
2575 static int
tankan_auto_learning(buf,k,hinsi)2576 tankan_auto_learning(buf, k, hinsi)
2577 register struct wnn_buf *buf;
2578 int k;
2579 int hinsi;
2580 {
2581 int i, j;
2582 w_char tmp[LENGTHYOMI];
2583 w_char yomi[LENGTHYOMI];
2584 w_char kanji[LENGTHKANJI];
2585
2586 for (i = k; i > 0; i--) {
2587 if (buf->bun[i]->dic_no == -1) {
2588 i++;
2589 break;
2590 }
2591 wnn_area(buf->bun[i], tmp, WNN_KANJI);
2592 for (j = 0; j < buf->bun[i]->kanjilen; j++) {
2593 if (!ishanja(tmp[j])) {
2594 i++;
2595 goto _find;;
2596 }
2597 }
2598 }
2599 _find:
2600
2601 yomi[0] = kanji[0] = 0;
2602 for ( ; i <= k; i++) {
2603 wnn_area(buf->bun[i], tmp, WNN_YOMI);
2604 wnn_Strncat(yomi, tmp, buf->bun[i]->jirilen);
2605 wnn_area(buf->bun[i], tmp, WNN_KANJI);
2606 wnn_Strncat(kanji, tmp, buf->bun[i]->kanjilen);
2607 }
2608
2609 return(do_autolearning(buf->env, WNN_MUHENKAN_LEARNING, yomi, kanji,
2610 hinsi));
2611 }
2612
2613 /* �ϥ���ؽ�
2614 * �Ѵ�����������Ȥ��ƴ��������Ф줿�����ϥ������ꤷ�����ˤ��Υ�
2615 * �������Ͽ���롣
2616 * �ʻ�ϥϥ���Ȥ�����Ͽ���Ƥ���
2617 */
2618 static int
hangul_auto_learning(buf,k,hinsi,bun_no2)2619 hangul_auto_learning(buf, k, hinsi, bun_no2)
2620 register struct wnn_buf *buf;
2621 int k;
2622 int hinsi;
2623 int bun_no2;
2624 {
2625 int i, j;
2626 int find;
2627 w_char tmp[LENGTHYOMI];
2628 w_char yomi[LENGTHYOMI];
2629 w_char kanji[LENGTHKANJI];
2630
2631 yomi[0] = kanji[0] = 0;
2632 find = 0;
2633 for (i = k; i < bun_no2; i++) {
2634 wnn_area(buf->bun[i], tmp, WNN_KANJI);
2635 for (j = 0; j < buf->bun[i]->kanjilen; j++) {
2636 if (!ishangul(tmp[j])) {
2637 if (tmp[j] != ' ' && tmp[j] != JSPACE)
2638 goto _find_hangul;
2639 tmp[j] = 0;
2640 find = 1;
2641 break;
2642 }
2643 }
2644 wnn_Strncat(kanji, tmp, j);
2645 wnn_area(buf->bun[i], tmp, WNN_YOMI);
2646 wnn_Strncat(yomi, tmp, j);
2647 if (find == 1) break;
2648 }
2649 _find_hangul:
2650
2651 return(do_autolearning(buf->env, WNN_MUHENKAN_LEARNING, yomi, kanji,
2652 hinsi));
2653 }
2654
2655 /* ��°��ؽ�
2656 * ��Ω��ܥϥ������ꤷ�����ˡ����Υϥ���ʸ������μ�Ω�����³
2657 * ��ǽ����°��Ȥ�����Ͽ���롣
2658 * ���ϡ�����ʸ��Ρ���°����ʻ�Ȥ�����Ͽ���Ƥ��롣
2659 */
2660 static int
fuzokugo_auto_learning(buf,k,hinsi,bun_no2)2661 fuzokugo_auto_learning(buf, k, hinsi, bun_no2)
2662 register struct wnn_buf *buf;
2663 int k;
2664 int hinsi;
2665 int bun_no2;
2666 {
2667 int i, j;
2668 int find;
2669 w_char tmp[LENGTHYOMI];
2670 w_char yomi[LENGTHYOMI];
2671 w_char kanji[LENGTHKANJI];
2672
2673 if (k <= 0 || buf->bun[k-1]->dic_no == -1)
2674 return (0);
2675 wnn_area(buf->bun[k-1], tmp, WNN_KANJI);
2676 for (j = 0; j < buf->bun[k-1]->kanjilen; j++) {
2677 if (!ishanja(tmp[j]))
2678 return(0);
2679 }
2680
2681 yomi[0] = kanji[0] = 0;
2682 find = 0;
2683 for (i = k; i < bun_no2; i++) {
2684 wnn_area(buf->bun[i], tmp, WNN_KANJI);
2685 for (j = 0; j < buf->bun[i]->kanjilen; j++) {
2686 if (!ishangul(tmp[j])) {
2687 if (tmp[j] != ' ' && tmp[j] != JSPACE)
2688 goto _find_fzk;
2689 tmp[j] = 0;
2690 find = 1;
2691 break;
2692 }
2693 }
2694 wnn_Strncat(kanji, tmp, j);
2695 wnn_area(buf->bun[i], tmp, WNN_YOMI);
2696 wnn_Strncat(yomi, tmp, j);
2697 if (find == 1) break;
2698 }
2699 _find_fzk:
2700
2701 return(do_autolearning(buf->env, WNN_BUNSETSUGIRI_LEARNING, yomi, kanji,
2702 hinsi));
2703 }
2704 #endif /* KOREAN */
2705
2706 static int
muhenkan_auto_learning(buf,wb)2707 muhenkan_auto_learning(buf, wb)
2708 struct wnn_buf *buf;
2709 register WNN_BUN *wb;
2710 {
2711 int hinsi;
2712 w_char yomi[LENGTHYOMI];
2713 w_char kanji[LENGTHKANJI];
2714
2715 wnn_area(wb, yomi, WNN_YOMI);
2716 wnn_area(wb, kanji, WNN_KANJI);
2717 yomi[wb->jirilen] = (w_char)0;
2718 kanji[wb->real_kanjilen] = (w_char)0;
2719 if(wb->entry == WNN_IKEIJI_ENTRY)
2720 hinsi = wb->hinsi;
2721 else
2722 hinsi = wnn_meisi;
2723 return(do_autolearning(buf->env, WNN_MUHENKAN_LEARNING, yomi, kanji,
2724 hinsi));
2725 }
2726
2727 static int
bunsetsugiri_auto_learning(buf,wb,bun_no,bun_no2)2728 bunsetsugiri_auto_learning(buf, wb, bun_no, bun_no2)
2729 register struct wnn_buf *buf;
2730 register WNN_BUN *wb;
2731 int bun_no, bun_no2;
2732 {
2733 register int i;
2734 register WNN_BUN *wb1;
2735 w_char yomi[LENGTHYOMI];
2736 w_char kanji[LENGTHKANJI];
2737 int yomilen, kanjilen, fuzokugolen, found_dai_top;
2738
2739 wnn_area(wb, yomi, WNN_YOMI);
2740 wnn_area(wb, kanji, WNN_KANJI);
2741 yomilen = wb->yomilen;
2742 kanjilen = wb->kanjilen;
2743 wb1 = buf->bun[bun_no+1];
2744 wnn_area(wb1, &yomi[yomilen], WNN_YOMI);
2745 wnn_area(wb1, &kanji[kanjilen], WNN_KANJI);
2746 yomilen += wb1->yomilen;
2747 kanjilen += wb1->kanjilen;
2748 fuzokugolen = wb1->yomilen - wb1->jirilen;
2749 yomi[yomilen - fuzokugolen] = (w_char)0;
2750 kanji[kanjilen - fuzokugolen] = (w_char)0;
2751 return(do_autolearning(buf->env, WNN_BUNSETSUGIRI_LEARNING, yomi, kanji,
2752 wb1->hinsi));
2753 }
2754
2755 static int
rendaku_learning(buf,mode,wb1,bun_no,bun_no2)2756 rendaku_learning(buf, mode, wb1, bun_no, bun_no2)
2757 register struct wnn_buf *buf;
2758 register WNN_BUN *wb1;
2759 int mode, bun_no, bun_no2;
2760 {
2761 register int i;
2762 register WNN_BUN *wb;
2763 w_char yomi[LENGTHYOMI];
2764 w_char kanji[LENGTHKANJI];
2765 int yomilen, kanjilen, fuzokugolen, found_dai_top;
2766
2767 wb = buf->bun[bun_no];
2768 wnn_area(wb, yomi, WNN_YOMI);
2769 wnn_area(wb, kanji, WNN_KANJI);
2770 yomilen = wb->yomilen;
2771 kanjilen = wb->kanjilen;
2772 wnn_area(wb1, &yomi[yomilen], WNN_YOMI);
2773 wnn_area(wb1, &kanji[kanjilen], WNN_KANJI);
2774 yomilen += wb1->yomilen;
2775 kanjilen += wb1->kanjilen;
2776 fuzokugolen = wb1->yomilen - wb1->jirilen;
2777 yomi[yomilen - fuzokugolen] = (w_char)0;
2778 kanji[kanjilen - fuzokugolen] = (w_char)0;
2779 if (mode != WNN_DIC_RW) {
2780 if (js_temporary_word_add(buf->env, yomi, kanji, NULL, wnn_meisi, 0) == -1) {
2781 if (env_wnn_errorno_eql == WNN_JSERVER_DEAD) {
2782 jl_disconnect_body(buf->env);
2783 }
2784 return(-1);
2785 }
2786 return(0);
2787 }
2788 return(do_autolearning(buf->env, WNN_BUNSETSUGIRI_LEARNING, yomi, kanji,
2789 wnn_meisi));
2790 }
2791
2792 /*:::DOC_START
2793 *
2794 * Function Name: jl_update_hindo
2795 * Description : ����ʸ�ᤫ�����پ���ʺ��ӥåȡ����١ˤι�����
2796 * jlib ��Ƚ�ǤǤ���ؽ�������Ԥ�
2797 * Parameter :
2798 * buf : (In) �Хåե��ؤΥݥ���
2799 * bun_no : (In) ���ꤷ��ʸ�����Ƭʸ���ֹ�
2800 * bun_no2 : (In) ���ꤷ��ʸ��κǽ�ʸ���ľ���ʸ���ֹ�
2801 *
2802 * Return value : 0==SUCCESS, -1==ERROR
2803 *
2804 * Author : Hideyuki Kishiba
2805 *
2806 * Revision history:
2807 *
2808 *:::DOC_END
2809 */
2810 int
jl_update_hindo(buf,bun_no,bun_no2)2811 jl_update_hindo(buf, bun_no, bun_no2)
2812 register struct wnn_buf *buf;
2813 int bun_no, bun_no2;
2814 {
2815 register int k;
2816 register WNN_BUN *wb;
2817
2818 if(!buf) return(-1);
2819 LockMutex(&BUF_LOCK(buf));
2820 buf_wnn_errorno_set = 0;
2821 if(bun_no < 0 || !(buf->env)) {
2822 UnlockMutex(&BUF_LOCK(buf));
2823 return(-1);
2824 }
2825 if(bun_no2 >= buf->bun_suu || bun_no2 < 0) bun_no2 = buf->bun_suu;
2826
2827 LockMutex(&(envmt->env_lock));
2828
2829 if(
2830 /* ���ӥåȤ���Ȥ��٤�����κ��ӥåȤ���Ȥ� */
2831 set_ima_off(buf, bun_no, bun_no2, 0) == -1 ||
2832 /* jlib ���Ƚ�ǤǤ���ؽ�������Ԥ� */
2833 optimize_in_lib(buf, bun_no, bun_no2) == -1) {
2834 buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
2835 if (buf_wnn_errorno_eql == WNN_JSERVER_DEAD) goto ERROR_RET;
2836 }
2837
2838 /* ���ꤷ������κ��ӥåȡ����٤�夲�� */
2839 for(k = bun_no; k < bun_no2; k++) {
2840 if(buf->bun[k]->hindo_updated != 1) continue;
2841 buf->bun[k]->hindo_updated = 2;
2842 wb = buf->bun[k];
2843 if(js_hindo_set(buf->env, wb->dic_no, wb->entry,
2844 WNN_IMA_ON, WNN_HINDO_INC) == -1){
2845 buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
2846 if (buf_wnn_errorno_eql == WNN_JSERVER_DEAD) goto ERROR_RET;
2847 }
2848 }
2849
2850 /* �ؽ�����ư�����ֳ�������ã�����顢��ư�����֤�Ԥ� */
2851 kakutei_count ++;
2852 if(buf->env->autosave > 0 && kakutei_count >= buf->env->autosave) {
2853 jl_dic_save_all_e_body(buf->env);
2854 kakutei_count = 0;
2855 }
2856
2857 UnlockMutex(&(envmt->env_lock));
2858 UnlockMutex(&BUF_LOCK(buf));
2859 return(0);
2860
2861 ERROR_RET:
2862 jl_disconnect_body(buf->env);
2863 UnlockMutex(&(envmt->env_lock));
2864 UnlockMutex(&BUF_LOCK(buf));
2865 return(-1);
2866 } /* End of jl_update_hindo */
2867
2868 /*:::DOC_START
2869 *
2870 * Function Name: jl_optimize_fi
2871 * Description : ����ʸ�ᤫ�����پ���ʺ��ӥåȡ����١ˤι����ȡ�
2872 * Wnn5 ���ɲä����ؽ������ȣƣɳؽ�������Ԥ�
2873 * Parameter :
2874 * buf : (In) �Хåե��ؤΥݥ���
2875 * bun_no : (In) ���ꤷ��ʸ�����Ƭʸ���ֹ�
2876 * bun_no2 : (In) ���ꤷ��ʸ��κǽ�ʸ���ľ���ʸ���ֹ�
2877 *
2878 * Return value : 0==SUCCESS, -1==ERROR
2879 *
2880 * Author : Hideyuki Kishiba
2881 *
2882 * Revision history:
2883 *
2884 *:::DOC_END
2885 */
2886 int
jl_optimize_fi(buf,bun_no,bun_no2)2887 jl_optimize_fi(buf, bun_no, bun_no2)
2888 register struct wnn_buf *buf;
2889 int bun_no, bun_no2;
2890 {
2891 if(!buf) return(-1);
2892 LockMutex(&BUF_LOCK(buf));
2893 buf_wnn_errorno_set = 0;
2894 if(bun_no < 0 || !(buf->env)) {
2895 UnlockMutex(&BUF_LOCK(buf));
2896 return(-1);
2897 }
2898 if(strncmp(js_get_lang(buf->env), WNN_J_LANG, 5)) {
2899 UnlockMutex(&BUF_LOCK(buf));
2900 return(jl_update_hindo(buf, bun_no, bun_no2));
2901 }
2902 if(bun_no2 >= buf->bun_suu || bun_no2 < 0) bun_no2 = buf->bun_suu;
2903
2904 LockMutex(&(envmt->env_lock));
2905
2906 if(
2907 /* ���ӥåȤ���Ȥ��٤�����ȣƣ���³�ط��κ��ӥåȤ���Ȥ� */
2908 set_ima_off(buf, bun_no, bun_no2, 1) == -1 ||
2909 /* jlib ���Ƚ�ǤǤ���ؽ�������Ԥ� */
2910 optimize_in_lib(buf, bun_no, bun_no2) == -1 ||
2911 /* server ���Ƚ�Ǥ��� Wnn5 �ؽ������ȣƣɳؽ�������Ԥ� */
2912 optimize_in_server(buf, bun_no, bun_no2) == -1) {
2913 buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
2914 if (buf_wnn_errorno_eql == WNN_JSERVER_DEAD) goto ERROR_RET;
2915 }
2916
2917 /* �ؽ�����ư�����ֳ�������ã�����顢��ư�����֤�Ԥ� */
2918 kakutei_count ++;
2919 if(buf->env->autosave > 0 && kakutei_count >= buf->env->autosave) {
2920 jl_dic_save_all_e_body(buf->env);
2921 kakutei_count = 0;
2922 }
2923
2924 UnlockMutex(&(envmt->env_lock));
2925 UnlockMutex(&BUF_LOCK(buf));
2926 return(0);
2927 ERROR_RET:
2928 jl_disconnect_body(buf->env);
2929 UnlockMutex(&(envmt->env_lock));
2930 UnlockMutex(&BUF_LOCK(buf));
2931 return(-1);
2932 } /* End of jl_optimize_fi */
2933
2934 /*:::DOC_START
2935 *
2936 * Function Name: jl_reset_prev_bun
2937 * Description : ������ʸ��������������
2938 * Parameter :
2939 * buf : (In) �Хåե��ؤΥݥ���
2940 *
2941 * Return value : 0==SUCCESS, -1==ERROR
2942 *
2943 * Author : Hideyuki Kishiba
2944 *
2945 * Revision history:
2946 *
2947 *:::DOC_END
2948 */
2949 int
jl_reset_prev_bun(buf)2950 jl_reset_prev_bun(buf)
2951 register struct wnn_buf *buf;
2952 {
2953 int i;
2954
2955 if(!buf) return(-1);
2956 LockMutex(&BUF_LOCK(buf));
2957 buf_wnn_errorno_set = 0;
2958 if(!(buf->env)) {
2959 UnlockMutex(&BUF_LOCK(buf));
2960 return(-1);
2961 }
2962
2963 for(i = 0; i < WNN_PREV_BUN_SUU; i++) buf->prev_bun[i].dic_no = -2;
2964
2965 UnlockMutex(&BUF_LOCK(buf));
2966 return(0);
2967 } /* End of jl_reset_prev_bun */
2968
2969 /*:::DOC_START
2970 *
2971 * Function Name: set_ima_off
2972 * Description : �Ѵ��˻��Ѥ���ʤ��ä�����κ��ӥåȤ���Ȥ����ƣ��Ѵ����
2973 * ���Ѥ����ƣ���³�ط��κ��ӥåȤ��٤���Ȥ�
2974 * Parameter :
2975 * buf : (In) �Хåե��ؤΥݥ���
2976 * bun_no : (In) ���ꤷ��ʸ�����Ƭʸ���ֹ�
2977 * bun_no2 : (In) ���ꤷ��ʸ��κǽ�ʸ���ľ���ʸ���ֹ�
2978 * fi_flag : (In) �ƣɳؽ��ʤ��ʤ�������˥ե饰
2979 *
2980 * Return value : 0==SUCCESS, -1==ERROR
2981 *
2982 * Author : Hideyuki Kishiba
2983 *
2984 * Revision history:
2985 *
2986 *:::DOC_END
2987 */
2988 static int
set_ima_off(buf,bun_no,bun_no2,fi_flag)2989 set_ima_off(buf, bun_no, bun_no2, fi_flag)
2990 register struct wnn_buf *buf;
2991 int bun_no, bun_no2, fi_flag;
2992 {
2993 register int k;
2994 register WNN_BUN *wb;
2995
2996 /* ����κ��ӥåȤ���Ȥ� */
2997 for(k = bun_no; k < bun_no2; k++){
2998 if(buf->bun[k]->hindo_updated == 1) continue;
2999 for(wb = buf->down_bnst[k]; wb; wb = wb->down){
3000 if(wb->bug == 1) break;
3001 wb->bug = 1;
3002 if(wb->dic_no != -1){
3003 if(js_hindo_set(buf->env, wb->dic_no, wb->entry,
3004 WNN_IMA_OFF, WNN_HINDO_NOP) == -1) {
3005 buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
3006 if (buf_wnn_errorno_eql == WNN_JSERVER_DEAD)
3007 return(-1);
3008 }
3009 }
3010 }
3011 }
3012 free_down((WNN_BUF_MT *)buf, bun_no, bun_no2);
3013
3014 /* �ƣ���³�ط��κ��ӥåȤ���Ȥ� */
3015 if(fi_flag) {
3016 if(js_set_fi_priority(buf->env, &(buf->fi_rb)) == -1) {
3017 buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
3018 if (buf_wnn_errorno_eql == WNN_JSERVER_DEAD)
3019 return(-1);
3020 }
3021 /* �ƣ���³�ط�������¤�Τν���� */
3022 buf->fi_rb.num = 0;
3023 }
3024
3025 return(0);
3026 } /* End of set_ima_off */
3027
3028 /*:::DOC_START
3029 *
3030 * Function Name: optimize_in_lib
3031 * Description : jlib ��ǹԤ��ؽ���������
3032 * Parameter :
3033 * buf : (In) �Хåե��ؤΥݥ���
3034 * bun_no : (In) ���ꤷ��ʸ�����Ƭʸ���ֹ�
3035 * bun_no2 : (In) ���ꤷ��ʸ��κǽ�ʸ���ľ���ʸ���ֹ�
3036 *
3037 * Return value : 0==SUCCESS, -1==ERROR
3038 *
3039 * Author : Hideyuki Kishiba
3040 *
3041 * Revision history:
3042 *
3043 *:::DOC_END
3044 */
3045 static int
optimize_in_lib(buf,bun_no,bun_no2)3046 optimize_in_lib(buf, bun_no, bun_no2)
3047 register struct wnn_buf *buf;
3048 int bun_no, bun_no2;
3049 {
3050 register int k;
3051 register WNN_BUN *wb;
3052
3053 for(k = bun_no; k < bun_no2; k++){
3054 if(buf->bun[k]->hindo_updated == 1) continue;
3055 buf->bun[k]->hindo_updated = 1;
3056 wb = buf->bun[k];
3057
3058 #ifdef KOREAN
3059 if(!strncmp(js_get_lang(buf->env), WNN_K_LANG, 5)) {
3060 /* ñ���ؽ� */
3061 if ((wb->hinsi == kwnn_tankan) && /* Tankan */
3062 (buf->env->muhenkan_mode != WNN_DIC_RDONLY)) {
3063 if (tankan_auto_learning(buf, k, kwnn_meisi) == -1) {
3064 buf_wnn_errorno_copy(buf);
3065 if (buf_wnn_errorno_eql == WNN_JSERVER_DEAD)
3066 return(-1);
3067 }
3068 }
3069 /* �ְ�äƴ������Ѵ������Τ�ϥ�����Ȥ��Ƽ������Ͽ */
3070 if ((wb->from_zenkouho & 1) == ZENKOUHO &&
3071 wb->hinsi == kwnn_hangul && wb->dic_no == -1 &&
3072 /* Hangul */
3073 (buf->env->muhenkan_mode != WNN_DIC_RDONLY) ) {
3074 if (hangul_auto_learning(buf, k, kwnn_hangul, bun_no2) == -1) {
3075 buf_wnn_errorno_copy(buf);
3076 if (buf_wnn_errorno_eql == WNN_JSERVER_DEAD)
3077 return(-1);
3078 }
3079 }
3080 /* ��°��ؽ� */
3081 if (k > 0 && wb->hinsi == kwnn_hangul && wb->dic_no == -1 &&
3082 /* Hangul */
3083 (buf->env->bunsetsugiri_mode != WNN_DIC_RDONLY)) {
3084 if (fuzokugo_auto_learning(buf, k, kwnn_fuzokugo, bun_no2) == -1) {
3085 buf_wnn_errorno_copy(buf);
3086 if (buf_wnn_errorno_eql == WNN_JSERVER_DEAD)
3087 return(-1);
3088 }
3089 }
3090 } else
3091 #endif /* KOREAN */
3092 {
3093 /* �Ҥ餬�ʳؽ����������ʳؽ����۷����ؽ� */
3094 if (((wb->dic_no == -1) &&
3095 (buf->env->muhenkan_mode != WNN_DIC_RDONLY) &&
3096 ((wb->entry == WNN_KATAKANA) || (wb->entry == WNN_HIRAGANA))&&
3097 (wb->jirilen >= WNN_KATAKANA_LEARNING_LEN)) ||
3098 wb->entry == WNN_IKEIJI_ENTRY) {
3099 int entry;
3100
3101 if ((entry = muhenkan_auto_learning(buf, wb)) == -1) {
3102 buf_wnn_errorno_copy(buf);
3103 if (buf_wnn_errorno_eql == WNN_JSERVER_DEAD)
3104 return(-1);
3105 }
3106 wb->dic_no = WNN_MUHENKAN_DIC;
3107 wb->entry = entry;
3108 }
3109
3110 /* ��ʸ��ؽ� */
3111 if (wb->dai_top && ((k + 1) < bun_no2) &&
3112 !buf->bun[k + 1]->dai_top) {
3113 if (rendaku_learning(buf, buf->env->bunsetsugiri_mode,
3114 buf->bun[k + 1], k, k+1) == -1) {
3115 buf_wnn_errorno_copy(buf);
3116 if (buf_wnn_errorno_eql == WNN_JSERVER_DEAD)
3117 return(-1);
3118 }
3119 } else
3120 /* Ϣ���ؽ� */
3121 if ((k > bun_no) && (wb->hinsi == wnn_rendaku) &&
3122 (buf->bun[k-1]->yomilen == buf->bun[k-1]->jirilen)) {
3123 if (rendaku_learning(buf, buf->env->bunsetsugiri_mode, wb, k-1, k)
3124 == -1) {
3125 buf_wnn_errorno_copy(buf);
3126 if (buf_wnn_errorno_eql == WNN_JSERVER_DEAD)
3127 return(-1);
3128 }
3129 } else
3130 /* ��Ƭ��(��)�ؽ� */
3131 if (((k + 1) < bun_no2) && (wb->hinsi == wnn_settou)) {
3132 if (rendaku_learning(buf, buf->env->bunsetsugiri_mode,
3133 buf->bun[k + 1], k, k+1)
3134 == -1) {
3135 buf_wnn_errorno_copy(buf);
3136 if (buf_wnn_errorno_eql == WNN_JSERVER_DEAD)
3137 return(-1);
3138 }
3139 } else
3140 /* ʸ���ڤ�ؽ� */
3141 if (wb->nobi_top &&
3142 (buf->env->bunsetsugiri_mode != WNN_DIC_RDONLY) &&
3143 ((k + 1) < bun_no2) &&
3144 (buf->bun[k+1]->hinsi != wnn_rendaku &&
3145 buf->bun[k]->hinsi != wnn_settou)) {
3146 if (bunsetsugiri_auto_learning(buf, wb, k, bun_no2) == -1) {
3147 buf_wnn_errorno_copy(buf);
3148 if (buf_wnn_errorno_eql == WNN_JSERVER_DEAD)
3149 return(-1);
3150 }
3151 }
3152 }
3153 }
3154 return(0);
3155 } /* End of optimize_in_lib */
3156
3157 /*:::DOC_START
3158 *
3159 * Function Name: optimize_in_server
3160 * Description : jserver ��ǹԤ��ؽ���������
3161 * Parameter :
3162 * buf : (In) �Хåե��ؤΥݥ���
3163 * bun_no : (In) ���ꤷ��ʸ�����Ƭʸ���ֹ�
3164 * bun_no2 : (In) ���ꤷ��ʸ��κǽ�ʸ���ľ���ʸ���ֹ�
3165 *
3166 * Return value : 0==SUCCESS, -1==ERROR
3167 *
3168 * Author : Hideyuki Kishiba
3169 *
3170 * Revision history:
3171 *
3172 *:::DOC_END
3173 */
3174 static int
optimize_in_server(buf,bun_no,bun_no2)3175 optimize_in_server(buf, bun_no, bun_no2)
3176 register struct wnn_buf *buf;
3177 int bun_no, bun_no2;
3178 {
3179 register int k, j;
3180 register WNN_BUN *wb;
3181
3182 int nkouho, *dic, *entry, *ima, *hindo, *kmoji;
3183 w_char **kouho, *tmp;
3184 struct wnn_prev_bun *prev;
3185
3186 /* ���ܸ�Τߤ��ݡ��� */
3187 if(strncmp(js_get_lang(buf->env), WNN_J_LANG, 5)) return(0);
3188
3189 /* ������ʸ�����ʬ����������˲ä��� */
3190 nkouho = bun_no2 - bun_no + WNN_PREV_BUN_SUU;
3191
3192 if ( (dic = (int *)malloc(nkouho * sizeof(int))) == NULL )
3193 return(-1);
3194
3195 if ( (entry = (int *)malloc(nkouho * sizeof(int))) == NULL ) {
3196 free(dic);
3197 return(-1);
3198 }
3199 if ( (ima = (int *)malloc(nkouho * sizeof(int))) == NULL ) {
3200 free(dic);
3201 free(entry);
3202 return(-1);
3203 }
3204 if ( (hindo = (int *)malloc(nkouho * sizeof(int))) == NULL ) {
3205 free(dic);
3206 free(entry);
3207 free(ima);
3208 return(-1);
3209 }
3210 if ( (kmoji = (int *)malloc(nkouho * sizeof(int))) == NULL ) {
3211 free(dic);
3212 free(entry);
3213 free(ima);
3214 free(hindo);
3215 return(-1);
3216 }
3217 if ( (kouho = (w_char **)malloc(nkouho * sizeof(w_char *))) == NULL ) {
3218 free(dic);
3219 free(entry);
3220 free(ima);
3221 free(hindo);
3222 free(kmoji);
3223 return(-1);
3224 }
3225 if ( (tmp = (w_char *)malloc(nkouho * sizeof(w_char) * LENGTHKANJI)) == NULL ) {
3226 free(dic);
3227 free(entry);
3228 free(ima);
3229 free(hindo);
3230 free(kmoji);
3231 free(kouho);
3232 return(-1);
3233 }
3234 for(k = 0; k < nkouho; k++) {
3235 kouho[k] = tmp;
3236 tmp += LENGTHKANJI;
3237 }
3238
3239 /* ������ʸ���������ʸ����������� */
3240 prev = buf->prev_bun;
3241 for(j = 0, k = WNN_PREV_BUN_SUU - 1; j < WNN_PREV_BUN_SUU; j++, k--) {
3242 dic[j] = prev[k].dic_no;
3243 entry[j] = prev[k].entry;
3244 ima[j] = WNN_HINDO_NOP;
3245 hindo[j] = WNN_HINDO_NOP;
3246 kmoji[j] = prev[k].real_kanjilen;
3247 wnn_Strcpy(kouho[j], prev[k].kouho);
3248 }
3249
3250 for(k = WNN_PREV_BUN_SUU; k < nkouho; k++) {
3251 wb = buf->bun[(k - WNN_PREV_BUN_SUU) + bun_no];
3252 dic[k] = wb->dic_no; /* �����ֹ� */
3253 entry[k] = wb->entry; /* ����ȥ��ֹ� */
3254 if(wb->hindo_updated == 1) {
3255 ima[k] = WNN_IMA_ON; /* ���ӥåȤ�������ˡ */
3256 hindo[k] = WNN_HINDO_INC; /* ���٤�������ˡ */
3257 wb->hindo_updated = 2;
3258 } else {
3259 ima[k] = WNN_HINDO_NOP; /* ���ӥåȤ�������ˡ */
3260 hindo[k] = WNN_HINDO_NOP; /* ���٤�������ˡ */
3261 }
3262 kmoji[k] = wb->real_kanjilen; /* ����ʸ��������°��ʤ���*/
3263 wnn_area(wb, kouho[k], WNN_KANJI); /* ����ʸ�������°�줢���*/
3264 }
3265
3266 /* ľ�����국��ʸ���������ʸ��������ʤ��Ȥ��ϡ�
3267 ����ʸ���ʬ�Ť�ʸ������õ�����Τ�ľ�����국��ʸ�����
3268 ʸ������Ф��Ƥ����褦�ˤ��� */
3269 for(j = WNN_PREV_BUN_SUU - 1, k = WNN_PREV_BUN_SUU - (bun_no2 - bun_no) - 1;
3270 k >= 0; j--, k--) {
3271 prev[j].dic_no = prev[k].dic_no;
3272 prev[j].entry = prev[k].entry;
3273 prev[j].real_kanjilen = prev[k].real_kanjilen;
3274 wnn_Strcpy(prev[j].kouho, prev[k].kouho);
3275 prev[j].jirilen = prev[k].jirilen;
3276 prev[j].hinsi = prev[k].hinsi;
3277 }
3278 /* ����γ�������ľ������������������ */
3279 for(j = 0, k = nkouho - WNN_PREV_BUN_SUU - 1;
3280 j < WNN_PREV_BUN_SUU && k >= 0;
3281 j++, k--) {
3282 wb = buf->bun[k + bun_no];
3283 prev[j].dic_no = wb->dic_no;
3284 prev[j].entry = wb->entry;
3285 prev[j].real_kanjilen = wb->real_kanjilen;
3286 wnn_area(wb, prev[j].kouho, WNN_KANJI);
3287 prev[j].jirilen = wb->jirilen;
3288 prev[j].hinsi = wb->hinsi;
3289 }
3290
3291 /* Wnn5 �ؽ��ܣƣɳؽ� */
3292 k = js_optimize_fi(buf->env, nkouho, dic, entry, ima, hindo, kmoji, kouho);
3293
3294 if(k == -1) {
3295 buf_wnn_errorno_copy((WNN_BUF_MT *)buf)
3296 if (buf_wnn_errorno_eql == WNN_JSERVER_DEAD) {
3297 free(dic);
3298 free(entry);
3299 free(ima);
3300 free(hindo);
3301 free(kmoji);
3302 free(kouho[0]);
3303 free(kouho);
3304 return(-1);
3305 }
3306 }
3307 free(dic);
3308 free(entry);
3309 free(ima);
3310 free(hindo);
3311 free(kmoji);
3312 free(kouho[0]);
3313 free(kouho);
3314 return(0);
3315 } /* End of optimize_in_server */
3316
3317
3318 static w_char *
wnn_area(bp,area,kanjip)3319 wnn_area(bp, area, kanjip)
3320 WNN_BUN *bp;
3321 w_char *area;
3322 int kanjip;
3323 {
3324 register WNN_BUN *bp1;
3325 register w_char *c, *end;
3326
3327 for(bp1 = bp; bp1; bp1 = bp1->next){
3328 if(bp1 != bp) c = (w_char *)bp1;
3329 else c = bp1->yomi;
3330 end = (w_char *)&bp1->next;
3331 for(;c < end;){
3332 if(!kanjip){
3333 if((*area++ = *c++) == 0){ area--; goto out;}
3334 }else{
3335 if(*c++ == 0) kanjip--;
3336 }
3337 }
3338 }
3339 out:
3340 return(area);
3341 }
3342
3343 static int
dai_end(buf,bun_no)3344 dai_end(buf, bun_no)
3345 register struct wnn_buf_mt *buf;
3346 register int bun_no;
3347 {
3348 bun_no++;
3349 for(;bun_no < buf->orig.bun_suu && !buf->orig.bun[bun_no]->dai_top; bun_no++);
3350 return(bun_no);
3351 }
3352
3353 #define dai_end_zenkouho(buf, bun_no) (buf->zenkouho_dai[bun_no + 1])
3354
3355 #ifdef CONVERT_by_STROKE
3356 /* ɮ�� (Bi Xing) */
3357 void
jl_get_zenkouho_yomi(buf,zen_num,area)3358 jl_get_zenkouho_yomi(buf, zen_num, area)
3359 register struct wnn_buf *buf;
3360 int zen_num;
3361 w_char *area;
3362 {
3363 register int k, end;
3364
3365 if(!buf) return;
3366 LockMutex(&BUF_LOCK(buf));
3367 buf_wnn_errorno_set = 0;
3368 if(buf->zenkouho_daip==SHO){
3369 wnn_area(buf->zenkouho[zen_num], area, WNN_YOMI);
3370 }else{
3371 end = dai_end_zenkouho(buf, zen_num);
3372 for(k = buf->zenkouho_dai[zen_num]; k < end; k++){
3373 area = wnn_area(buf->zenkouho[k], area, WNN_KANJI);
3374 }
3375 }
3376 UnlockMutex(&BUF_LOCK(buf));
3377 }
3378 #endif
3379
3380 void
jl_get_zenkouho_kanji(buf,zen_num,area)3381 jl_get_zenkouho_kanji(buf, zen_num, area)
3382 register struct wnn_buf *buf;
3383 int zen_num;
3384 w_char *area;
3385 {
3386 register int k, end;
3387
3388 if(!buf) return;
3389 LockMutex(&BUF_LOCK(buf));
3390 buf_wnn_errorno_set = 0;
3391 if(buf->zenkouho_daip==SHO){
3392 wnn_area(buf->zenkouho[zen_num], area, WNN_KANJI);
3393 }else{
3394 end = dai_end_zenkouho(buf, zen_num);
3395 for(k = buf->zenkouho_dai[zen_num]; k < end; k++){
3396 area = wnn_area(buf->zenkouho[k], area, WNN_KANJI);
3397 }
3398 }
3399 UnlockMutex(&BUF_LOCK(buf));
3400 }
3401
3402 static int
wnn_get_area_body(buf,bun_no,bun_no2,area,kanjip)3403 wnn_get_area_body(buf, bun_no, bun_no2, area, kanjip)
3404 struct wnn_buf_mt *buf;
3405 register int bun_no, bun_no2;
3406 w_char *area;
3407 int kanjip;
3408 {
3409 register int k;
3410 w_char *area1 = area;
3411 int x;
3412
3413 if(bun_no < 0) {
3414 return(0);
3415 }
3416 if(bun_no2 >= buf->orig.bun_suu || bun_no2 < 0) bun_no2 = buf->orig.bun_suu;
3417
3418 for(k = bun_no; k < bun_no2; k++){
3419 area = wnn_area(buf->orig.bun[k], area, kanjip);
3420 }
3421 x = area - area1;
3422 return x;
3423 }
3424
3425 int
wnn_get_area(buf,bun_no,bun_no2,area,kanjip)3426 wnn_get_area(buf, bun_no, bun_no2, area, kanjip)
3427 struct wnn_buf *buf;
3428 register int bun_no, bun_no2;
3429 w_char *area;
3430 int kanjip;
3431 {
3432 int x;
3433
3434 if(!buf) return(0);
3435 LockMutex(&BUF_LOCK(buf));
3436 x = wnn_get_area_body((WNN_BUF_MT *)buf, bun_no, bun_no2, area, kanjip);
3437 UnlockMutex(&BUF_LOCK(buf));
3438 return x;
3439 }
3440
3441 #define JISHO 1
3442 #define HINDO 2
3443 #define FI_JISHO 3 /* Hideyuki Kishiba (Jul. 7, 1994) */
3444 #define FI_HINDO 4 /* New type for FI-Wnn */
3445
3446 /*********************************/
3447 static int
jl_dic_add_e_body(env,dic_name,hindo_name,rev,prio,rw,hrw,pwd_dic,pwd_hindo,error_handler,message_handler)3448 jl_dic_add_e_body(env,dic_name,hindo_name,rev, prio,rw, hrw, pwd_dic, pwd_hindo, error_handler, message_handler)
3449 register struct wnn_env_int *env;
3450 char *dic_name;
3451 char *hindo_name;
3452 int prio;
3453 int rw, hrw, rev;
3454 char *pwd_dic, *pwd_hindo;
3455 int (*error_handler)(), (*message_handler)();
3456 {
3457 char tmp[256];
3458 char pwd[WNN_PASSWD_LEN], hpwd[WNN_PASSWD_LEN];
3459 int fid, hfid = -1;
3460 register int ret;
3461
3462 if(file_exist(env, dic_name) == -1) {
3463 /* failed, try to access compressed dictionary,
3464 but this may cause error */
3465 char t_dic_name[1024]; char *t_dic_ext = ".gz";
3466 char t_dic_name2[1024]; char *t_dic_ext2 = ".Z";
3467 strcpy(t_dic_name, dic_name); strcat(t_dic_name, t_dic_ext);
3468 strcpy(t_dic_name2, dic_name); strcat(t_dic_name2, t_dic_ext2);
3469 if( (file_exist(env, t_dic_name) == -1) &&
3470 (file_exist(env, t_dic_name2) == -1) ) {
3471 env_wnn_errorno_copy(env);
3472 if (env_wnn_errorno_eql == WNN_JSERVER_DEAD) {
3473 jl_disconnect_body(env);
3474 return(-1);
3475 }
3476 if((int)error_handler == WNN_NO_CREATE ||
3477 (rw == WNN_DIC_RDONLY)){
3478 LockMutex(&msg_lock);
3479 sprintf(tmp, "%s \"%s\" %s",
3480 msg_get(wnn_msg_cat, 200, NULL, env->orig.lang, NULL),
3481 dic_name,
3482 msg_get(wnn_msg_cat, 201, NULL, env->orig.lang, NULL));
3483 /*
3484 "����ե����� \"%s\" ��̵���衣",
3485 */
3486 message_out(message_handler, tmp);
3487 UnlockMutex(&msg_lock);
3488 env_wnn_errorno_set = WNN_NO_EXIST;
3489 return(-1);
3490 }
3491 LockMutex(&msg_lock);
3492 sprintf(tmp, "%s \"%s\" %s%s",
3493 msg_get(wnn_msg_cat, 200, NULL, env->orig.lang, NULL),
3494 dic_name,
3495 msg_get(wnn_msg_cat, 201, NULL, env->orig.lang, NULL),
3496 msg_get(wnn_msg_cat, 202, NULL, env->orig.lang, NULL));
3497
3498 /*
3499 "����ե����� \"%s\" ��̵���衣���?(Y/N)",
3500 */
3501 UnlockMutex(&msg_lock);
3502 if((int)error_handler == WNN_CREATE ||
3503 call_error_handler(error_handler, tmp, env)){
3504 if(create_file(env, dic_name,JISHO, rw,
3505 pwd_dic,
3506 (hindo_name && *hindo_name)? "": pwd_hindo,
3507 error_handler, message_handler) == -1) {
3508 env_wnn_errorno_copy(env);
3509 return(-1);
3510 }
3511 }else{
3512 env_wnn_errorno_set = WNN_NO_EXIST;
3513 return(-1);
3514 }
3515 }
3516 }
3517
3518 if((fid = file_read(env, dic_name)) == -1) {
3519 env_wnn_errorno_copy(env);
3520 if_dead_disconnect(env);
3521 return(-1);
3522 }
3523 if(hindo_name && *hindo_name){
3524 if(file_exist(env, hindo_name) == -1) {
3525 env_wnn_errorno_copy(env);
3526 if(env_wnn_errorno_eql == WNN_JSERVER_DEAD) {
3527 jl_disconnect_body(env);
3528 return(-1);
3529 }
3530 if((int)error_handler == WNN_NO_CREATE ||
3531 (hrw == WNN_DIC_RDONLY)){
3532 LockMutex(&msg_lock);
3533 sprintf(tmp, "%s \"%s\" %s",
3534 msg_get(wnn_msg_cat, 203, NULL, env->orig.lang, NULL),
3535 hindo_name,
3536 msg_get(wnn_msg_cat, 201, NULL, env->orig.lang, NULL));
3537 /*
3538 "���٥ե����� \"%s\" ��̵���衣",
3539 */
3540 message_out(message_handler, tmp);
3541 UnlockMutex(&msg_lock);
3542 env_wnn_errorno_set = WNN_NO_EXIST;
3543 return(-1);
3544 }
3545 LockMutex(&msg_lock);
3546 sprintf(tmp, "%s \"%s\" %s%s",
3547 msg_get(wnn_msg_cat, 203, NULL, env->orig.lang, NULL),
3548 hindo_name,
3549 msg_get(wnn_msg_cat, 201, NULL, env->orig.lang, NULL),
3550 msg_get(wnn_msg_cat, 202, NULL, env->orig.lang, NULL));
3551 /*
3552 "���٥ե����� \"%s\" ��̵���衣���?(Y/N)",
3553 */
3554 UnlockMutex(&msg_lock);
3555 if((int)error_handler == WNN_CREATE ||
3556 call_error_handler(error_handler, tmp, env)){
3557 if(create_file(env, hindo_name, HINDO, fid,
3558 "", pwd_hindo, error_handler,
3559 message_handler) == -1) {
3560 env_wnn_errorno_copy(env);
3561 return(-1);
3562 }
3563 }else{
3564 env_wnn_errorno_set = WNN_NO_EXIST;
3565 return(-1);
3566 }
3567 }
3568 if((hfid = file_read(env, hindo_name)) == -1){
3569 env_wnn_errorno_copy(env);
3570 if_dead_disconnect(env);
3571 return(-1);
3572 }
3573 }
3574
3575 /* Hideyuki Kishiba (Dec. 3, 1994)
3576 ���롼����ξ��� read write���ޡ�������ξ��� read only ��
3577 dic_add ��Ԥ� */
3578 if(rw == WNN_DIC_GROUP) rw = WNN_DIC_RW;
3579 else if(rw == WNN_DIC_MERGE) rw = WNN_DIC_RDONLY;
3580
3581 if(get_pwd(pwd_dic, pwd, env) == -1)return(-1);
3582 if(get_pwd(pwd_hindo, hpwd, env) == -1)return(-1);
3583 if((ret = js_dic_add(env, fid, hfid, rev, prio, rw, hrw, pwd, hpwd)) < 0) {
3584 env_wnn_errorno_copy(env);
3585 if(env_wnn_errorno_eql == WNN_JSERVER_DEAD){
3586 jl_disconnect_body(env);
3587 return(-1);
3588 }else if(env_wnn_errorno_eql == WNN_HINDO_NO_MATCH){
3589 if((int)error_handler == WNN_NO_CREATE){
3590 return(-1);
3591 }
3592 LockMutex(&msg_lock);
3593 sprintf(tmp,
3594 msg_get(wnn_msg_cat, 204, NULL, env->orig.lang, NULL),
3595 hindo_name);
3596 /*
3597 "���٥ե����� \"%s\" �����ꤵ�줿��������٥ե�����ǤϤ���ޤ������ľ���ޤ���?(Y/N)",
3598 */
3599 UnlockMutex(&msg_lock);
3600 if(!((int)error_handler == WNN_CREATE ||
3601 call_error_handler(error_handler, tmp, env))){
3602 return(-1);
3603 }
3604 if(file_discard(env, hfid) == -1) {
3605 env_wnn_errorno_copy(env);
3606 if_dead_disconnect(env);
3607 return(-1);
3608 }
3609 if(file_remove(env->orig.js_id, hindo_name, hpwd) == -1) {
3610 env_wnn_errorno_copy(env);
3611 if_dead_disconnect(env);
3612 return(-1);
3613 }
3614 if(create_file(env,hindo_name, HINDO, fid, NULL, pwd_hindo, WNN_CREATE, message_handler) == -1) {
3615 env_wnn_errorno_copy(env);
3616 return(-1);
3617 }
3618 if((hfid = file_read(env, hindo_name)) == -1) {
3619 env_wnn_errorno_copy(env);
3620 if_dead_disconnect(env);
3621 return(-1);
3622 }
3623 if((ret = js_dic_add(env, fid, hfid, rev, prio, rw, hrw, pwd, hpwd))< 0) {
3624 env_wnn_errorno_copy(env);
3625 if_dead_disconnect(env);
3626 return(-1);
3627 }
3628 }
3629 }
3630 return(ret);
3631 }
3632
3633 int
jl_dic_add_e(env,dic_name,hindo_name,rev,prio,rw,hrw,pwd_dic,pwd_hindo,error_handler,message_handler)3634 jl_dic_add_e(env,dic_name,hindo_name,rev, prio,rw, hrw, pwd_dic, pwd_hindo, error_handler, message_handler)
3635 register struct wnn_env *env;
3636 char *dic_name;
3637 char *hindo_name;
3638 int prio;
3639 int rw, hrw, rev;
3640 char *pwd_dic, *pwd_hindo;
3641 int (*error_handler)(), (*message_handler)();
3642 {
3643 int x;
3644
3645 if(!env) return(-1);
3646 LockMutex(&ENV_LOCK(env));
3647 env_wnn_errorno_set = 0;
3648 x = jl_dic_add_e_body((WNN_ENV_INT *)env, dic_name, hindo_name, rev, prio,
3649 rw, hrw, pwd_dic, pwd_hindo, error_handler,
3650 message_handler);
3651 UnlockMutex(&ENV_LOCK(env));
3652 return x;
3653 }
3654
3655 int
jl_dic_add(buf,dic_name,hindo_name,rev,prio,rw,hrw,pwd_dic,pwd_hindo,error_handler,message_handler)3656 jl_dic_add(buf, dic_name, hindo_name, rev, prio, rw, hrw, pwd_dic, pwd_hindo, error_handler, message_handler)
3657 register struct wnn_buf *buf;
3658 char *dic_name;
3659 char *hindo_name;
3660 int prio;
3661 int rw, hrw, rev;
3662 char *pwd_dic, *pwd_hindo;
3663 int (*error_handler)(), (*message_handler)();
3664 {
3665 int x;
3666
3667 if(!buf || !(buf->env)) return(-1);
3668 LockMutex(&BUF_LOCK(buf));
3669 LockMutex(&(envmt->env_lock));
3670 buf_wnn_errorno_set = 0;
3671 x = jl_dic_add_e_body((WNN_ENV_INT *)buf->env, dic_name, hindo_name, rev,
3672 prio, rw, hrw, pwd_dic, pwd_hindo, error_handler,
3673 message_handler);
3674 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
3675 UnlockMutex(&(envmt->env_lock));
3676 UnlockMutex(&BUF_LOCK(buf));
3677 return x;
3678 }
3679
3680 /*:::DOC_START
3681 *
3682 * Function Name: jl_fi_dic_add_e_body
3683 * Description : jl_fi_dic_add[_e] �Υ��֥롼����ؿ�
3684 * Parameter :
3685 * env : (In) �Ķ��ؤΥݥ���
3686 * dic_name : (In) �ƣɴط�����ե�����̾
3687 * hindo_name : (In) �ƣɴط����٥ե�����̾
3688 * suflag : (In) �����ƥ༭����桼������
3689 * rw : (In) ����������ǽ����Բ�ǽ
3690 * hrw : (In) ���ٹ�������ǽ����Բ�ǽ
3691 * pwd_dic : (In) �ƣɴط�����ե�����Υѥ����
3692 * pwd_hindo : (In) �ƣɴط����٥ե�����Υѥ����
3693 * error_handler : (In) ���顼�ϥ�ɥ��
3694 * message_handler : (In) ��å������ϥ�ɥ顼
3695 *
3696 * Return value : -1==ERROR, else ��Ͽ�����ֹ�
3697 *
3698 * Author : Hideyuki Kishiba
3699 *
3700 * Revision history:
3701 *
3702 *:::DOC_END
3703 */
3704 static int
jl_fi_dic_add_e_body(env,dic_name,hindo_name,suflag,rw,hrw,pwd_dic,pwd_hindo,error_handler,message_handler)3705 jl_fi_dic_add_e_body(env, dic_name, hindo_name, suflag, rw, hrw, pwd_dic, pwd_hindo, error_handler, message_handler)
3706 register struct wnn_env_int *env;
3707 char *dic_name;
3708 char *hindo_name;
3709 int suflag;
3710 int rw, hrw;
3711 char *pwd_dic, *pwd_hindo;
3712 int (*error_handler)(), (*message_handler)();
3713 {
3714 char tmp[256];
3715 char pwd[WNN_PASSWD_LEN], hpwd[WNN_PASSWD_LEN];
3716 int fid, hfid = -1;
3717 register int ret;
3718
3719 if(file_exist(env, dic_name) == -1) {
3720 /* �ƣɴط�����ե����뤬¸�ߤ��ʤ� */
3721 env_wnn_errorno_copy(env);
3722 if (env_wnn_errorno_eql == WNN_JSERVER_DEAD) {
3723 /* jserver �����Ǥ��� */
3724 jl_disconnect_body(env);
3725 return(-1);
3726 }
3727 if((int)error_handler == WNN_NO_CREATE) {
3728 LockMutex(&msg_lock);
3729 sprintf(tmp, "%s \"%s\" %s",
3730 msg_get(wnn_msg_cat, 200, NULL, env->orig.lang, NULL),
3731 dic_name,
3732 msg_get(wnn_msg_cat, 201, NULL, env->orig.lang, NULL));
3733 /*
3734 "����ե����� \"%s\" ��̵���衣",
3735 */
3736 message_out(message_handler, tmp);
3737 UnlockMutex(&msg_lock);
3738 env_wnn_errorno_set = WNN_NO_EXIST;
3739 return(-1);
3740 }
3741 LockMutex(&msg_lock);
3742 sprintf(tmp, "%s \"%s\" %s%s",
3743 msg_get(wnn_msg_cat, 200, NULL, env->orig.lang, NULL),
3744 dic_name,
3745 msg_get(wnn_msg_cat, 201, NULL, env->orig.lang, NULL),
3746 msg_get(wnn_msg_cat, 202, NULL, env->orig.lang, NULL));
3747 /*
3748 "����ե����� \"%s\" ��̵���衣���?(Y/N)",
3749 */
3750 UnlockMutex(&msg_lock);
3751 if((int)error_handler == WNN_CREATE ||
3752 call_error_handler(error_handler, tmp, env)){
3753 /* �ƣɴط�����κ��� */
3754 if(create_file(env, dic_name, FI_JISHO, -1, /* -1 is dummy */
3755 pwd_dic,
3756 (hindo_name && *hindo_name)? "": pwd_hindo,
3757 error_handler, message_handler) == -1) {
3758 env_wnn_errorno_copy(env);
3759 return(-1);
3760 }
3761 }else{
3762 env_wnn_errorno_set = WNN_NO_EXIST;
3763 return(-1);
3764 }
3765 }
3766 /* �ƣɴط�������ɤ߹��� */
3767 if((fid = file_read(env, dic_name)) == -1) {
3768 env_wnn_errorno_copy(env);
3769 if_dead_disconnect(env);
3770 return(-1);
3771 }
3772 if(hindo_name && *hindo_name){
3773 if(file_exist(env, hindo_name) == -1) {
3774 /* �ƣɴط����٥ե����뤬¸�ߤ��ʤ� */
3775 env_wnn_errorno_copy(env);
3776 if(env_wnn_errorno_eql == WNN_JSERVER_DEAD) {
3777 /* jserver �����Ǥ��� */
3778 jl_disconnect_body(env);
3779 return(-1);
3780 }
3781 if((int)error_handler == WNN_NO_CREATE ||
3782 (hrw == WNN_DIC_RDONLY)){
3783 LockMutex(&msg_lock);
3784 sprintf(tmp, "%s \"%s\" %s",
3785 msg_get(wnn_msg_cat, 203, NULL, env->orig.lang, NULL),
3786 hindo_name,
3787 msg_get(wnn_msg_cat, 201, NULL, env->orig.lang, NULL));
3788 /*
3789 "���٥ե����� \"%s\" ��̵���衣",
3790 */
3791 message_out(message_handler, tmp);
3792 UnlockMutex(&msg_lock);
3793 env_wnn_errorno_set = WNN_NO_EXIST;
3794 return(-1);
3795 }
3796 LockMutex(&msg_lock);
3797 sprintf(tmp, "%s \"%s\" %s%s",
3798 msg_get(wnn_msg_cat, 203, NULL, env->orig.lang, NULL),
3799 hindo_name,
3800 msg_get(wnn_msg_cat, 201, NULL, env->orig.lang, NULL),
3801 msg_get(wnn_msg_cat, 202, NULL, env->orig.lang, NULL));
3802 /*
3803 "���٥ե����� \"%s\" ��̵���衣���?(Y/N)",
3804 */
3805 UnlockMutex(&msg_lock);
3806 if((int)error_handler == WNN_CREATE ||
3807 call_error_handler(error_handler, tmp, env)){
3808 /* �ƣɴط����٥ե�����κ��� */
3809 if(create_file(env, hindo_name, FI_HINDO, fid,
3810 "", pwd_hindo, error_handler,
3811 message_handler) == -1) {
3812 env_wnn_errorno_copy(env);
3813 return(-1);
3814 }
3815 }else{
3816 env_wnn_errorno_set = WNN_NO_EXIST;
3817 return(-1);
3818 }
3819 }
3820 /* �ƣɴط����٥ե�������ɤ߹��� */
3821 if((hfid = file_read(env, hindo_name)) == -1){
3822 env_wnn_errorno_copy(env);
3823 if_dead_disconnect(env);
3824 return(-1);
3825 }
3826 }
3827
3828 /* �ѥ���ɤμ��� */
3829 if(get_pwd(pwd_dic, pwd, env) == -1)return(-1);
3830 if(get_pwd(pwd_hindo, hpwd, env) == -1)return(-1);
3831
3832 /* �ƣɴط���������٤������������å� */
3833 if((ret = js_fi_dic_add(env, fid, hfid, suflag, rw, hrw, pwd, hpwd)) < 0) {
3834 env_wnn_errorno_copy(env);
3835 if(env_wnn_errorno_eql == WNN_JSERVER_DEAD){
3836 /* jserver �����Ǥ��� */
3837 jl_disconnect_body(env);
3838 return(-1);
3839 }else if(env_wnn_errorno_eql == WNN_HINDO_NO_MATCH){
3840 /* ��������٤���������̵�� */
3841 if((int)error_handler == WNN_NO_CREATE){
3842 return(-1);
3843 }
3844 LockMutex(&msg_lock);
3845 sprintf(tmp,
3846 msg_get(wnn_msg_cat, 204, NULL, env->orig.lang, NULL),
3847 hindo_name);
3848 /*
3849 "���٥ե����� \"%s\" �����ꤵ�줿��������٥ե�����ǤϤ���ޤ������ľ���ޤ���?(Y/N)",
3850 */
3851 UnlockMutex(&msg_lock);
3852 if(!((int)error_handler == WNN_CREATE ||
3853 call_error_handler(error_handler, tmp, env))){
3854 return(-1);
3855 }
3856 /* ���٥ե�����Υ������ */
3857 if(file_discard(env, hfid) == -1) {
3858 env_wnn_errorno_copy(env);
3859 if_dead_disconnect(env);
3860 return(-1);
3861 }
3862 /* ���٥ե�����Υǥ���������κ�� */
3863 if(file_remove(env->orig.js_id, hindo_name, hpwd) == -1) {
3864 env_wnn_errorno_copy(env);
3865 if_dead_disconnect(env);
3866 return(-1);
3867 }
3868 /* �ƣɴط����٥ե�����κ��� */
3869 if(create_file(env,hindo_name, FI_HINDO, fid, NULL, pwd_hindo, WNN_CREATE, message_handler) == -1) {
3870 env_wnn_errorno_copy(env);
3871 return(-1);
3872 }
3873 /* �ƣɴط����٥ե�������ɤ߹��� */
3874 if((hfid = file_read(env, hindo_name)) == -1) {
3875 env_wnn_errorno_copy(env);
3876 if_dead_disconnect(env);
3877 return(-1);
3878 }
3879 /* �ƣɴط���������٤������������å� */
3880 if((ret = js_fi_dic_add(env, fid, hfid, suflag, rw, hrw, pwd, hpwd))< 0) {
3881 env_wnn_errorno_copy(env);
3882 if_dead_disconnect(env);
3883 return(-1);
3884 }
3885 }
3886 }
3887 return(ret);
3888 } /* End of jl_fi_dic_add_e_body */
3889
3890 /*:::DOC_START
3891 *
3892 * Function Name: jl_fi_dic_add_e
3893 * Description : �Ķ��ˣƣɼ�����ɲä���
3894 * Parameter :
3895 * env : (In) �Ķ��ؤΥݥ���
3896 * dic_name : (In) �ƣɴط�����ե�����̾
3897 * hindo_name : (In) �ƣɴط����٥ե�����̾
3898 * suflag : (In) �����ƥ༭����桼������
3899 * rw : (In) ����������ǽ����Բ�ǽ
3900 * hrw : (In) ���ٹ�������ǽ����Բ�ǽ
3901 * pwd_dic : (In) �ƣɴط�����ե�����Υѥ����
3902 * pwd_hindo : (In) �ƣɴط����٥ե�����Υѥ����
3903 * error_handler : (In) ���顼�ϥ�ɥ��
3904 * message_handler : (In) ��å������ϥ�ɥ顼
3905 *
3906 * Return value : -1==ERROR, else ��Ͽ�����ֹ�
3907 *
3908 * Author : Hideyuki Kishiba
3909 *
3910 * Revision history:
3911 *
3912 *:::DOC_END
3913 */
3914 int
jl_fi_dic_add_e(env,dic_name,hindo_name,suflag,rw,hrw,pwd_dic,pwd_hindo,error_handler,message_handler)3915 jl_fi_dic_add_e(env, dic_name, hindo_name, suflag ,rw, hrw, pwd_dic, pwd_hindo, error_handler, message_handler)
3916 register struct wnn_env *env;
3917 char *dic_name;
3918 char *hindo_name;
3919 int suflag;
3920 int rw, hrw;
3921 char *pwd_dic, *pwd_hindo;
3922 int (*error_handler)(), (*message_handler)();
3923 {
3924 int x;
3925
3926 if(!env) return(-1);
3927 LockMutex(&ENV_LOCK(env));
3928 env_wnn_errorno_set = 0;
3929 /* ���֥롼����ؿ��Υ����� */
3930 x = jl_fi_dic_add_e_body((WNN_ENV_INT *)env, dic_name, hindo_name, suflag,
3931 rw, hrw, pwd_dic, pwd_hindo, error_handler,
3932 message_handler);
3933 UnlockMutex(&ENV_LOCK(env));
3934 return x;
3935 } /* End of jl_fi_dic_add_e */
3936
3937 /*:::DOC_START
3938 *
3939 * Function Name: jl_fi_dic_add
3940 * Description : �Хåե��ˣƣɼ�����ɲä���
3941 * Parameter :
3942 * buf : (In) �Хåե��ؤΥݥ���
3943 * dic_name : (In) �ƣɴط�����ե�����̾
3944 * hindo_name : (In) �ƣɴط����٥ե�����̾
3945 * suflag : (In) �����ƥ༭����桼������
3946 * rw : (In) ����������ǽ����Բ�ǽ
3947 * hrw : (In) ���ٹ�������ǽ����Բ�ǽ
3948 * pwd_dic : (In) �ƣɴط�����ե�����Υѥ����
3949 * pwd_hindo : (In) �ƣɴط����٥ե�����Υѥ����
3950 * error_handler : (In) ���顼�ϥ�ɥ��
3951 * message_handler : (In) ��å������ϥ�ɥ顼
3952 *
3953 * Return value : -1==ERROR, else ��Ͽ�����ֹ�
3954 *
3955 * Author : Hideyuki Kishiba
3956 *
3957 * Revision history:
3958 *
3959 *:::DOC_END
3960 */
3961 int
jl_fi_dic_add(buf,dic_name,hindo_name,suflag,rw,hrw,pwd_dic,pwd_hindo,error_handler,message_handler)3962 jl_fi_dic_add(buf, dic_name, hindo_name, suflag, rw, hrw, pwd_dic, pwd_hindo, error_handler, message_handler)
3963 register struct wnn_buf *buf;
3964 char *dic_name;
3965 char *hindo_name;
3966 int suflag;
3967 int rw, hrw;
3968 char *pwd_dic, *pwd_hindo;
3969 int (*error_handler)(), (*message_handler)();
3970 {
3971 int x;
3972
3973 if(!buf || !(buf->env)) return(-1);
3974 LockMutex(&BUF_LOCK(buf));
3975 LockMutex(&(envmt->env_lock));
3976 buf_wnn_errorno_set = 0;
3977 /* ���֥롼����ؿ��Υ����� */
3978 x = jl_fi_dic_add_e_body((WNN_ENV_INT *)buf->env, dic_name, hindo_name,
3979 suflag, rw, hrw, pwd_dic, pwd_hindo, error_handler,
3980 message_handler);
3981 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
3982 UnlockMutex(&(envmt->env_lock));
3983 UnlockMutex(&BUF_LOCK(buf));
3984 return x;
3985 } /* End of jl_fi_dic_add */
3986
3987 static int
jl_dic_delete_e_body(env,dic_no)3988 jl_dic_delete_e_body(env, dic_no)
3989 register struct wnn_env_int *env;
3990 register int dic_no;
3991 {
3992 WNN_DIC_INFO dic;
3993
3994 if(js_dic_info(env,dic_no,&dic) < 0){
3995 env_wnn_errorno_copy(env);
3996 if_dead_disconnect(env);
3997 return(-1);
3998 }
3999 if(js_dic_delete(env, dic_no) < 0) {
4000 env_wnn_errorno_copy(env);
4001 if_dead_disconnect(env);
4002 return(-1);
4003 }
4004 /* dic Body */
4005 if (file_discard(env,dic.body) < 0) {
4006 env_wnn_errorno_copy(env);
4007 if_dead_disconnect(env);
4008 return(-1);
4009 }
4010 /* dic hindo */
4011 if(dic.hindo != -1){
4012 if (file_discard(env,dic.hindo) < 0){
4013 env_wnn_errorno_copy(env);
4014 if_dead_disconnect(env);
4015 return(-1);
4016 }
4017 }
4018 return(0);
4019 }
4020
4021 int
jl_dic_delete_e(env,dic_no)4022 jl_dic_delete_e(env, dic_no)
4023 register struct wnn_env *env;
4024 register int dic_no;
4025 {
4026 int x;
4027
4028 if(!env) return(-1);
4029 LockMutex(&ENV_LOCK(env));
4030 env_wnn_errorno_set = 0;
4031 x = jl_dic_delete_e_body((WNN_ENV_INT *)env, dic_no);
4032 UnlockMutex(&ENV_LOCK(env));
4033 return x;
4034 }
4035
4036 int
jl_dic_delete(buf,dic_no)4037 jl_dic_delete(buf, dic_no)
4038 register struct wnn_buf *buf;
4039 register int dic_no;
4040 {
4041 int x;
4042
4043 if(!buf || !(buf->env)) return(-1);
4044 LockMutex(&BUF_LOCK(buf));
4045 LockMutex(&(envmt->env_lock));
4046 buf_wnn_errorno_set = 0;
4047 x = jl_dic_delete_e_body((WNN_ENV_INT *)buf->env, dic_no);
4048 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
4049 UnlockMutex(&(envmt->env_lock));
4050 UnlockMutex(&BUF_LOCK(buf));
4051 return x;
4052 }
4053
4054 static int
get_pwd(pwd_dic,pwd,env)4055 get_pwd(pwd_dic, pwd, env)
4056 register char *pwd_dic, *pwd;
4057 ARGS *env;
4058 {
4059 FILE *fp;
4060
4061 if(pwd_dic && *pwd_dic){
4062 if((fp = fopen(pwd_dic, "r")) == NULL){
4063 env_wnn_errorno_set = WNN_CANT_OPEN_PASSWD_FILE;
4064 return(-1);
4065 }
4066 fgets(pwd, WNN_PASSWD_LEN, fp);
4067 fclose(fp);
4068 }else {
4069 pwd[0] = 0;
4070 }
4071 return(0);
4072 }
4073
4074 static int
create_pwd_file(env,pwd_file,error_handler,message_handler)4075 create_pwd_file(env, pwd_file, error_handler, message_handler)
4076 register struct wnn_env_int *env;
4077 char *pwd_file;
4078 int (*error_handler)(), (*message_handler)();
4079 {
4080 FILE *fp;
4081 char gomi[256];
4082
4083 if(pwd_file == NULL || *pwd_file == 0) return(0);
4084 if(access(pwd_file, F_OK) != -1) return(0);
4085 LockMutex(&msg_lock);
4086 sprintf(gomi, "%s \"%s\" %s%s",
4087 msg_get(wnn_msg_cat, 205, NULL, env->orig.lang, NULL),
4088 pwd_file,
4089 msg_get(wnn_msg_cat, 201, NULL, env->orig.lang, NULL),
4090 msg_get(wnn_msg_cat, 202, NULL, env->orig.lang, NULL));
4091 /*
4092 "password_file \"%s\" ��̵���衣���?(Y/N)",
4093 */
4094 UnlockMutex(&msg_lock);
4095 /* error_handler != WNN_CREATE �Υ����å���ȴ���Ƥ����Τ��ɲ� */
4096 if((int)error_handler != WNN_CREATE && call_error_handler(error_handler,gomi, env) == 0){
4097 env_wnn_errorno_set = WNN_NO_EXIST;
4098 return(-1);
4099 }
4100 if((fp = fopen(pwd_file, "w")) == NULL){
4101 env_wnn_errorno_set = WNN_CANT_OPEN_PASSWD_FILE;
4102 message_out(message_handler, wnn_perror_lang(env->orig.lang, env));
4103 return(-1);
4104 }
4105 #ifdef SYSVR2
4106 srand(time(0)+getuid());
4107 fprintf(fp,"%d\n",rand());
4108 #else
4109 srandom(time(0)+getuid());
4110 fprintf(fp,"%d\n",random());
4111 #endif
4112 fclose(fp);
4113 #define MODE_PWD (0000000 | 0000400)
4114 chmod(pwd_file,MODE_PWD);
4115 return(0);
4116 }
4117
4118
4119 /** jl_fuzokugo_set **/
4120 static int
jl_fuzokugo_set_e_body(env,fname)4121 jl_fuzokugo_set_e_body(env,fname)
4122 struct wnn_env_int *env;
4123 char *fname;
4124 {
4125 register int fid, orgfid;
4126 int ret;
4127
4128 orgfid = js_fuzokugo_get(env);
4129 /* If orgfid == -1, it must be
4130 because no fuzokugo_file is set to the env
4131 */
4132 if((fid=file_read(env,fname)) == -1) {
4133 env_wnn_errorno_copy(env);
4134 if_dead_disconnect(env);
4135 return(-1);
4136 }
4137 if ((ret = js_fuzokugo_set(env,fid)) < 0) {
4138 env_wnn_errorno_copy(env);
4139 if_dead_disconnect(env);
4140 return(ret);
4141 }
4142 if(fid != orgfid && orgfid != -1){
4143 js_file_discard(env, orgfid);
4144 }
4145 return(ret);
4146 }
4147
4148 int
jl_fuzokugo_set_e(env,fname)4149 jl_fuzokugo_set_e(env,fname)
4150 struct wnn_env *env;
4151 char *fname;
4152 {
4153 int x;
4154 if(!env) return(-1);
4155 LockMutex(&ENV_LOCK(env));
4156 env_wnn_errorno_set = 0;
4157 x = jl_fuzokugo_set_e_body((WNN_ENV_INT *)env,fname);
4158 UnlockMutex(&ENV_LOCK(env));
4159 return x;
4160 }
4161
4162 int
jl_fuzokugo_set(buf,fname)4163 jl_fuzokugo_set(buf, fname)
4164 register struct wnn_buf *buf;
4165 char *fname;
4166 {
4167 int x;
4168 if(!buf || !(buf->env)) return(-1);
4169 LockMutex(&BUF_LOCK(buf));
4170 LockMutex(&(envmt->env_lock));
4171 buf_wnn_errorno_set = 0;
4172 x = jl_fuzokugo_set_e_body((WNN_ENV_INT *)buf->env, fname);
4173 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
4174 UnlockMutex(&(envmt->env_lock));
4175 UnlockMutex(&BUF_LOCK(buf));
4176 return x;
4177 }
4178
4179 /** jl_fuzokugo_get **/
4180 static int
jl_fuzokugo_get_e_body(env,fname)4181 jl_fuzokugo_get_e_body(env, fname)
4182 register struct wnn_env_int *env;
4183 char *fname;
4184 {
4185 WNN_FILE_INFO_STRUCT file;
4186 int fid;
4187 char *c;
4188
4189 fname[0] = 0;
4190 if((fid = js_fuzokugo_get(env)) < 0) {
4191 env_wnn_errorno_copy(env);
4192 if_dead_disconnect(env);
4193 return(-1);
4194 }
4195 if (js_file_info(env,fid,&file) < 0) {
4196 env_wnn_errorno_copy(env);
4197 if_dead_disconnect(env);
4198 return(-1);
4199 }
4200 LockMutex(&envs_lock);
4201 c = find_file_name_from_id(env, fid);
4202 if(c == NULL){
4203 c = file.name;
4204 }
4205 strcpy(fname, c);
4206 UnlockMutex(&envs_lock);
4207 return(fid);
4208 }
4209
4210 int
jl_fuzokugo_get_e(env,fname)4211 jl_fuzokugo_get_e(env, fname)
4212 register struct wnn_env *env;
4213 char *fname;
4214 {
4215 int x;
4216
4217 if(!env) return(-1);
4218 LockMutex(&ENV_LOCK(env));
4219 env_wnn_errorno_set = 0;
4220 x = jl_fuzokugo_get_e_body((WNN_ENV_INT *)env, fname);
4221 UnlockMutex(&ENV_LOCK(env));
4222 return x;
4223 }
4224
4225 int
jl_fuzokugo_get(buf,fname)4226 jl_fuzokugo_get(buf, fname)
4227 register struct wnn_buf *buf;
4228 char *fname;
4229 {
4230 int x;
4231
4232 if(!buf || !(buf->env)) return(-1);
4233 LockMutex(&BUF_LOCK(buf));
4234 LockMutex(&(envmt->env_lock));
4235 buf_wnn_errorno_set = 0;
4236 x = jl_fuzokugo_get_e_body((WNN_ENV_INT *)buf->env, fname);
4237 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
4238 UnlockMutex(&(envmt->env_lock));
4239 UnlockMutex(&BUF_LOCK(buf));
4240 return x;
4241 }
4242
4243 /** jl_dic_save **/
4244 static int
jl_dic_save_e_body(env,dic_no)4245 jl_dic_save_e_body(env,dic_no)
4246 register struct wnn_env_int *env;
4247 int dic_no;
4248 {
4249 WNN_DIC_INFO dic;
4250 WNN_FILE_INFO_STRUCT file;
4251 char *c;
4252
4253 if(js_dic_info(env,dic_no,&dic) < 0) {
4254 env_wnn_errorno_copy(env);
4255 if_dead_disconnect(env);
4256 return(-1);
4257 }
4258 /* dic Body */
4259 LockMutex(&envs_lock);
4260 c = find_file_name_from_id(env, dic.body);
4261 if(c == NULL){
4262 if(dic.localf){
4263 c = dic.fname;
4264 }else{
4265 UnlockMutex(&envs_lock);
4266 env_wnn_errorno_set=WNN_FILE_NOT_READ_FROM_CLIENT;
4267 return(-1);
4268 }
4269 }
4270 if(c[0] != C_LOCAL){
4271 if (js_file_write(env,dic.body,c) < 0) {
4272 env_wnn_errorno_copy(env);
4273 if (env_wnn_errorno_eql == WNN_JSERVER_DEAD) {
4274 UnlockMutex(&envs_lock);
4275 jl_disconnect_if_server_dead_body(env);
4276 return(-1);
4277 }
4278 }
4279 }else{
4280 if (js_file_receive(env,dic.body,c + 1) < 0) {
4281 env_wnn_errorno_copy(env);
4282 if (env_wnn_errorno_eql == WNN_JSERVER_DEAD) {
4283 UnlockMutex(&envs_lock);
4284 jl_disconnect_if_server_dead_body(env);
4285 return(-1);
4286 }
4287 }
4288 }
4289 /* dic hindo */
4290 if(dic.hindo != -1){
4291 if (js_file_info(env,dic.hindo,&file) < 0) {
4292 UnlockMutex(&envs_lock);
4293 env_wnn_errorno_copy(env);
4294 if_dead_disconnect(env);
4295 return(-1);
4296 }
4297 c = find_file_name_from_id(env, file.fid);
4298 if(c == NULL){
4299 if(dic.hlocalf){
4300 c = dic.hfname;
4301 }else{
4302 UnlockMutex(&envs_lock);
4303 env_wnn_errorno_set=WNN_FILE_NOT_READ_FROM_CLIENT;
4304 return(-1);
4305 }
4306 }
4307 if(c[0] != C_LOCAL){
4308 if (js_file_write(env,dic.hindo,c) < 0) {
4309 UnlockMutex(&envs_lock);
4310 env_wnn_errorno_copy(env);
4311 if_dead_disconnect(env);
4312 return(-1);
4313 }
4314 }else{
4315 if (js_file_receive(env,dic.hindo,c + 1) < 0) {
4316 UnlockMutex(&envs_lock);
4317 env_wnn_errorno_copy(env);
4318 if_dead_disconnect(env);
4319 return(-1);
4320 }
4321 }
4322 }
4323 UnlockMutex(&envs_lock);
4324 return(0);
4325 }
4326
4327 int
jl_dic_save_e(env,dic_no)4328 jl_dic_save_e(env,dic_no)
4329 register struct wnn_env *env;
4330 int dic_no;
4331 {
4332 int x;
4333
4334 if(!env) return(-1);
4335 LockMutex(&ENV_LOCK(env));
4336 env_wnn_errorno_set = 0;
4337 x = jl_dic_save_e_body((WNN_ENV_INT *)env,dic_no);
4338 UnlockMutex(&ENV_LOCK(env));
4339 return x;
4340 }
4341
4342 int
jl_dic_save(buf,dic_no)4343 jl_dic_save(buf, dic_no)
4344 register struct wnn_buf *buf;
4345 int dic_no;
4346 {
4347 int x;
4348
4349 if(!buf || !(buf->env)) return(-1);
4350 LockMutex(&BUF_LOCK(buf));
4351 LockMutex(&(envmt->env_lock));
4352 buf_wnn_errorno_set = 0;
4353 x = jl_dic_save_e_body((WNN_ENV_INT *)buf->env, dic_no);
4354 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
4355 UnlockMutex(&(envmt->env_lock));
4356 UnlockMutex(&BUF_LOCK(buf));
4357 return x;
4358 }
4359
4360 static int
jl_dic_save_all_e_body(env)4361 jl_dic_save_all_e_body(env)
4362 struct wnn_env_int *env;
4363 {
4364 register WNN_DIC_INFO *dic;
4365 register int k;
4366 char *c;
4367 register int cnt;
4368 register unsigned long dmask = 0;
4369
4370 /* �ƥ�ݥ�꼭��ʳ��μ����������� */
4371 dmask |= WNN_DIC_ALL_MASK & ~WNN_DIC_TEMPORARY_MASK;
4372
4373 if((cnt = js_fi_dic_list(env, dmask, &dicrb)) == -1) {
4374 env_wnn_errorno_copy(env);
4375 if_dead_disconnect(env);
4376 return(-1);
4377 }
4378 dic = (WNN_DIC_INFO *)dicrb.buf;
4379 LockMutex(&envs_lock);
4380 for(k = 0 ; k < cnt ; k++, dic++){
4381 if((c = find_file_name_from_id(env, dic->body)) == NULL){
4382 if(dic->localf){
4383 c = dic->fname;
4384 }else{
4385 env_wnn_errorno_set=WNN_FILE_NOT_READ_FROM_CLIENT;
4386 }
4387 }
4388 if(c){
4389 if(c[0] != C_LOCAL){
4390 if (js_file_write(env,dic->body,c) < 0) {
4391 env_wnn_errorno_copy(env);
4392 if (env_wnn_errorno_eql == WNN_JSERVER_DEAD) {
4393 UnlockMutex(&envs_lock);
4394 jl_disconnect_if_server_dead_body(env);
4395 return(-1);
4396 }
4397 }
4398 }else{
4399 if (js_file_receive(env,dic->body,c + 1) < 0) {
4400 env_wnn_errorno_copy(env);
4401 if (env_wnn_errorno_eql == WNN_JSERVER_DEAD) {
4402 UnlockMutex(&envs_lock);
4403 jl_disconnect_if_server_dead_body(env);
4404 return(-1);
4405 }
4406 }
4407 }
4408 }
4409 /* dic hindo */
4410 if(dic->hindo != -1){
4411 c = find_file_name_from_id(env, dic->hindo);
4412 if(c == NULL){
4413 if(dic->hlocalf){
4414 c = dic->hfname;
4415 }else{
4416 env_wnn_errorno_set=WNN_FILE_NOT_READ_FROM_CLIENT;
4417 }
4418 }
4419 if(c){
4420 if(c[0] != C_LOCAL){
4421 if (js_file_write(env,dic->hindo,c) < 0) {
4422 env_wnn_errorno_copy(env);
4423 if (env_wnn_errorno_eql == WNN_JSERVER_DEAD) {
4424 UnlockMutex(&envs_lock);
4425 if_dead_disconnect(env);
4426 return(-1);
4427 }
4428 }
4429 }else{
4430 if (js_file_receive(env,dic->hindo,c + 1) < 0) {
4431 env_wnn_errorno_copy(env);
4432 if (env_wnn_errorno_eql == WNN_JSERVER_DEAD) {
4433 UnlockMutex(&envs_lock);
4434 if_dead_disconnect(env);
4435 return(-1);
4436 }
4437 }
4438 }
4439 }
4440 }
4441 }
4442 UnlockMutex(&envs_lock);
4443 env_wnn_errorno_copy(env);
4444 if(env_wnn_errorno_eql)
4445 return(-1);
4446 else
4447 return(0);
4448 }
4449
4450 int
jl_dic_save_all_e(env)4451 jl_dic_save_all_e(env)
4452 struct wnn_env *env;
4453 {
4454 int x;
4455
4456 if(!env) return(-1);
4457 LockMutex(&ENV_LOCK(env));
4458 env_wnn_errorno_set = 0;
4459 x = jl_dic_save_all_e_body((WNN_ENV_INT *)env);
4460 UnlockMutex(&ENV_LOCK(env));
4461 return x;
4462 }
4463
4464 int
jl_dic_save_all(buf)4465 jl_dic_save_all(buf)
4466 register struct wnn_buf *buf;
4467 {
4468 int x;
4469
4470 if(!buf || !(buf->env)) return(-1);
4471 LockMutex(&BUF_LOCK(buf));
4472 LockMutex(&(envmt->env_lock));
4473 buf_wnn_errorno_set = 0;
4474 x = jl_dic_save_all_e_body((WNN_ENV_INT *)buf->env);
4475 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
4476 UnlockMutex(&(envmt->env_lock));
4477 UnlockMutex(&BUF_LOCK(buf));
4478 return x;
4479 }
4480
4481 /*
4482 *
4483 * bun manipulate routines
4484 *
4485 */
4486
4487 static void
free_sho(buf,wbp)4488 free_sho(buf, wbp)
4489 register struct wnn_buf_mt *buf;
4490 WNN_BUN **wbp;
4491 {
4492 register WNN_BUN *wb, *wb1;
4493 wb = *wbp;
4494
4495 if(--wb->ref_cnt <= 0){
4496 for(wb1 = wb; wb;){
4497 if((wb1 == wb) && (wb->hinsi_list != NULL)) {
4498 free((char *)(wb->hinsi_list));
4499 wb->hinsi_list = NULL;
4500 }
4501 wb->free_next = buf->orig.free_heap;
4502 buf->orig.free_heap = wb;
4503 wb = wb->next;
4504 }
4505 }
4506 *wbp = NULL;
4507 }
4508
4509 static void
free_zenkouho(buf)4510 free_zenkouho(buf)
4511 register struct wnn_buf_mt *buf;
4512 {
4513 register int k;
4514
4515 for(k = 0 ; k < buf->orig.zenkouho_suu; k++){
4516 free_sho(buf, &buf->orig.zenkouho[k]);
4517 }
4518 buf->orig.zenkouho_suu = 0;
4519 buf->orig.zenkouho_dai_suu = 0;
4520 buf->orig.c_zenkouho = -1;
4521 buf->orig.zenkouho_bun = -1;
4522 buf->orig.zenkouho_end_bun = -1;
4523 }
4524
4525 static void
free_bun(buf,bun_no,bun_no2)4526 free_bun(buf, bun_no, bun_no2)
4527 struct wnn_buf_mt *buf;
4528 register int bun_no, bun_no2;
4529 {
4530 register int k;
4531
4532 for(k = bun_no; k < bun_no2; k++){
4533 free_sho(buf, &buf->orig.bun[k]);
4534 }
4535 }
4536
4537 static void
free_down(buf,bun_no,bun_no2)4538 free_down(buf, bun_no, bun_no2)
4539 struct wnn_buf_mt *buf;
4540 int bun_no, bun_no2;
4541 {
4542 register WNN_BUN **wbp, **wbp1;
4543 int k;
4544
4545 for(k = bun_no; k < bun_no2; k++){
4546 for(wbp = &buf->orig.down_bnst[k]; *wbp; wbp = wbp1){
4547 wbp1 = &(*wbp)->down;
4548 free_sho(buf, wbp);
4549 }
4550 }
4551 }
4552
4553 static
4554 WNN_BUN *
get_new_bun(buf)4555 get_new_bun(buf)
4556 register struct wnn_buf_mt *buf;
4557 {
4558 register WNN_BUN *wb;
4559
4560
4561 if(buf->orig.free_heap == NULL){
4562 if(alloc_heap(buf, INCREMENT) == -1)return(NULL);
4563 }
4564 wb = buf->orig.free_heap;
4565 buf->orig.free_heap = wb->free_next;
4566 wb->free_next = NULL;
4567 wb->daihyoka = -1;
4568 return(wb);
4569 }
4570
4571 static
4572 WNN_BUN *
get_sho(buf,sb,zenp,daip,fuku,nhinsi,hlist)4573 get_sho(buf, sb, zenp, daip, fuku, nhinsi, hlist)
4574 struct wnn_buf_mt *buf;
4575 struct wnn_sho_bunsetsu *sb;
4576 int zenp, daip, fuku, nhinsi, *hlist;
4577 {
4578 register w_char *c, *end, *s;
4579 register WNN_BUN *wb;
4580 WNN_BUN *wb1;
4581 int where = 1;
4582 int len;
4583
4584 if((wb = get_new_bun(buf)) == NULL) return(NULL);
4585
4586 wb->jirilen = sb->jiriend - sb->start + 1;
4587 wb->dic_no = sb->dic_no;
4588 wb->entry = sb->entry;
4589 wb->kangovect = sb->kangovect;
4590 wb->hinsi = sb->hinsi;
4591 wb->hindo = sb->hindo;
4592 wb->ima = sb->ima;
4593 wb->hindo_updated = 0;
4594 wb->bug = 0;
4595 wb->dai_top = 0;
4596 wb->nobi_top = 0;
4597 wb->ref_cnt = 1;
4598 wb->hyoka = sb->hyoka;
4599 wb->down = NULL;
4600 wb->from_zenkouho = daip << 1 | zenp;
4601 len = wnn_Strlen(sb->fuzoku);
4602 wb->yomilen = wnn_Strlen(sb->yomi) + len;
4603 wb->real_kanjilen = wnn_Strlen(sb->kanji);
4604 wb->kanjilen = wb->real_kanjilen + len;
4605 wb->fukugou = fuku;
4606 wb->num_hinsi = nhinsi;
4607 if(nhinsi) {
4608 int hsize = abs(nhinsi) * sizeof(int);
4609 if((wb->hinsi_list = (int *)malloc(hsize)) == NULL) return(NULL);
4610 bcopy(hlist, wb->hinsi_list, hsize);
4611 } else
4612 wb->hinsi_list = NULL;
4613 /*
4614 wb->dai_top = (sb->status == WNN_CONNECT)? 0:1;
4615 ��ʸ�����Ƭ�ʳ��ξ�ʸ��˴ؤ��Ƥϡ�status �Ϥ����ø����ͤ����äƤ��롣
4616 */
4617 s = sb->yomi;
4618
4619 for(wb1 = wb; ;){
4620 if(wb1 == wb) c = wb1->yomi;
4621 else c = (w_char *)wb1;
4622 end = (w_char *)&wb1->next;
4623
4624 for(; c < end;) {
4625 if((*c++ = *s++) == 0){
4626 if(where == 1){
4627 where = 3;
4628 c--;
4629 s = sb->fuzoku;
4630 }else if(where == 3){
4631 where = 0;
4632 s = sb->kanji;
4633 }else if(where == 0){
4634 where = 4;
4635 c--;
4636 s = sb->fuzoku;
4637 }else{
4638 goto out;
4639 }
4640 }
4641 }
4642 wb1->next = get_new_bun(buf);
4643 wb1 = wb1->next;
4644 }
4645 out:
4646 wb1->next = NULL;
4647 return(wb);
4648 }
4649
4650 static void
make_space_for(buf,zenp,bun_no,bun_no2,cnt)4651 make_space_for(buf, zenp, bun_no, bun_no2, cnt)
4652 register struct wnn_buf_mt *buf;
4653 int bun_no, bun_no2, zenp;
4654 int cnt;
4655 {
4656 switch(zenp){
4657 case BUN:
4658 make_space_for_bun(buf,bun_no, bun_no2, cnt);
4659 break;
4660 case ZENKOUHO:
4661 make_space_for_zenkouho(buf,bun_no, bun_no2, cnt);
4662 }
4663 }
4664
4665 static void
make_space_for_bun(buf,bun_no,bun_no2,cnt)4666 make_space_for_bun(buf, bun_no, bun_no2, cnt)
4667 register struct wnn_buf_mt *buf;
4668 int bun_no, bun_no2;
4669 int cnt;
4670 {
4671 int newsize;
4672 register int k;
4673
4674 newsize = buf->orig.bun_suu + cnt - (bun_no2 - bun_no);
4675
4676 #define Realloc(a, b) realloc((char *)(a), (unsigned)(b))
4677
4678 if(newsize > buf->orig.msize_bun){
4679 buf->orig.bun = (WNN_BUN **)Realloc(buf->orig.bun, newsize * sizeof(WNN_BUN *));
4680 buf->orig.down_bnst = (WNN_BUN **)Realloc(buf->orig.down_bnst, newsize * sizeof(WNN_BUN *));
4681 buf->orig.msize_bun = newsize;
4682 }
4683
4684
4685 for(k = buf->orig.bun_suu; k < newsize; k++){
4686 buf->orig.down_bnst[k] = NULL;
4687 }
4688 bcopy((char *)&buf->orig.bun[bun_no2], (char *)&buf->orig.bun[bun_no + cnt],
4689 (buf->orig.bun_suu - bun_no2) * sizeof(WNN_BUN *));
4690 bcopy((char *)&buf->orig.down_bnst[bun_no2], (char *)&buf->orig.down_bnst[bun_no + cnt],
4691 (buf->orig.bun_suu - bun_no2) * sizeof(WNN_BUN *));
4692 if(bun_no2 < bun_no + cnt){
4693 bzero((char *)&buf->orig.down_bnst[bun_no2], (bun_no + cnt - bun_no2) * sizeof(WNN_BUN *));
4694 }
4695 buf->orig.bun_suu = newsize;
4696 }
4697
4698 static void
make_space_for_zenkouho(buf,bun_no,bun_no2,cnt)4699 make_space_for_zenkouho(buf, bun_no, bun_no2, cnt)
4700 struct wnn_buf_mt *buf;
4701 int bun_no, bun_no2;
4702 register int cnt;
4703 {
4704 register int newsize;
4705
4706 newsize = buf->orig.zenkouho_suu + cnt - (bun_no2 - bun_no);
4707
4708 if(newsize > buf->orig.msize_zenkouho){
4709 buf->orig.zenkouho = (WNN_BUN **)Realloc(buf->orig.zenkouho, newsize * sizeof(WNN_BUN *));
4710 buf->orig.zenkouho_dai = (int *)Realloc(buf->orig.zenkouho_dai, (1 + newsize) * sizeof(int *));
4711 buf->orig.msize_zenkouho = newsize;
4712 }
4713 bcopy((char *)&buf->orig.zenkouho[bun_no2],
4714 (char *)&buf->orig.zenkouho[bun_no + cnt],
4715 (buf->orig.zenkouho_suu - bun_no2) * sizeof(WNN_BUN *));
4716 buf->orig.zenkouho_suu = newsize;
4717 }
4718
4719
4720 static int
insert_sho(buf,zenp,bun_no,bun_no2,sp,cnt,uniq_level,fuku,nhinsi,hlist)4721 insert_sho(buf, zenp, bun_no, bun_no2, sp, cnt, uniq_level, fuku, nhinsi, hlist)
4722 struct wnn_buf_mt *buf;
4723 int bun_no, bun_no2;
4724 register struct wnn_sho_bunsetsu *sp;
4725 int cnt;
4726 int zenp; /* daip */
4727 int uniq_level; /* uniq is only supported when bun_no = -1
4728 and zenp == ZENKOUHO */
4729 int fuku, nhinsi, *hlist;
4730 {
4731 register WNN_BUN **b;
4732 register int k;
4733
4734 if(bun_no == -1){
4735 bun_no = bun_no2 = (zenp == BUN)? buf->orig.bun_suu: buf->orig.zenkouho_suu;
4736 }
4737
4738 /* It will make too big space when uniq_level > 0, but That's OK! */
4739 make_space_for(buf, zenp, bun_no, bun_no2, cnt);
4740
4741 b = ((zenp == BUN)? buf->orig.bun: buf->orig.zenkouho) + bun_no;
4742 for(k = bun_no ; k < bun_no + cnt ; k++, sp++){
4743 /* �ʻ�����Ѵ��κݤϡ�find_same_kouho() ���ơ�
4744 ������ꥹ�ȤΥ��֥���ɤ� */
4745 if(uniq_level && ((k < bun_no + cnt - 2) || nhinsi)){
4746 if(find_same_kouho(sp, buf->orig.zenkouho, b,uniq_level))continue;
4747 }
4748 *b = get_sho(buf, sp, zenp, SHO, fuku, nhinsi, hlist);
4749 (*b)->dai_top = (sp->status == WNN_CONNECT)? 0:1;
4750 if(zenp != BUN){
4751 if(buf->orig.zenkouho_endvect != -1){
4752 (*b)->dai_end = (sp->status_bkwd == WNN_CONNECT_BK)? 0:1;
4753 }else{
4754 (*b)->dai_end = 1;
4755 }
4756 }
4757 b++;
4758 }
4759 if(uniq_level && zenp == ZENKOUHO){
4760 buf->orig.zenkouho_suu = b - buf->orig.zenkouho;
4761 }
4762 return(cnt + bun_no);
4763 }
4764
4765 /* for zenkouho, assume bun_no = bun_no2 = zenkouho_suu */
4766 static int
insert_dai(buf,zenp,bun_no,bun_no2,dp,dcnt,uniq_level,fuku,nhinsi,hlist)4767 insert_dai(buf, zenp, bun_no, bun_no2, dp, dcnt, uniq_level, fuku, nhinsi, hlist)
4768 struct wnn_buf_mt *buf;
4769 int bun_no, bun_no2;
4770 struct wnn_dai_bunsetsu *dp;
4771 int dcnt;
4772 int zenp;
4773 int uniq_level;
4774 int fuku, nhinsi, *hlist;
4775 {
4776 register WNN_BUN **b, **b0;
4777 register int k, l, m;
4778 register int cnt = 0;
4779 struct wnn_sho_bunsetsu *sp, *sp1;
4780
4781 if(bun_no == -1){
4782 bun_no = bun_no2 = (zenp == BUN)? buf->orig.bun_suu: buf->orig.zenkouho_suu;
4783 }
4784
4785 for(k = 0; k < dcnt ; k++){
4786 cnt += dp[k].sbncnt;
4787 }
4788 make_space_for(buf, zenp, bun_no, bun_no2, cnt);
4789 /* zenkouho_dai_suu must not be initialized */
4790
4791 b = ((zenp == BUN)? buf->orig.bun: buf->orig.zenkouho) + bun_no;
4792
4793 for(k = 0, m = buf->orig.zenkouho_dai_suu ; k < dcnt; k++){
4794 /* �ʻ�����Ѵ��κݤϡ�find_same_kouho_dai() ���ơ�
4795 ������ꥹ�ȤΥ��֥���ɤ� */
4796 if(uniq_level && ((k < dcnt - 2) || nhinsi)){
4797 if(find_same_kouho_dai(&dp[k], buf, m, uniq_level))
4798 continue;
4799 }
4800 sp = dp[k].sbn;
4801 if(zenp == ZENKOUHO){
4802 buf->orig.zenkouho_dai[m++] = b - buf->orig.zenkouho;
4803 }
4804 b0 = b;
4805 sp1 = sp;
4806 for(l = 0 ; l < dp[k].sbncnt; l++){
4807 *b = get_sho(buf, sp, zenp, DAI, fuku, nhinsi, hlist);
4808 if(zenp == ZENKOUHO){
4809 if (l == dp[k].sbncnt -1){
4810 if(buf->orig.zenkouho_endvect != -1){
4811 (*b)->dai_end = (sp->status_bkwd == WNN_CONNECT_BK)? 0:1;
4812 }else{
4813 (*b)->dai_end = 0;
4814 }
4815 }else{
4816 (*b)->dai_end = 0;
4817 }
4818 }
4819 b++;
4820 sp++;
4821 }
4822 (*b0)->dai_top = (sp1->status == WNN_CONNECT)? 0:1;
4823 (*b0)->daihyoka = dp[k].hyoka;
4824 }
4825 if(zenp == ZENKOUHO){
4826 buf->orig.zenkouho_dai[m] = b - buf->orig.zenkouho;
4827 buf->orig.zenkouho_suu = b - buf->orig.zenkouho;
4828 buf->orig.zenkouho_dai_suu = m;
4829 }
4830 return(cnt + bun_no);
4831 }
4832
4833 static void
set_sho(b,p)4834 set_sho(b, p)
4835 register WNN_BUN *b;
4836 register WNN_BUN **p;
4837 {
4838 b->ref_cnt++;
4839 *p = b;
4840 }
4841
4842 static void
set_dai(b,p,n)4843 set_dai(b, p, n)
4844 register WNN_BUN **b;
4845 register WNN_BUN **p;
4846 register int n;
4847 {
4848 for(;n;n--){
4849 (*b)->ref_cnt++;
4850 *p++ = *b++;
4851 }
4852 }
4853
4854 static int
get_c_jikouho_from_zenkouho(buf,dest)4855 get_c_jikouho_from_zenkouho(buf, dest)
4856 struct wnn_buf_mt *buf;
4857 WNN_BUN *dest;
4858 {
4859 register int k;
4860 w_char area[LENGTHKANJI];
4861 w_char area1[LENGTHKANJI];
4862 register WNN_BUN *b;
4863
4864 wnn_area(dest, area, WNN_KANJI);
4865 for(k = 0; k < buf->orig.zenkouho_suu; k++){
4866 b = buf->orig.zenkouho[k];
4867 if(b->entry == dest->entry && b->dic_no == dest->dic_no){
4868 wnn_area(b, area1, WNN_KANJI);
4869 if(wnn_Strcmp(area, area1) == 0){
4870 return(k);
4871 }
4872 }
4873 }
4874 return(-1);
4875 }
4876
4877 static int
get_c_jikouho_from_zenkouho_dai(buf,dest)4878 get_c_jikouho_from_zenkouho_dai(buf, dest)
4879 struct wnn_buf_mt *buf;
4880 WNN_BUN *dest;
4881 {
4882 register int k;
4883 w_char area[LENGTHKANJI];
4884 w_char area1[LENGTHKANJI];
4885 register WNN_BUN *b;
4886 register int l;
4887
4888 wnn_area(dest, area, WNN_KANJI);
4889 for(k = 0; k < buf->orig.zenkouho_dai_suu; k++){
4890 b = buf->orig.zenkouho[buf->orig.zenkouho_dai[k]];
4891 for(l = 0 ; l < buf->orig.zenkouho_dai[k + 1]; l++, dest++, b++){
4892 if(b->entry != dest->entry || b->dic_no != dest->dic_no) break;
4893 wnn_area(b, area1, WNN_KANJI);
4894 if(wnn_Strcmp(area, area1) != 0){
4895 break;
4896 }
4897 }
4898 if(l == buf->orig.zenkouho_dai[k + 1]){
4899 return(k);
4900 }
4901 }
4902 return(-1);
4903 }
4904
4905
4906 static int
get_c_jikouho(sp,cnt,dest)4907 get_c_jikouho(sp, cnt, dest)
4908 struct wnn_sho_bunsetsu *sp;
4909 int cnt;
4910 WNN_BUN *dest;
4911 {
4912 register int k;
4913 register int len;
4914 w_char area[LENGTHKANJI];
4915
4916 wnn_area(dest, area, WNN_KANJI);
4917 for(k = 0; k < cnt; k++,sp++){
4918 if(sp->entry == dest->entry && sp->dic_no == dest->dic_no
4919 && sp->kangovect == dest->kangovect){
4920 if(wnn_Strncmp(area, sp->kanji, len = wnn_Strlen(sp->kanji)) == 0 &&
4921 wnn_Strcmp(area + len, sp->fuzoku) == 0){
4922 return(k);
4923 }
4924 }
4925 }
4926 return(-1);
4927 }
4928
4929 static int
get_c_jikouho_dai(dp,cnt,dest,bun_no)4930 get_c_jikouho_dai(dp, cnt, dest, bun_no)
4931 struct wnn_dai_bunsetsu *dp;
4932 int cnt;
4933 WNN_BUN **dest;
4934 int bun_no;
4935 {
4936 register int k, l;
4937 register int len;
4938 w_char area[LENGTHKANJI];
4939 register struct wnn_sho_bunsetsu *sp;
4940
4941 for(k = 0; k < cnt; k++,dp++){
4942 sp = dp->sbn;
4943 for(l = 0 ; l < dp->sbncnt; l++, sp++){
4944 if(sp->entry != (dest[bun_no + l])->entry ||
4945 sp->kangovect != (dest[bun_no + l])->kangovect ||
4946 sp->dic_no != (dest[bun_no + l])->dic_no){
4947 break;
4948 }
4949 wnn_area(dest[bun_no + l], area, WNN_KANJI);
4950 if(wnn_Strncmp(area, sp->kanji, len = wnn_Strlen(sp->kanji)) != 0 ||
4951 wnn_Strcmp(area + len, sp->fuzoku) != 0){
4952 break;
4953 }
4954 }
4955 if(l == dp->sbncnt) return(k);
4956 }
4957 return(-1);
4958 }
4959
4960
4961 static int
find_same_kouho(sp,st,end,level)4962 find_same_kouho(sp, st, end, level)
4963 struct wnn_sho_bunsetsu *sp;
4964 register WNN_BUN **st, **end;
4965 int level;
4966 {
4967 register int len;
4968 w_char area[LENGTHKANJI];
4969 register WNN_BUN *b;
4970
4971 if(level == WNN_UNIQ){
4972 for(; st < end; st++){
4973 b = *st;
4974 if(sp->hinsi == b->hinsi){
4975 wnn_area(b, area, WNN_KANJI);
4976 if(wnn_Strncmp(area, sp->kanji, len = wnn_Strlen(sp->kanji)) == 0 &&
4977 wnn_Strcmp(area + len, sp->fuzoku) == 0){
4978 return(1);
4979 }
4980 }
4981 }
4982 }else{ /* level = WNN_UNIQ_KNJ */
4983 for(; st < end; st++){
4984 b = *st;
4985 wnn_area(b, area, WNN_KANJI);
4986 if(wnn_Strncmp(area, sp->kanji, len = wnn_Strlen(sp->kanji)) == 0 &&
4987 wnn_Strcmp(area + len, sp->fuzoku) == 0){
4988 return(1);
4989 }
4990 }
4991 }
4992 return(0);
4993 }
4994
4995 static int
find_same_kouho_dai(dp,buf,top,level)4996 find_same_kouho_dai(dp, buf, top, level)
4997 struct wnn_dai_bunsetsu *dp;
4998 struct wnn_buf_mt *buf;
4999 int top;
5000 int level;
5001 {
5002 int len;
5003 register int k, l;
5004 w_char area[LENGTHKANJI];
5005 WNN_BUN *b;
5006 register struct wnn_sho_bunsetsu *sp;
5007
5008 for(k = 0 ; k < top ; k++){
5009 for(l = 0,sp = dp->sbn ; l < dp->sbncnt; l++, sp++){
5010 b = buf->orig.zenkouho[buf->orig.zenkouho_dai[k] + l];
5011 if(sp->end - sp->start + 1 != b->yomilen) break;/* From: tsuiki */
5012 if(level != WNN_UNIQ_KNJ){
5013 if(sp->hinsi != b->hinsi) break;
5014 }
5015 wnn_area(b, area, WNN_KANJI);
5016 if(wnn_Strncmp(area, sp->kanji, len = wnn_Strlen(sp->kanji)) != 0 ||
5017 wnn_Strcmp(area + len, sp->fuzoku) != 0){
5018 break;
5019 }
5020 }
5021 if(l == dp->sbncnt)
5022 return(1);
5023 }
5024 return(0);
5025 }
5026
5027 int
wnn_cnt_free(buf)5028 wnn_cnt_free(buf)
5029 struct wnn_buf *buf;
5030 {
5031 register int n;
5032 register WNN_BUN *b;
5033
5034 for(n = 0, b = buf->free_heap;b;n++, b = b->free_next);
5035 return(n);
5036 }
5037
5038 static struct wnn_jdata *
jl_word_info_e_body(env,dic_no,entry)5039 jl_word_info_e_body(env, dic_no, entry)
5040 register struct wnn_env_int *env;
5041 int dic_no, entry;
5042 {
5043 struct wnn_jdata *x;
5044
5045 if (js_word_info(env,dic_no, entry, &wordrb) < 0) {
5046 env_wnn_errorno_copy(env);
5047 if_dead_disconnect(env);
5048 return(NULL);
5049 }
5050 x = (struct wnn_jdata *)(wordrb.buf);
5051 return x;
5052 }
5053
5054 struct wnn_jdata *
jl_word_info_e(env,dic_no,entry)5055 jl_word_info_e(env, dic_no, entry)
5056 register struct wnn_env *env;
5057 int dic_no, entry;
5058 {
5059 struct wnn_jdata *x;
5060
5061 if(!env) return(NULL);
5062 LockMutex(&ENV_LOCK(env));
5063 env_wnn_errorno_set = 0;
5064 x = jl_word_info_e_body((WNN_ENV_INT *)env, dic_no, entry);
5065 UnlockMutex(&ENV_LOCK(env));
5066 return x;
5067 }
5068
5069 struct wnn_jdata *
jl_word_info(buf,dic_no,entry)5070 jl_word_info(buf, dic_no, entry)
5071 register struct wnn_buf *buf;
5072 int dic_no, entry;
5073 {
5074 struct wnn_jdata *x;
5075
5076 if(!buf || !(buf->env)) return(NULL);
5077 LockMutex(&BUF_LOCK(buf));
5078 LockMutex(&(envmt->env_lock));
5079 buf_wnn_errorno_set = 0;
5080 x = jl_word_info_e_body((WNN_ENV_INT *)buf->env, dic_no, entry);
5081 if(x == NULL) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
5082 UnlockMutex(&(envmt->env_lock));
5083 UnlockMutex(&BUF_LOCK(buf));
5084 return x;
5085 }
5086
5087 /*:::DOC_START
5088 *
5089 * Function Name: jl_dic_list_e_body
5090 * Description : �����������Υ��֥롼����
5091 * Parameter :
5092 * env : (InOut) �Ķ��ؤΥݥ���
5093 * dmask : (In) ��������ޥ���
5094 * dicinfo : (Ont) �ǡ�����������ѹ�¤�ΤؤΥݥ���
5095 *
5096 * Return value : -1==ERROR, else ��Ͽ�����
5097 *
5098 * Author : Hideyuki Kishiba
5099 *
5100 * Revision history:
5101 *
5102 *:::DOC_END
5103 */
5104 static int
jl_dic_list_e_body(env,dmask,dicinfo)5105 jl_dic_list_e_body(env, dmask, dicinfo)
5106 struct wnn_env_int *env;
5107 unsigned long dmask;
5108 WNN_DIC_INFO **dicinfo;
5109 {
5110 WNN_DIC_INFO *info;
5111 int cnt;
5112 register int k;
5113 register char *c;
5114
5115 if(dmask == 0)
5116 cnt = js_dic_list(env, &dicrb);
5117 else
5118 cnt = js_fi_dic_list(env, dmask, &dicrb);
5119
5120 if (cnt < 0) {
5121 env_wnn_errorno_copy(env);
5122 if_dead_disconnect(env);
5123 return(-1);
5124 }
5125 info = (WNN_DIC_INFO *)(dicrb.buf);
5126
5127 /* If the file is loaded from this client, change the file name to the one
5128 used in loading it. */
5129 LockMutex(&envs_lock);
5130 for(k = 0 ; k < cnt ; k++){
5131 c = find_file_name_from_id(env, info[k].body);
5132 if(c != NULL){
5133 strcpy(info[k].fname, c);
5134 }
5135
5136 c = find_file_name_from_id(env, info[k].hindo);
5137 if(c != NULL){
5138 strcpy(info[k].hfname, c);
5139 }
5140 }
5141
5142 *dicinfo = info;
5143 UnlockMutex(&envs_lock);
5144 return(cnt);
5145 } /* End of jl_dic_list_e_body */
5146
5147 /*:::DOC_START
5148 *
5149 * Function Name: jl_dic_list_e
5150 * Description : �Ķ�����Ͽ����Ƥ���ף�����������
5151 * Parameter :
5152 * env : (InOut) �Ķ��ؤΥݥ���
5153 * dicinfo : (Ont) �ǡ�����������ѹ�¤�ΤؤΥݥ���
5154 *
5155 * Return value : -1==ERROR, else ��Ͽ�����
5156 *
5157 * Author : Hideyuki Kishiba
5158 *
5159 * Revision history:
5160 *
5161 *:::DOC_END
5162 */
5163 int
jl_dic_list_e(env,dicinfo)5164 jl_dic_list_e(env, dicinfo)
5165 struct wnn_env *env;
5166 WNN_DIC_INFO **dicinfo;
5167 {
5168 int x;
5169
5170 if(!env) return(-1);
5171 LockMutex(&ENV_LOCK(env));
5172 env_wnn_errorno_set = 0;
5173 x = jl_dic_list_e_body((WNN_ENV_INT *)env, 0, dicinfo);
5174 UnlockMutex(&ENV_LOCK(env));
5175 return x;
5176 } /* End of jl_dic_list_e */
5177
5178 /*:::DOC_START
5179 *
5180 * Function Name: jl_dic_list
5181 * Description : �Ķ�����Ͽ����Ƥ���ף�����������
5182 * Parameter :
5183 * buf : (InOut) �Хåե��ؤΥݥ���
5184 * dip : (Ont) �ǡ�����������ѹ�¤�ΤؤΥݥ���
5185 *
5186 * Return value : -1==ERROR, else ��Ͽ�����
5187 *
5188 * Author : Hideyuki Kishiba
5189 *
5190 * Revision history:
5191 *
5192 *:::DOC_END
5193 */
5194 int
jl_dic_list(buf,dip)5195 jl_dic_list(buf, dip)
5196 register struct wnn_buf *buf;
5197 WNN_DIC_INFO **dip;
5198 {
5199 int x;
5200
5201 if(!buf || !(buf->env)) return(-1);
5202 LockMutex(&BUF_LOCK(buf));
5203 LockMutex(&(envmt->env_lock));
5204 buf_wnn_errorno_set = 0;
5205 x = jl_dic_list_e_body((WNN_ENV_INT *)buf->env, 0, dip);
5206 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
5207 UnlockMutex(&(envmt->env_lock));
5208 UnlockMutex(&BUF_LOCK(buf));
5209 return x;
5210 } /* End of jl_dic_list */
5211
5212 /*:::DOC_START
5213 *
5214 * Function Name: jl_fi_dic_list_e
5215 * Description : �Ķ�����Ͽ����Ƥ��뼭����⡢���ꤷ��������
5216 * ���������
5217 * Parameter :
5218 * env : (InOut) �Ķ��ؤΥݥ���
5219 * dmask : (In) ��������ޥ���
5220 * dicinfo : (Ont) �ǡ�����������ѹ�¤�ΤؤΥݥ���
5221 *
5222 * Return value : -1==ERROR, else ��Ͽ�����
5223 *
5224 * Author : Hideyuki Kishiba
5225 *
5226 * Revision history:
5227 *
5228 *:::DOC_END
5229 */
5230 int
jl_fi_dic_list_e(env,dmask,dicinfo)5231 jl_fi_dic_list_e(env, dmask, dicinfo)
5232 struct wnn_env *env;
5233 unsigned long dmask;
5234 WNN_DIC_INFO **dicinfo;
5235 {
5236 int x;
5237
5238 if(!env) return(-1);
5239 LockMutex(&ENV_LOCK(env));
5240 env_wnn_errorno_set = 0;
5241 x = jl_dic_list_e_body((WNN_ENV_INT *)env, dmask, dicinfo);
5242 UnlockMutex(&ENV_LOCK(env));
5243 return x;
5244 } /* End of jl_fi_dic_list_e */
5245
5246 /*:::DOC_START
5247 *
5248 * Function Name: jl_fi_dic_list
5249 * Description : �Ķ�����Ͽ����Ƥ��뼭����⡢���ꤷ��������
5250 * ���������
5251 * Parameter :
5252 * buf : (InOut) �Хåե��ؤΥݥ���
5253 * dmask : (In) ��������ޥ���
5254 * dip : (Ont) �ǡ�����������ѹ�¤�ΤؤΥݥ���
5255 *
5256 * Return value : -1==ERROR, else ��Ͽ�����
5257 *
5258 * Author : Hideyuki Kishiba
5259 *
5260 * Revision history:
5261 *
5262 *:::DOC_END
5263 */
5264 int
jl_fi_dic_list(buf,dmask,dip)5265 jl_fi_dic_list(buf, dmask, dip)
5266 register struct wnn_buf *buf;
5267 unsigned long dmask;
5268 WNN_DIC_INFO **dip;
5269 {
5270 int x;
5271
5272 if(!buf || !(buf->env)) return(-1);
5273 LockMutex(&BUF_LOCK(buf));
5274 LockMutex(&(envmt->env_lock));
5275 buf_wnn_errorno_set = 0;
5276 x = jl_dic_list_e_body((WNN_ENV_INT *)buf->env, dmask, dip);
5277 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
5278 UnlockMutex(&(envmt->env_lock));
5279 UnlockMutex(&BUF_LOCK(buf));
5280 return x;
5281 } /* End of jl_fi_dic_list */
5282
5283 /*:::DOC_START
5284 *
5285 * Function Name: jl_fuzokugo_list_e_body
5286 * Description : ��°���������Υ��֥롼����
5287 * Parameter :
5288 * env : (InOut) �Ķ��ؤΥݥ���
5289 * curfzk : (Out) �����ѥե����뼱�̻�
5290 * fzkinfo : (Out) ��°������������ѹ�¤�ΤؤΥݥ���
5291 *
5292 * Return value : -1==ERROR, else �ɹ�����°���
5293 *
5294 * Author : Hideyuki Kishiba
5295 *
5296 * Revision history:
5297 *
5298 *:::DOC_END
5299 */
5300 static int
jl_fuzokugo_list_e_body(env,curfzk,fzkinfo)5301 jl_fuzokugo_list_e_body(env, curfzk, fzkinfo)
5302 struct wnn_env *env;
5303 int *curfzk;
5304 WNN_FZK_INFO **fzkinfo;
5305 {
5306 int cnt;
5307
5308 if((cnt = js_fuzokugo_list(env, curfzk, fzkinfo)) < 0) {
5309 env_wnn_errorno_copy(env);
5310 if_dead_disconnect(env);
5311 return(-1);
5312 }
5313 return(cnt);
5314 } /* End of jl_fuzokugo_list_e_body */
5315
5316 /*:::DOC_START
5317 *
5318 * Function Name: jl_fuzokugo_list_e
5319 * Description : ���ꤵ�줿�����Ф��ɤ߹��ޤ�Ƥ�������°������
5320 * �Ķ��˸������ꤵ��Ƥ������μ��̻Ҥ��֤�
5321 * Parameter :
5322 * env : (In) �Ķ��ؤΥݥ���
5323 * curfzk : (Out) �����ѥե����뼱�̻�
5324 * fzkinfo : (Out) �ǡ�����������ѹ�¤�ΤؤΥݥ���
5325 *
5326 * Return value : -1==ERROR, else �ɹ�����°���
5327 *
5328 * Author : Hideyuki Kishiba
5329 *
5330 * Revision history:
5331 *
5332 *:::DOC_END
5333 */
5334 int
jl_fuzokugo_list_e(env,curfzk,fzkinfo)5335 jl_fuzokugo_list_e(env, curfzk, fzkinfo)
5336 struct wnn_env *env;
5337 int *curfzk;
5338 WNN_FZK_INFO **fzkinfo;
5339 {
5340 int x;
5341
5342 if(!env) return(-1);
5343 LockMutex(&ENV_LOCK(env));
5344 env_wnn_errorno_set = 0;
5345 x = jl_fuzokugo_list_e_body((WNN_ENV_INT *)env, curfzk, fzkinfo);
5346 UnlockMutex(&ENV_LOCK(env));
5347 return x;
5348 } /* End of jl_fuzokugo_list_e */
5349
5350 /*:::DOC_START
5351 *
5352 * Function Name: jl_fuzokugo_list
5353 * Description : ���ꤵ�줿�����Ф��ɤ߹��ޤ�Ƥ�������°������
5354 * �Ķ��˸������ꤵ��Ƥ������μ��̻Ҥ��֤�
5355 * Parameter :
5356 * buf : (In) �Хåե��ؤΥݥ���
5357 * curfzk : (Out) �����ѥե����뼱�̻�
5358 * fzkp : (Out) �ǡ�����������ѹ�¤�ΤؤΥݥ���
5359 *
5360 * Return value : -1==ERROR, else �ɹ�����°���
5361 *
5362 * Author : Hideyuki Kishiba
5363 *
5364 * Revision history:
5365 *
5366 *:::DOC_END
5367 */
5368 int
jl_fuzokugo_list(buf,curfzk,fzkp)5369 jl_fuzokugo_list(buf, curfzk, fzkp)
5370 register struct wnn_buf *buf;
5371 int *curfzk;
5372 WNN_FZK_INFO **fzkp;
5373 {
5374 int x;
5375
5376 if(!buf || !(buf->env)) return(-1);
5377 LockMutex(&BUF_LOCK(buf));
5378 LockMutex(&(envmt->env_lock));
5379 buf_wnn_errorno_set = 0;
5380 x = jl_fuzokugo_list_e_body((WNN_ENV_INT *)buf->env, curfzk, fzkp);
5381 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
5382 UnlockMutex(&(envmt->env_lock));
5383 UnlockMutex(&BUF_LOCK(buf));
5384 return x;
5385 } /* End of jl_fuzokugo_list */
5386
5387 /*:::DOC_START
5388 *
5389 * Function Name: jl_free
5390 * Description : �Ѵ��ʻ������°������ free ����
5391 * Parameter :
5392 * ptr : �оݥݥ���
5393 *
5394 * Return value : 0==SUCCESS, -1==ERROR
5395 *
5396 * Author : Hideyuki Kishiba
5397 *
5398 * Revision history:
5399 *
5400 *:::DOC_END
5401 */
5402 int
jl_free(ptr)5403 jl_free(ptr)
5404 char *ptr;
5405 {
5406 free(ptr);
5407 return(0);
5408 } /* End of jl_free */
5409
5410
5411 static int
sort_func_ws(a,b)5412 sort_func_ws(a,b)
5413 register char *a, *b;
5414 {
5415 int ah, bh, ai, bi, iah, ibh, iai, ibi;
5416 ah = ((struct wnn_jdata *)a)->hindo;
5417 bh = ((struct wnn_jdata *)b)->hindo;
5418 iah = ((struct wnn_jdata *)a)->int_hindo;
5419 ibh = ((struct wnn_jdata *)b)->int_hindo;
5420 ai = ((struct wnn_jdata *)a)->ima;
5421 bi = ((struct wnn_jdata *)b)->ima;
5422 iai = ((struct wnn_jdata *)a)->int_ima;
5423 ibi = ((struct wnn_jdata *)b)->int_ima;
5424
5425 if(ai == WNN_IMA_OFF && ah == WNN_ENTRY_NO_USE) return(1);
5426 if(bi == WNN_IMA_OFF && bh == WNN_ENTRY_NO_USE) return(-1);
5427 if(iai == WNN_IMA_OFF && iah == WNN_ENTRY_NO_USE) return(1);
5428 if(ibi == WNN_IMA_OFF && ibh == WNN_ENTRY_NO_USE) return(-1);
5429
5430 if(ai != bi){
5431 if(ai < bi) return(1);
5432 return(-1);
5433 }
5434 if(iah >= 0){
5435 ah += iah;
5436 bh += ibh;
5437 }
5438 if(ah > bh)return(-1);
5439 if(ah < bh)return(1);
5440 return(0);
5441 }
5442
5443 static int
jl_word_search_e_body(env,dic_no,yomi,jdp)5444 jl_word_search_e_body(env,dic_no, yomi, jdp)
5445 register struct wnn_env_int *env;
5446 int dic_no;
5447 w_char *yomi;
5448 struct wnn_jdata **jdp;
5449 {
5450 register int cnt;
5451 struct wnn_jdata *jd;
5452
5453 if ((cnt = js_word_search(env,dic_no, yomi, &wordrb)) < 0) {
5454 env_wnn_errorno_copy(env);
5455 if_dead_disconnect(env);
5456 return(-1);
5457 }
5458 jd = (struct wnn_jdata *)wordrb.buf;
5459 qsort((char *)jd,cnt,sizeof(struct wnn_jdata),sort_func_ws);
5460 *jdp = jd;
5461 return(cnt);
5462 }
5463
5464 int
jl_word_search_e(env,dic_no,yomi,jdp)5465 jl_word_search_e(env,dic_no, yomi, jdp)
5466 register struct wnn_env *env;
5467 int dic_no;
5468 w_char *yomi;
5469 struct wnn_jdata **jdp;
5470 {
5471 int x;
5472
5473 if(!env) return(-1);
5474 LockMutex(&ENV_LOCK(env));
5475 env_wnn_errorno_set = 0;
5476 x = jl_word_search_e_body((WNN_ENV_INT *)env,dic_no, yomi, jdp);
5477 UnlockMutex(&ENV_LOCK(env));
5478 return x;
5479 }
5480
5481 int
jl_word_search(buf,dic_no,yomi,jdp)5482 jl_word_search(buf, dic_no, yomi, jdp)
5483 register struct wnn_buf *buf;
5484 int dic_no;
5485 w_char *yomi;
5486 struct wnn_jdata **jdp;
5487 {
5488 int x;
5489
5490 if(!buf || !(buf->env)) return(-1);
5491 LockMutex(&BUF_LOCK(buf));
5492 LockMutex(&(envmt->env_lock));
5493 buf_wnn_errorno_set = 0;
5494 x = jl_word_search_e_body((WNN_ENV_INT *)buf->env, dic_no, yomi, jdp);
5495 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
5496 UnlockMutex(&(envmt->env_lock));
5497 UnlockMutex(&BUF_LOCK(buf));
5498 return x;
5499 }
5500
5501 static int
jl_word_search_by_env_e_body(env,yomi,jdp)5502 jl_word_search_by_env_e_body(env, yomi, jdp)
5503 register struct wnn_env_int *env;
5504 struct wnn_jdata **jdp;
5505 w_char *yomi;
5506 {
5507 register int cnt;
5508 struct wnn_jdata *jd;
5509
5510 if ((cnt = js_word_search_by_env(env, yomi, &wordrb)) < 0) {
5511 env_wnn_errorno_copy(env);
5512 if_dead_disconnect(env);
5513 return(-1);
5514 }
5515 jd = (struct wnn_jdata *)wordrb.buf;
5516 qsort((char *)jd,cnt,sizeof(struct wnn_jdata),sort_func_ws);
5517 *jdp = jd;
5518 return(cnt);
5519 }
5520
5521 int
jl_word_search_by_env_e(env,yomi,jdp)5522 jl_word_search_by_env_e(env, yomi, jdp)
5523 register struct wnn_env *env;
5524 struct wnn_jdata **jdp;
5525 w_char *yomi;
5526 {
5527 int x;
5528
5529 if(!env) return(-1);
5530 LockMutex(&ENV_LOCK(env));
5531 env_wnn_errorno_set = 0;
5532 x = jl_word_search_by_env_e_body((WNN_ENV_INT *)env, yomi, jdp);
5533 UnlockMutex(&ENV_LOCK(env));
5534 return x;
5535 }
5536
5537 int
jl_word_search_by_env(buf,yomi,jdp)5538 jl_word_search_by_env(buf, yomi, jdp)
5539 register struct wnn_buf *buf;
5540 struct wnn_jdata **jdp;
5541 w_char *yomi;
5542 {
5543 int x;
5544
5545 if(!buf || !(buf->env)) return(-1);
5546 LockMutex(&BUF_LOCK(buf));
5547 LockMutex(&(envmt->env_lock));
5548 buf_wnn_errorno_set = 0;
5549 x = jl_word_search_by_env_e_body((WNN_ENV_INT *)buf->env, yomi, jdp);
5550 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
5551 UnlockMutex(&(envmt->env_lock));
5552 UnlockMutex(&BUF_LOCK(buf));
5553 return x;
5554 }
5555
5556
5557
5558 static void
add_down_bnst(buf,k,b)5559 add_down_bnst(buf, k, b)
5560 register struct wnn_buf_mt *buf;
5561 register int k;
5562 register WNN_BUN *b;
5563 {
5564 if(b->down) return; /* In order to prevent roop! */
5565 if(b == buf->orig.down_bnst[k]) return; /* In order to prevent roop! */
5566 /* It occurs when Zenkouho-->Nobi-conv */
5567 b->down = buf->orig.down_bnst[k];
5568 buf->orig.down_bnst[k] = b;
5569 b->ref_cnt ++;
5570 }
5571
5572
5573 #define REAL_PARAM(x) (strcmp(x, "-"))
5574
5575 /** wnnrc ���ƤΥѥ��������� */
5576 int
jl_set_env_wnnrc(env,wnnrc_n,error_handler,message_handler)5577 jl_set_env_wnnrc(env, wnnrc_n, error_handler, message_handler)
5578 register struct wnn_env *env;
5579 char *wnnrc_n;
5580 int (*error_handler)(), (*message_handler)();
5581 {
5582 int level = 0;
5583 int x;
5584
5585 if(!env) return(-1);
5586 LockMutex(&ENV_LOCK(env));
5587 env_wnn_errorno_set = 0;
5588 if((int)error_handler == WNN_CREATE){
5589 confirm_state = CREATE_WITHOUT_CONFIRM;
5590 }else if((int)error_handler == WNN_NO_CREATE){
5591 confirm_state = NO_CREATE;
5592 }else{
5593 confirm_state = CONFIRM;
5594 }
5595
5596 x = jl_set_env_wnnrc1_body((WNN_ENV_INT *)env, wnnrc_n, error_handler, message_handler, level, 0);
5597
5598 confirm_state = 0;
5599 UnlockMutex(&ENV_LOCK(env));
5600 return(x);
5601 }
5602
5603 static int
jl_set_env_wnnrc1_body(env,wnnrc_n,error_handler,message_handler,level,local)5604 jl_set_env_wnnrc1_body(env, wnnrc_n, error_handler, message_handler, level, local)
5605 register struct wnn_env_int *env;
5606 char *wnnrc_n;
5607 int (*error_handler)(), (*message_handler)();
5608 int level;
5609 int local;
5610 {
5611 register int num, rev, prio;
5612 char s[20][EXPAND_PATH_LENGTH];
5613 char code[EXPAND_PATH_LENGTH];
5614 char tmp[1024];
5615 int tmplen;
5616 register FILE *fp;
5617 unsigned long vmask = 0;
5618 int *flag;
5619 struct wnn_henkan_env henv;
5620 int (*error_handler1)() = (int (*)())0;
5621 char *p;
5622 extern char *getenv();
5623
5624 if(level > MAXINCLUDE){
5625 LockMutex(&msg_lock);
5626 message_out(message_handler,
5627 msg_get(wnn_msg_cat, 206, NULL, env->orig.lang, NULL));
5628 /*
5629 "include �Υ�٥뤬¿��ޤ���"
5630 */
5631 UnlockMutex(&msg_lock);
5632 return(-1);
5633 }
5634 if (!strcmp(wnnrc_n, DEFAULT_RC_NAME)) {
5635 /*
5636 * �ǥե���Ȥ�wnnenvrc��õ���˹Ԥ�
5637 */
5638 if(!(p = getenv("HOME")))
5639 goto Default_WNVRC;
5640 tmplen = sizeof(tmp);
5641 strncpy(tmp, p, tmplen - 1);
5642 tmp[tmplen - 1] = 0;
5643 if (strlen(tmp) + strlen(FIWNN_DIR) >= tmplen)
5644 goto Default_WNVRC;
5645 strcat(tmp, FIWNN_DIR);
5646 if (strlen(tmp) + strlen(ENVRCFILE) >= tmplen)
5647 goto Default_WNVRC;
5648 strcat(tmp, ENVRCFILE);
5649 if ((fp = fopen(tmp, "r")) == NULL) {
5650 Default_WNVRC:
5651 /*
5652 * �桼���Υǥե���ȥե����뤬̵���ä��Τǡ������ƥ�Υǥե���Ȥ�
5653 * ���˹Ԥ�
5654 */
5655 sprintf(tmp, "%s/%s%s", LIBDIR, WNN_DEFAULT_LANG, ENVRCFILE);
5656 /* /usr/local/lib/wnn/ja_JP/wnnenvrc */
5657 if((fp = fopen(tmp, "r")) == NULL) {
5658 /*
5659 * �����ƥ�Υǥե���Ȥ�ʤ��ä��Τǥ��顼�ˤ���
5660 */
5661 message_out(message_handler,
5662 msg_get(wnn_msg_cat, 111, NULL, env->orig.lang,
5663 NULL));
5664 UnlockMutex(&msg_lock);
5665 return(-1);
5666 }
5667 }
5668 } else {
5669 if((fp = fopen(wnnrc_n, "r")) == NULL){
5670 LockMutex(&msg_lock);
5671 /*
5672 * ���ꤵ�줿wnnennvrc�������ץ�Ǥ��ʤ�
5673 */
5674 message_out(message_handler,
5675 msg_get(wnn_msg_cat, 207, NULL, env->orig.lang, NULL),
5676 wnnrc_n);
5677 UnlockMutex(&msg_lock);
5678 return(-1);
5679 }
5680 }
5681 while(fgets(tmp,1024,fp ) != NULL){
5682 num = sscanf(tmp,
5683 "%s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s",code,
5684 s[0],s[1],s[2],s[3],s[4],s[5],s[6],s[7],s[8],s[9],s[10],
5685 s[11],s[12],s[13],s[14],s[15],s[16],s[17],s[18],s[19]) ;
5686 if (num <= 0) {
5687 continue;
5688 }
5689 if(code[0] == ';'){
5690 continue;
5691 }else if (strcmp(code, "include") == 0){
5692 expand_expr_all(s[0], env);
5693 if(jl_set_env_wnnrc1_body(env, s[0], error_handler,
5694 message_handler, level + 1,
5695 local) == -1){
5696 fclose(fp);
5697 return(-1);
5698 }
5699 continue;
5700 }
5701 switch (code[0]) {
5702 case 'a':
5703 if (!strcmp(code, "autosave")) env->orig.autosave = atoi(s[0]);
5704 break;
5705 case 'k':
5706 if (!strcmp(code, "kutouten")) {
5707 /* ������ */
5708 if (num < 2) goto _Err_happend;
5709 vmask |= WNN_ENV_KUTOUTEN_MASK;
5710 flag = &henv.kutouten_flag;
5711 goto _set_flag;
5712 } else if (!strcmp(code, "kakko")) {
5713 /* ��� */
5714 if (num < 2) goto _Err_happend;
5715 vmask |= WNN_ENV_KAKKO_MASK;
5716 flag = &henv.kakko_flag;
5717 goto _set_flag;
5718 } else if (!strcmp(code, "kigou")) {
5719 /* ���� */
5720 if (num < 2) goto _Err_happend;
5721 vmask |= WNN_ENV_KIGOU_MASK;
5722 flag = &henv.kigou_flag;
5723 goto _set_flag;
5724 }
5725 }
5726 if (local == 0) {
5727 switch (code[0]) {
5728 case 'b':
5729 if (!strcmp(code, "bunsetsugiri_gakusyuu")) {
5730 int dic_no, mode, type;
5731 AUTO_LEARNING:
5732 if (num < 6) goto _Err_happend;
5733 if (!strcmp(code, "muhenkan_gakusyuu")) {
5734 type = WNN_MUHENKAN_LEARNING;
5735 } else {
5736 type = WNN_BUNSETSUGIRI_LEARNING;
5737 }
5738 if (((dic_no = js_get_autolearning_dic(env, type)) == -1)
5739 && env_wnn_errorno_eql) {
5740 if (env_wnn_errorno_eql != WNN_JSERVER_DEAD) {
5741 message_out(message_handler, "%s :%s\n", s[0],
5742 wnn_perror_lang(env->orig.lang, env));
5743 } else
5744 message_out(message_handler, "%s\n",
5745 wnn_perror_lang(env->orig.lang, env));
5746 goto _Err_happend;
5747 }
5748 expand_expr_all(s[0], env);
5749 mode = atoi(s[1]);
5750 if ((mode > 2) || (mode < 0)) goto _Err_happend;
5751 if (!REAL_PARAM(s[3])) {
5752 s[3][0] = '\0';
5753 } else {
5754 expand_expr_all(s[3], env);
5755 }
5756 if (dic_no == WNN_NO_LEARNING) {
5757 /* �ޤ��������ɤ��Ƥ��ʤ��Τǡ����ɤ��� */
5758 prio = REAL_PARAM(s[2])? atoi(s[2]) :
5759 WNN_DIC_PRIO_DEFAULT;
5760 rev = REAL_PARAM(s[4])? atoi(s[4]) : 0;
5761 /* ��ư�ؽ��μ���Ͼ���˺�� */
5762 if (((dic_no = jl_dic_add_e_body(env, s[0], NULL, rev,
5763 prio, 0, 0, NULL,
5764 NULL,
5765 (int (*)())WNN_CREATE,
5766 message_handler))
5767 == -1) && (env_wnn_errorno_eql != 0)) {
5768 if (env_wnn_errorno_eql != WNN_JSERVER_DEAD) {
5769 message_out(message_handler, "%s :%s\n", s[0],
5770 wnn_perror_lang(env->orig.lang,
5771 env));
5772 } else
5773 message_out(message_handler, "%s\n",
5774 wnn_perror_lang(env->orig.lang, env));
5775 goto _Err_happend;
5776 }
5777 js_set_autolearning_dic(env, type, dic_no);
5778 }
5779 if (!js_is_loaded_temporary_dic(env)) {
5780 /* �ޤ��ƥ�ݥ�꼭�����ɤ��Ƥ��ʤ��Τǡ�
5781 ���ɤ��� */
5782 if ((js_temporary_dic_add(env, rev) == -1) &&
5783 (env_wnn_errorno_eql != 0)){
5784 if (env_wnn_errorno_eql == WNN_NOT_SUPPORT_PACKET){
5785 message_out(message_handler,
5786 msg_get(wnn_msg_cat, 211,
5787 "You can not temporary dictionary because server's version is old.",
5788 env->orig.lang, NULL));
5789 continue;
5790 } else if (env_wnn_errorno_eql !=
5791 WNN_JSERVER_DEAD) {
5792 message_out(message_handler, "%s :%s\n", s[0],
5793 wnn_perror_lang(env->orig.lang,
5794 env));
5795 } else
5796 message_out(message_handler, "%s\n",
5797 wnn_perror_lang(env->orig.lang, env));
5798 goto _Err_happend;
5799 }
5800 }
5801 /* �ؽ��Υ⡼�ɤ����ꤹ�� */
5802 if (type == WNN_MUHENKAN_LEARNING) {
5803 henv.muhenkan_flag = mode;
5804 vmask |= WNN_ENV_MUHENKAN_LEARN_MASK;
5805 } else {
5806 henv.bunsetsugiri_flag = mode;
5807 vmask |= WNN_ENV_BUNSETSUGIRI_LEARN_MASK;
5808 }
5809 }
5810 break;
5811
5812 case 'c':
5813 if (!strcmp(code, "confirm")){
5814 confirm_state = CONFIRM;
5815 } else if (!strcmp(code, "confirm1")) {
5816 confirm_state = CONFIRM1;
5817 } else if (!strcmp(code, "create_without_confirm")) {
5818 confirm_state = CREATE_WITHOUT_CONFIRM;
5819 }
5820 break;
5821
5822 case 'f':
5823 if (!strcmp(code, "fi_hindo_kakuritu")) {
5824 /* �ף��ƣɴط����پ徺��Ψ�ؿ� */
5825 int is_wnn;
5826 HINDO_KAKURITU:
5827 if(!strcmp(code, "hindo_kakuritu")) {
5828 flag = &henv.freq_func_flag;
5829 is_wnn = 1;
5830 } else {
5831 flag = &henv.fi_freq_func_flag;
5832 is_wnn = 0;
5833 }
5834 switch (s[0][0]) {
5835 case 'n':
5836 case 'N':
5837 if(!strncmp(s[0], "not", 3) ||
5838 !strncmp(s[0], "NOT", 3)) {
5839 /* ���ٳؽ����ʤ� */
5840 *flag = WNN_HINDO_NOT;
5841 } else {
5842 /* ���̳ؽ� */
5843 *flag = WNN_HINDO_NORMAL;
5844 }
5845 break;
5846 case 'a':
5847 case 'A':
5848 /* ɬ�����ٳؽ����� */
5849 *flag = WNN_HINDO_ALWAYS;
5850 break;
5851 case 'h':
5852 case 'H':
5853 /* �����Ҥ��ؽ� */
5854 *flag = WNN_HINDO_HIGH;
5855 break;
5856 case 'l':
5857 case 'L':
5858 /* ���露��ؽ� */
5859 *flag = WNN_HINDO_LOW;
5860 break;
5861 default:
5862 goto _Err_happend;
5863 }
5864 if(is_wnn) vmask |= WNN_ENV_FREQ_FUNC_MASK;
5865 else vmask |= WNN_ENV_FI_FREQ_FUNC_MASK;
5866 break;
5867 } else if (!strcmp(code, "fukugou_yuusen")) {
5868 /* ʣ���ͥ���Ѵ� */
5869 if (num < 2) goto _Err_happend;
5870 vmask |= WNN_ENV_COMPLEX_CONV_MASK;
5871 flag = &henv.complex_flag;
5872 goto _set_flag;
5873 }
5874 break;
5875 case 'g':
5876 if (!strcmp(code, "giji_number")) {
5877 /* ���������ν��ɽ����ˡ */
5878 switch (s[0][0]) {
5879 case 'k':
5880 case 'K':
5881 if(!strcmp(s[0], "kansuuji")||
5882 !strcmp(s[0], "KANSUUJI")) {
5883 henv.numeric_flag = WNN_NUM_KANSUUJI;
5884 } else if(!strcmp(s[0], "kanold") ||
5885 !strcmp(s[0], "KANOLD")) {
5886 henv.numeric_flag = WNN_NUM_KANOLD;
5887 } else if(!strcmp(s[0], "kan") ||
5888 !strcmp(s[0], "KAN")) {
5889 henv.numeric_flag = WNN_NUM_KAN;
5890 }
5891 break;
5892 case 'h':
5893 case 'H':
5894 if(!strcmp(s[0], "hancan") ||
5895 !strcmp(s[0], "HANCAN")) {
5896 henv.numeric_flag = WNN_NUM_HANCAN;
5897 } else if(!strcmp(s[0], "han") ||
5898 !strcmp(s[0], "HAN")) {
5899 henv.numeric_flag = WNN_NUM_HAN;
5900 }
5901 break;
5902 case 'z':
5903 case 'Z':
5904 if(!strcmp(s[0], "zencan") ||
5905 !strcmp(s[0], "ZENCAN")) {
5906 henv.numeric_flag = WNN_NUM_ZENCAN;
5907 } else if(!strcmp(s[0], "zen") ||
5908 !strcmp(s[0], "ZEN")) {
5909 henv.numeric_flag = WNN_NUM_ZEN;
5910 }
5911 break;
5912 default:
5913 goto _Err_happend;
5914 }
5915 vmask |= WNN_ENV_NUMERIC_MASK;
5916 } else if (!strcmp(code, "giji_eisuu")) {
5917 /* ��������ե��٥åȤν��ɽ����ˡ */
5918 switch (s[0][0]) {
5919 case 'h':
5920 case 'H':
5921 henv.alphabet_flag = WNN_ALP_HAN;
5922 break;
5923 case 'z':
5924 case 'Z':
5925 henv.alphabet_flag = WNN_ALP_ZEN;
5926 break;
5927 default:
5928 goto _Err_happend;
5929 }
5930 vmask |= WNN_ENV_ALPHABET_MASK;
5931 } else if (!strcmp(code, "giji_kigou")) {
5932 /* ��������ν��ɽ����ˡ */
5933 switch (s[0][0]) {
5934 case 'h':
5935 case 'H':
5936 henv.symbol_flag = WNN_KIG_HAN;
5937 break;
5938 case 'j':
5939 case 'J':
5940 henv.symbol_flag = WNN_KIG_JIS;
5941 break;
5942 case 'a':
5943 case 'A':
5944 henv.symbol_flag = WNN_KIG_ASC;
5945 break;
5946 default:
5947 goto _Err_happend;
5948 }
5949 vmask |= WNN_ENV_SYMBOL_MASK;
5950 }
5951 break;
5952 case 'h':
5953 if (!strcmp(code, "hindo_kakuritu")) {
5954 goto HINDO_KAKURITU;
5955 } else if (strcmp(code, "hanyou_gakusyu") == 0) {
5956 /* ���Ѹ�ؽ� */
5957 if (num < 2) goto _Err_happend;
5958 vmask |= WNN_ENV_COMMON_LAERN_MASK;
5959 flag = &henv.common_learn_flag;
5960 goto _set_flag;
5961 }
5962 break;
5963 case 'm':
5964 if (!strcmp(code, "muhenkan_gakusyuu")) {
5965 goto AUTO_LEARNING;
5966 }
5967 break;
5968 case 'n':
5969 if (strcmp(code, "no_create") == 0){
5970 confirm_state = NO_CREATE;
5971 }
5972 break;
5973 case 'o':
5974 if (strcmp(code, "okuri_gakusyu") == 0) {
5975 /* ������ؽ� */
5976 if (num < 2) goto _Err_happend;
5977 vmask |= WNN_ENV_OKURI_LEARN_MASK;
5978 flag = &henv.okuri_learn_flag;
5979 goto _set_flag;
5980 } else if (strcmp(code, "okuri_kijun") == 0) {
5981 /* ��������� */
5982 switch (s[0][0]) {
5983 case 'r':
5984 case 'R':
5985 /* ��§ */
5986 henv.okuri_flag = WNN_OKURI_REGULATION;
5987 break;
5988 case 'n':
5989 case 'N':
5990 /* ����ʤ� */
5991 henv.okuri_flag = WNN_OKURI_NO;
5992 break;
5993 case 'y':
5994 case 'Y':
5995 /* ���� */
5996 henv.okuri_flag = WNN_OKURI_YES;
5997 break;
5998 default:
5999 goto _Err_happend;
6000 }
6001 vmask |= WNN_ENV_OKURI_MASK;
6002 }
6003 break;
6004 case 'r':
6005 if (strcmp(code, "rendaku") == 0) {
6006 /* Ϣ������ */
6007 if (num < 2) goto _Err_happend;
6008 vmask |= WNN_ENV_RENDAKU_MASK;
6009 flag = &henv.rendaku_flag;
6010 goto _set_flag;
6011 }
6012 break;
6013 case 's':
6014 if (!strcmp(code, "setdic")){
6015 /* dic_add */
6016 int rdonly, hrdonly;
6017 expand_expr_all(s[0], env);
6018 if(num < 3 || !REAL_PARAM(s[1])){
6019 s[1][0] = 0;
6020 }else{
6021 expand_expr_all(s[1], env);
6022 }
6023 prio = (num >= 4 && REAL_PARAM(s[2]))? atoi(s[2]) :
6024 WNN_DIC_PRIO_DEFAULT;
6025 rdonly = (num >= 5 && REAL_PARAM(s[3]))? atoi(s[3]) : 0;
6026 hrdonly = (num >= 6 && REAL_PARAM(s[4]))? atoi(s[4]) : 0;
6027 if(num < 7 || !REAL_PARAM(s[5])) s[5][0] = 0;
6028 if(num < 8 || !REAL_PARAM(s[6])) s[6][0] = 0;
6029 rev = (num >= 9 && REAL_PARAM(s[7]))? atoi(s[7]) : 0;
6030
6031 switch (confirm_state) {
6032 case CONFIRM:
6033 case CONFIRM1:
6034 error_handler1 = error_handler;
6035 break;
6036 case CREATE_WITHOUT_CONFIRM:
6037 error_handler1 = (int (*)())WNN_CREATE;
6038 break;
6039 case NO_CREATE:
6040 error_handler1 = (int (*)())WNN_NO_CREATE;
6041 break;
6042 }
6043
6044 if((jl_dic_add_e_body(env, s[0], s[1], rev, prio, rdonly,
6045 hrdonly, s[5], s[6], error_handler1,
6046 message_handler) == -1)
6047 && (env_wnn_errorno_eql != 0)) {
6048 if (env_wnn_errorno_eql != WNN_JSERVER_DEAD)
6049 message_out(message_handler, "%s (%s) :%s\n",
6050 s[0], s[1], wnn_perror_lang(env->orig.lang,
6051 env));
6052 else
6053 message_out(message_handler, "%s\n",
6054 wnn_perror_lang(env->orig.lang, env));
6055 goto _Err_happend;
6056 }
6057 break;
6058 }else if (!strcmp(code, "setfuzokugo") ||
6059 !strcmp(code, "setgrammar")) {
6060 /* fuzokugo_set */
6061 expand_expr_all(s[0], env);
6062 if(jl_fuzokugo_set_e_body(env,s[0]) == -1){
6063 if (env_wnn_errorno_eql != WNN_JSERVER_DEAD)
6064 message_out(message_handler, "%s :%s\n", s[0],
6065 wnn_perror_lang(env->orig.lang, env));
6066 else
6067 message_out(message_handler, "%s\n",
6068 wnn_perror_lang(env->orig.lang, env));
6069 goto _Err_happend;
6070 }
6071 break;
6072 } else if (!strcmp(code, "setparam")){
6073 struct wnn_param para;
6074 /* setparam --- set parameter */
6075 change_ascii_to_int(s[0], ¶.n);
6076 change_ascii_to_int(s[1], ¶.nsho);
6077 change_ascii_to_int(s[2], ¶.p1);
6078 change_ascii_to_int(s[3], ¶.p2);
6079 change_ascii_to_int(s[4], ¶.p3);
6080 change_ascii_to_int(s[5], ¶.p4);
6081 change_ascii_to_int(s[6], ¶.p5);
6082 change_ascii_to_int(s[7], ¶.p6);
6083 change_ascii_to_int(s[8], ¶.p7);
6084 change_ascii_to_int(s[9], ¶.p8);
6085 change_ascii_to_int(s[10], ¶.p9);
6086 change_ascii_to_int(s[11], ¶.p10);
6087 change_ascii_to_int(s[12], ¶.p11);
6088 change_ascii_to_int(s[13], ¶.p12);
6089 change_ascii_to_int(s[14], ¶.p13);
6090 change_ascii_to_int(s[15], ¶.p14);
6091 change_ascii_to_int(s[16], ¶.p15);
6092
6093 if (js_param_set(env,¶) < 0) {
6094 fclose(fp);
6095 LockMutex(&msg_lock);
6096 message_out(message_handler,
6097 msg_get(wnn_msg_cat, 208, NULL,
6098 env->orig.lang, NULL), wnnrc_n);
6099 /*
6100 * "�ե����� \"%s\" �ǴĶ�������ˡ����顼��ȯ������
6101 * ����ˡ��������ߤ��ޤ���\n",
6102 */
6103 UnlockMutex(&msg_lock);
6104 env_wnn_errorno_copy(env);
6105 if_dead_disconnect(env);
6106 return(-1);
6107 }
6108 break;
6109 } else if (!strcmp(code, "saisyu_siyou")) {
6110 /* �ǽ����Ѻ�ͥ�� */
6111 if (num < 2) goto _Err_happend;
6112 vmask |= WNN_ENV_LAST_IS_FIRST_MASK;
6113 flag = &henv.last_is_first_flag;
6114 goto _set_flag;
6115 } else if (!strcmp(code, "settou_gakusyu")) {
6116 /* ��Ƭ��ؽ� */
6117 if (num < 2) goto _Err_happend;
6118 vmask |= WNN_ENV_PREFIX_LEARN_MASK;
6119 flag = &henv.prefix_learn_flag;
6120 goto _set_flag;
6121 } else if (!strcmp(code, "settou_kouho")) {
6122 /* ��Ƭ����� */
6123 switch (s[0][0]) {
6124 case 'h':
6125 case 'H':
6126 /* �Ҥ餬�ʡʤ���*/
6127 vmask |= WNN_ENV_PREFIX_MASK;
6128 henv.prefix_flag = WNN_KANA_KOUHO;
6129 break;
6130 case 'k':
6131 case 'K':
6132 /* �����ʸ��*/
6133 vmask |= WNN_ENV_PREFIX_MASK;
6134 henv.prefix_flag = WNN_KANJI_KOUHO;
6135 break;
6136 default:
6137 break;
6138 }
6139 break;
6140 } else if (strcmp(code, "setubi_gakusyu") == 0) {
6141 /* ������ؽ� */
6142 if (num < 2) goto _Err_happend;
6143 vmask |= WNN_ENV_SUFFIX_LEARN_MASK;
6144 flag = &henv.suffix_learn_flag;
6145 goto _set_flag;
6146 /*
6147 * Hideyuki Kishiba (Jul. 12, 1994)
6148 * �ƣɴط������ƥ༭��ȣƣɴط��桼�����������
6149 */
6150 } else if (strcmp(code, "set_fi_system_dic") == 0) {
6151 char nul = 0;
6152 int hrdonly;
6153 /* �ե�����̾�� @, ~ ��Ÿ������ */
6154 expand_expr_all(s[0], env);
6155 if(num < 3 || !REAL_PARAM(s[1])){
6156 s[1][0] = 0;
6157 }else{
6158 expand_expr_all(s[1], env);
6159 }
6160 /* �ƣɴط����٤� R_ONLY or R/W ���� */
6161 hrdonly = (num >= 4 && REAL_PARAM(s[2]))? atoi(s[2]) : WNN_DIC_RDONLY;
6162 /* �ƣɴط����٤Υѥ���ɥե����� */
6163 if(num < 5 || !REAL_PARAM(s[3])) s[3][0] = 0;
6164
6165 switch (confirm_state) {
6166 case CONFIRM:
6167 case CONFIRM1:
6168 error_handler1 = error_handler;
6169 break;
6170 case CREATE_WITHOUT_CONFIRM:
6171 error_handler1 = (int (*)())WNN_CREATE;
6172 break;
6173 case NO_CREATE:
6174 error_handler1 = (int (*)())WNN_NO_CREATE;
6175 break;
6176 }
6177
6178 if((jl_fi_dic_add_e_body(env, s[0], s[1],
6179 WNN_FI_SYSTEM_DICT,
6180 WNN_DIC_RDONLY,
6181 hrdonly, &nul, s[3],
6182 error_handler1, message_handler)
6183 == -1) && (env_wnn_errorno_eql != 0)) {
6184 if (env_wnn_errorno_eql != WNN_JSERVER_DEAD)
6185 message_out(message_handler, "%s (%s) :%s\n",
6186 s[0], s[1], wnn_perror_lang(env->orig.lang,
6187 env));
6188 else
6189 message_out(message_handler, "%s\n",
6190 wnn_perror_lang(env->orig.lang, env));
6191 goto _Err_happend;
6192 }
6193 } else if (!strcmp(code, "set_fi_user_dic")) {
6194 int rdonly, hrdonly;
6195 /* �ե�����̾�� @, ~ ��Ÿ������ */
6196 expand_expr_all(s[0], env);
6197 /* �ƣɴط������ R_ONLY or R/W ���� */
6198 rdonly = (num >= 3 && REAL_PARAM(s[1]))? atoi(s[1]) : WNN_DIC_RDONLY;
6199 /* �ƣɴط�����Υѥ���ɥե����� */
6200 if(num < 4 || !REAL_PARAM(s[2])) s[2][0] = 0;
6201
6202 switch (confirm_state) {
6203 case CONFIRM:
6204 case CONFIRM1:
6205 error_handler1 = error_handler;
6206 break;
6207 case CREATE_WITHOUT_CONFIRM:
6208 error_handler1 = (int (*)())WNN_CREATE;
6209 break;
6210 case NO_CREATE:
6211 error_handler1 = (int (*)())WNN_NO_CREATE;
6212 break;
6213 }
6214
6215 if((jl_fi_dic_add_e_body(env, s[0], NULL, WNN_FI_USER_DICT,
6216 rdonly, WNN_DIC_RDONLY, s[2], NULL,
6217 error_handler1, message_handler)
6218 == -1) && (env_wnn_errorno_eql != 0)) {
6219 if (env_wnn_errorno_eql != WNN_JSERVER_DEAD)
6220 message_out(message_handler, "%s (%s) :%s\n",
6221 s[0], s[1], wnn_perror_lang(env->orig.lang,
6222 env));
6223 else
6224 message_out(message_handler, "%s\n",
6225 wnn_perror_lang(env->orig.lang, env));
6226 goto _Err_happend;
6227 }
6228 henv.fi_relation_learn_flag = rdonly;
6229 vmask |= WNN_ENV_FI_RELATION_LEARN_MASK;
6230 }
6231 break;
6232 case 'u':
6233 if (!strcmp(code, "use_hinsi") ||
6234 !strcmp(code, "unuse_hinsi")) {
6235 /* �Ѵ����ѡ��Ի����ʻ� */
6236 int ii, *hlist, nhinsi = num - 1;
6237 w_char whname[64];
6238 if(nhinsi) {
6239 if(!(hlist = (int *)malloc(nhinsi * sizeof(int))))
6240 goto _Err_happend;
6241 for(ii = 0; ii < nhinsi; ii++) {
6242 _Sstrcpy(whname, s[ii]);
6243 if((hlist[ii] =
6244 jl_hinsi_number_e_body(env, whname)) == -1) {
6245 free((char *)hlist);
6246 goto _Err_happend;
6247 }
6248 }
6249 if(strcmp(code, "unuse_hinsi") == 0) nhinsi *= -1;
6250 if(js_set_henkan_hinsi(env, 1, nhinsi, hlist) < 0) {
6251 free((char *)hlist);
6252 goto _Err_happend;
6253 }
6254 free((char *)hlist);
6255 }
6256 }
6257 break;
6258 case 'y':
6259 if (strcmp(code, "yuragi") == 0) {
6260 /* Ĺ�����ɤ����� */
6261 if (num < 2) goto _Err_happend;
6262 vmask |= WNN_ENV_YURAGI_MASK;
6263 flag = &henv.yuragi_flag;
6264 goto _set_flag;
6265 }
6266 break;
6267 }
6268 continue;
6269 _set_flag:
6270 switch (s[0][0]) {
6271 case 't':
6272 case 'T':
6273 *flag = True;
6274 break;
6275 case 'f':
6276 case 'F':
6277 *flag = False;
6278 break;
6279 default:
6280 goto _Err_happend;
6281 }
6282 }
6283 }
6284 if(vmask) {
6285 if(js_set_henkan_env(env, vmask, &henv) < 0) goto _Err_happend;
6286 }
6287 fclose(fp);
6288 return(0);
6289
6290 _Err_happend:
6291 LockMutex(&msg_lock);
6292 message_out(message_handler, "%s set Error!!\n", code);
6293 message_out(message_handler,
6294 msg_get(wnn_msg_cat, 208, NULL, env->orig.lang, NULL),
6295 wnnrc_n);
6296 /*
6297 * "�ե����� \"%s\" �ǴĶ�������ˡ����顼��ȯ����������ˡ�
6298 * �������ߤ��ޤ���\n",
6299 */
6300 UnlockMutex(&msg_lock);
6301 fclose(fp);
6302 return(-1);
6303 }
6304 int
jl_set_env_wnnrc1(env,wnnrc_n,error_handler,message_handler,level)6305 jl_set_env_wnnrc1(env, wnnrc_n, error_handler, message_handler, level)
6306 register struct wnn_env *env;
6307 char *wnnrc_n;
6308 int (*error_handler)(), (*message_handler)();
6309 int level;
6310 {
6311 int x;
6312
6313 if(!env) return(-1);
6314 LockMutex(&ENV_LOCK(env));
6315 env_wnn_errorno_set = 0;
6316 x = jl_set_env_wnnrc1_body((WNN_ENV_INT *)env, wnnrc_n, error_handler, message_handler, level, 0);
6317 UnlockMutex(&ENV_LOCK(env));
6318 return x;
6319 }
6320
6321 static int
expand_expr_all(s,env)6322 expand_expr_all(s, env)
6323 struct wnn_env_int *env;
6324 register char *s;
6325 {
6326 register char *c;
6327
6328 for(c = s; *c; c++){
6329 if(*c == '~' || *c == '@'){
6330 if(expand_expr(c, env) == -1) return(-1);
6331 }
6332 }
6333 return(0);
6334 }
6335
6336 /* copy of js.c */
6337 static char *
getlogname()6338 getlogname()
6339 {
6340 extern struct passwd *getpwuid();
6341 struct passwd *p;
6342
6343 if ((p = getpwuid(getuid())) == NULL)
6344 return(NULL);
6345 return(p->pw_name);
6346 }
6347
6348
6349 static int
expand_expr(s,env)6350 expand_expr(s, env)
6351 struct wnn_env_int *env;
6352 /** ~user��@HOME��@LIBDIR @ENV @USR ��Ÿ��(â����ʸ�������Ƭ�Τ�)��
6353 �Ǥ��ʤ�����-1��
6354 �֤ꡢ���ξ��s����Ȥ��塹�Ȥ��Τޤ�ޡ�s��Ĺ����256�Ȳ��ꤷ�Ƥ롣*/
6355 register char *s;
6356 {
6357 char *p, *s1;
6358 char tmp[EXPAND_PATH_LENGTH];
6359 char buf[EXPAND_PATH_LENGTH];
6360 int noerr, expandsuc;
6361 struct passwd *u;
6362 extern char *getenv();
6363 extern struct passwd *getpwnam();
6364 #ifdef SYSVR2
6365 #ifndef AIXV3
6366 extern char * strchr();
6367 #endif /* AIXV3 */
6368 #endif
6369
6370 if(*s != '~' && *s != '@') return(0);
6371 if((int)strlen(s) >= EXPAND_PATH_LENGTH) return(-1);
6372
6373 s1 = s;
6374 #ifdef BSD42
6375 if(NULL != (p = index(++s1, '/'))){
6376 #else
6377 if(NULL != (p = strchr(++s1, '/'))){
6378 #endif
6379 strcpy(tmp, p);
6380 *p = '\0';
6381 } else *tmp = '\0';
6382 /* �����ޤǤϽ�����s����Ƭ��s1�ģ�ʸ���ܡ�p�ĺǽ��'/'�Τ��ä��Ȥ���
6383 �ʤ����ǰ�ö�ڤ�ˡ�tmp�Ĥ���ʸ�Υ��ԡ���*/
6384
6385 if(*s == '~'){
6386 if(*s1){
6387 noerr = expandsuc =
6388 (NULL != (u = getpwnam(s1)) &&
6389 (int)strlen(p = u -> pw_dir) + (int)strlen(tmp) <
6390 EXPAND_PATH_LENGTH );
6391
6392 } else {
6393 noerr = expandsuc =
6394 (NULL != (p = getenv("HOME")) &&
6395 (int)strlen(p) + (int)strlen(tmp) < EXPAND_PATH_LENGTH);
6396 }
6397
6398 } else { /* then, *s must be '@' */
6399 if(!strcmp(s1, "HOME")){
6400 noerr = expandsuc =
6401 (NULL != (p = getenv("HOME")) &&
6402 (int)strlen(p) + (int)strlen(tmp) < EXPAND_PATH_LENGTH);
6403 }else if(!strcmp(s1, "WNN_DIC_DIR")){
6404 noerr = expandsuc =
6405 (NULL != (p = getenv("HOME")) &&
6406 (int)strlen(p) + (int)strlen(tmp) < EXPAND_PATH_LENGTH);
6407 if (expandsuc) {
6408 strcpy(buf, p);
6409 if (strlen(buf) + strlen("/") < sizeof(buf)) {
6410 strcat(buf, "/");
6411 p = getenv("WNN_DIC_DIR");
6412 if (!p)
6413 p = "Wnn";
6414 if (strlen(buf) + strlen(p) < sizeof(buf)) {
6415 strcat(buf, p);
6416 p = buf;
6417 } else
6418 noerr = expandsuc = 0;
6419 } else
6420 noerr = expandsuc = 0;
6421 }
6422 } else if (!strcmp(s1, "LIBDIR")){
6423 noerr = expandsuc =
6424 ((int)strlen(p= LIBDIR)+ (int)strlen(tmp) < EXPAND_PATH_LENGTH);
6425 } else if (!strcmp(s1, "ENV")){ /* Added */
6426 noerr = expandsuc =
6427 (NULL != (p = env_name(env)) &&
6428 (int)strlen(p)+ (int)strlen(tmp) < EXPAND_PATH_LENGTH);
6429 }else if (!strcmp(s1, "USR")){
6430 noerr = expandsuc =
6431 (NULL != (p = getlogname()) &&
6432 (int)strlen(p)+ (int)strlen(tmp) < EXPAND_PATH_LENGTH);
6433 } else { /* @HOME, @LIBDIR @ENV igai ha kaenai */
6434 noerr = 1; expandsuc = 0;
6435 }
6436 }
6437
6438 if(expandsuc) strcpy(s, p);
6439 strcat(s, tmp);
6440 return(noerr ? 0 : -1);
6441 }
6442
6443 static int
change_ascii_to_int(st,dp)6444 change_ascii_to_int(st,dp)
6445 register char *st;
6446 int *dp;
6447 {
6448 register int total,flag;
6449
6450 total = 0;
6451 flag = 0;
6452 while(*st != NULL){
6453 if (isdigit(*st)){
6454 total = total * 10 + (*st - '0');
6455 } else if (*st == '+') {
6456 if (flag != 0) { return(-1); }
6457 flag = 1;
6458 } else if (*st == '-') {
6459 if (flag != 0) { return(-1); }
6460 flag = -1;
6461 } else { return(-1); }
6462 st++;
6463 }
6464 if (flag == 0){
6465 flag = 1;
6466 }
6467 *dp = total * flag;
6468 return(1);
6469 }
6470
6471 static int
file_exist(env,n)6472 file_exist(env, n)
6473 struct wnn_env_int *env;
6474 char *n;
6475 {
6476 if(n[0] == C_LOCAL){
6477 return(access(n + 1, 4));
6478 }else{
6479 return(js_access(env,n,4));
6480 }
6481 }
6482
6483 static int
create_file(env,n,d,fid,pwd_dic,pwd_hindo,error_handler,message_handler)6484 create_file(env,n, d, fid, pwd_dic, pwd_hindo, error_handler, message_handler)
6485 register struct wnn_env_int *env;
6486 char *n;
6487 int d;
6488 int fid;
6489 char *pwd_dic, *pwd_hindo;
6490 int (*error_handler)(), (*message_handler)();
6491 {
6492 char pwd[WNN_PASSWD_LEN], hpwd[WNN_PASSWD_LEN];
6493 int rev_dict_type;
6494 int x; /* result for creating file Hideyuki Kishiba (Jul. 7, 1994) */
6495
6496 if(
6497 make_dir_rec1(env, n, error_handler, message_handler) == -1){
6498 env_wnn_errorno_set = WNN_MKDIR_FAIL;
6499 return(-1);
6500 }
6501 if(d == HINDO || d == FI_HINDO){
6502 /*
6503 * Hideyuki Kishiba (Jul. 7, 1994)
6504 * �ƣɴط����٤κ����������ɲ�
6505 */
6506 if(create_pwd_file(env, pwd_hindo, error_handler, message_handler) == -1)return(-1);
6507 if(get_pwd(pwd_hindo, hpwd, env) == -1)return(-1);
6508 if(n[0] == C_LOCAL){
6509 /*
6510 * Hideyuki Kishiba (Jul. 7, 1994)
6511 * ���饤�����¦�����٥ե�������������
6512 */
6513 if(d == HINDO)
6514 x = js_hindo_file_create_client(env, fid, n + 1, NULL, hpwd);
6515 else
6516 x = js_fi_hindo_file_create_client(env, fid, n + 1, NULL, hpwd);
6517
6518 if(x == -1){
6519 message_out(message_handler, wnn_perror_lang(env->orig.lang, env));
6520 if_dead_disconnect(env);
6521 return(-1);
6522 }else{
6523 LockMutex(&msg_lock);
6524 message_out(message_handler,
6525 "%s \"%s\" %s",
6526 msg_get(wnn_msg_cat, 203, NULL, env->orig.lang, NULL),
6527 n,
6528 msg_get(wnn_msg_cat, 209, NULL, env->orig.lang, NULL));
6529 /*
6530 "���٥ե����� \"%s\" ����ޤ�����",
6531 */
6532 UnlockMutex(&msg_lock);
6533 chown(n + 1, getuid(), -1); /* H.T. */
6534 return(0);
6535 }
6536 }else{
6537 /*
6538 * Hideyuki Kishiba (Jul. 7, 1994)
6539 * ������¦�����٥ե�������������
6540 */
6541 if(d == HINDO)
6542 x = js_hindo_file_create(env, fid, n, NULL, hpwd);
6543 else
6544 x = js_fi_hindo_file_create(env, fid, n, NULL, hpwd);
6545
6546 if(x == -1){
6547 message_out(message_handler, wnn_perror_lang(env->orig.lang, env));
6548 if_dead_disconnect(env);
6549 return(-1);
6550 }else{
6551 LockMutex(&msg_lock);
6552 message_out(message_handler,
6553 "%s \"%s\" %s",
6554 msg_get(wnn_msg_cat, 203, NULL, env->orig.lang, NULL),
6555 n,
6556 msg_get(wnn_msg_cat, 209, NULL, env->orig.lang, NULL));
6557 /*
6558 "���٥ե����� \"%s\" ����ޤ�����",
6559 */
6560 UnlockMutex(&msg_lock);
6561 return(0);
6562 }
6563 }
6564 } else {
6565 if(create_pwd_file(env, pwd_hindo, error_handler, message_handler) == -1)return(-1);
6566 if(get_pwd(pwd_hindo, hpwd, env) == -1)return(-1);
6567 if(create_pwd_file(env, pwd_dic, error_handler, message_handler) == -1)return(-1);
6568 if(get_pwd(pwd_dic, pwd, env) == -1)return(-1);
6569
6570 /*
6571 * Hideyuki Kishiba (Jul. 7, 1994)
6572 * �ƣɴط�����κ����������ɲ�
6573 */
6574 if(d == JISHO) {
6575 #ifdef CONVERT_with_SiSheng
6576 if(!strncmp(js_get_lang(env), WNN_C_LANG, 5) ||
6577 !strncmp(js_get_lang(env), WNN_T_LANG, 5))
6578 rev_dict_type = CWNN_REV_DICT;
6579 else
6580 #endif
6581 /* Hideyuki Kishiba (Dec. 3, 1994)
6582 dic_add ���� rw �ե饰�ˤ�ꡢ���롼�����ޡ��������
6583 ������Ԥ��褦�ˤ��� */
6584 {
6585 if(fid == WNN_DIC_GROUP)
6586 rev_dict_type = WNN_GROUP_DICT;
6587 else if(fid == WNN_DIC_MERGE)
6588 rev_dict_type = WNN_MERGE_DICT;
6589 else
6590 rev_dict_type = WNN_REV_DICT;
6591 }
6592 } else
6593 rev_dict_type = WNN_FI_USER_DICT;
6594
6595 if(n[0] == C_LOCAL){
6596 if(js_dic_file_create_client(env, n + 1, rev_dict_type,
6597 NULL, pwd, hpwd) == -1){
6598 message_out(message_handler, wnn_perror_lang(env->orig.lang, env));
6599 if_dead_disconnect(env);
6600 return(-1);
6601 }else{
6602 LockMutex(&msg_lock);
6603 message_out(message_handler,
6604 "%s \"%s\" %s",
6605 msg_get(wnn_msg_cat, 200, NULL, env->orig.lang, NULL),
6606 n,
6607 msg_get(wnn_msg_cat, 209, NULL, env->orig.lang, NULL));
6608 /*
6609 "����ե����� \"%s\" ����ޤ�����",
6610 */
6611 UnlockMutex(&msg_lock);
6612 chown(n + 1, getuid(), -1);
6613 return(0);
6614 }
6615 }else{
6616 if(js_dic_file_create(env, n, rev_dict_type, NULL, pwd, hpwd)== -1){
6617 message_out(message_handler, wnn_perror_lang(env->orig.lang, env));
6618 if_dead_disconnect(env);
6619 return(-1);
6620 }else{
6621 LockMutex(&msg_lock);
6622 message_out(message_handler,
6623 "%s \"%s\" %s",
6624 msg_get(wnn_msg_cat, 200, NULL, env->orig.lang, NULL),
6625 n,
6626 msg_get(wnn_msg_cat, 209, NULL, env->orig.lang, NULL));
6627 /*
6628 "����ե����� \"%s\" ����ޤ�����",
6629 */
6630 UnlockMutex(&msg_lock);
6631 return(0);
6632 }
6633 }
6634 }
6635 }
6636
6637 static int
make_dir_rec1(env,path,error_handler,message_handler)6638 make_dir_rec1(env, path, error_handler, message_handler)
6639 struct wnn_env_int *env;
6640 register char *path;
6641 int (*error_handler)(), (*message_handler)();
6642 {
6643 char gomi[128];
6644 register char *c;
6645 for(c = path;*c;c++){
6646 if(*c == '/'){
6647 strncpy(gomi,path,c - path);
6648 gomi[c - path] = 0;
6649 if(make_dir1(env, gomi, error_handler, message_handler) == -1){
6650 return(-1);
6651 }
6652 }
6653 }
6654 return(0);
6655 }
6656
6657 static int
make_dir1(env,dirname,error_handler,message_handler)6658 make_dir1(env, dirname, error_handler, message_handler)
6659 register struct wnn_env_int *env;
6660 register char *dirname;
6661 int (*error_handler)(), (*message_handler)();
6662 {
6663 char gomi[128];
6664 if(dirname[0] == C_LOCAL){
6665 if(*(dirname + 1) == 0) return(0);
6666 if(access(dirname + 1 , 0) == 0){ /* check for existence */
6667 return(0); /* dir already exists */
6668 }
6669 }else{
6670 if(*dirname == 0) return(0);
6671 if(js_access(env, dirname , 0) == 0){ /* check for existence */
6672 return(0); /* dir already exists */
6673 }
6674 }
6675 if((int)error_handler != WNN_CREATE){
6676 LockMutex(&msg_lock);
6677 sprintf(gomi, "%s \"%s\" %s%s",
6678 msg_get(wnn_msg_cat, 210, NULL, env->orig.lang, NULL),
6679 dirname,
6680 msg_get(wnn_msg_cat, 201, NULL, env->orig.lang, NULL),
6681 msg_get(wnn_msg_cat, 202, NULL, env->orig.lang, NULL));
6682 /*
6683 "directry \"%s\" ��̵���衣���?(Y/N)",
6684 */
6685 UnlockMutex(&msg_lock);
6686 if(call_error_handler(error_handler,gomi, env) == 0){
6687 env_wnn_errorno_set = WNN_MKDIR_FAIL;
6688 return(-1);
6689 }
6690 }
6691 if(dirname[0] == C_LOCAL){ /* Create Directory */
6692 #define MODE (0000000 | 0000777)
6693 uid_t euid;
6694 int ret;
6695
6696 euid = geteuid();
6697 seteuid(getuid());
6698 ret = mkdir(dirname + 1 , MODE );
6699 seteuid(euid);
6700 if (ret != 0 ) {
6701 env_wnn_errorno_set=WNN_MKDIR_FAIL;
6702 return(-1);
6703 }
6704 }else{
6705 if(js_mkdir(env, dirname)){
6706 if_dead_disconnect(env);
6707 return(-1);
6708 }
6709 }
6710 return(0);
6711 }
6712
6713
6714 static int
6715 call_error_handler(error_handler, c, env)
6716 int (*error_handler)();
6717 char *c;
6718 ARGS *env;
6719 {
6720 register int x;
6721 x = error_handler(c);
6722 if(confirm_state == CONFIRM1){
6723 if(x) confirm_state = CREATE_WITHOUT_CONFIRM;
6724 else confirm_state = NO_CREATE;
6725 }
6726 return(x);
6727 }
6728
6729 static void
6730 message_out(message_handler, format, s1, s2, s3, s4, s5, s6, s7, s8)
6731 int (*message_handler)();
6732 char *format;
6733 char *s1, *s2, *s3, *s4, *s5, *s6, *s7, *s8;
6734 {
6735 char buf[256];
6736
6737 if(message_handler){
6738 sprintf(buf, format, s1, s2, s3, s4, s5, s6, s7, s8);
6739 (*message_handler)(buf);
6740 }
6741 }
6742
6743 static int
jl_yomi_len_body(buf,bun_no,bun_no2)6744 jl_yomi_len_body(buf, bun_no, bun_no2)
6745 struct wnn_buf_mt *buf;
6746 register int bun_no, bun_no2;
6747 {
6748 register int len = 0;
6749
6750 if(bun_no2 >= buf->orig.bun_suu || bun_no2 < 0)
6751 bun_no2 = buf->orig.bun_suu;
6752 for(;bun_no < bun_no2;bun_no++){
6753 len += buf->orig.bun[bun_no]->yomilen;
6754 }
6755 return(len);
6756 }
6757
6758 int
jl_yomi_len(buf,bun_no,bun_no2)6759 jl_yomi_len(buf, bun_no, bun_no2)
6760 struct wnn_buf *buf;
6761 register int bun_no, bun_no2;
6762 {
6763 int x;
6764
6765 if(!buf) return(0);
6766 LockMutex(&BUF_LOCK(buf));
6767 buf_wnn_errorno_set = 0;
6768 x = jl_yomi_len_body((WNN_BUF_MT *)buf, bun_no, bun_no2);
6769 UnlockMutex(&BUF_LOCK(buf));
6770 return x;
6771 }
6772
6773 int
jl_kanji_len(buf,bun_no,bun_no2)6774 jl_kanji_len(buf, bun_no, bun_no2)
6775 struct wnn_buf *buf;
6776 register int bun_no, bun_no2;
6777 {
6778 register int len = 0;
6779
6780 if(!buf) return(0);
6781 LockMutex(&BUF_LOCK(buf));
6782 buf_wnn_errorno_set = 0;
6783 if(bun_no < 0) {
6784 UnlockMutex(&BUF_LOCK(buf));
6785 return(0);
6786 }
6787 if(bun_no2 >= buf->bun_suu || bun_no2 < 0)
6788 bun_no2 = buf->bun_suu;
6789 for(;bun_no < bun_no2;bun_no++){
6790 len += buf->bun[bun_no]->kanjilen;
6791 }
6792 UnlockMutex(&BUF_LOCK(buf));
6793 return(len);
6794 }
6795
6796 int wnn_word_use_initial_hindo = 0;
6797
6798 static int
jl_word_use_e_body(env,dic_no,entry)6799 jl_word_use_e_body(env, dic_no, entry)
6800 register struct wnn_env_int *env;
6801 int dic_no, entry;
6802 {
6803 register struct wnn_jdata *jd;
6804
6805 if(js_word_info(env,dic_no,entry, &env_rb) == -1) {
6806 env_wnn_errorno_copy(env);
6807 if_dead_disconnect(env);
6808 return(-1);
6809 }
6810 jd = (struct wnn_jdata *)(env_rb.buf);
6811 if(jd->hindo != -1){
6812 if(js_hindo_set(env, dic_no, entry,WNN_IMA_OFF, WNN_ENTRY_NO_USE) == -1) {
6813 env_wnn_errorno_copy(env);
6814 if_dead_disconnect(env);
6815 return(-1);
6816 }
6817 }else{
6818 if(js_hindo_set(env, dic_no, entry,
6819 (wnn_word_use_initial_hindo & 0x80) ?
6820 WNN_IMA_ON : WNN_IMA_OFF ,
6821 wnn_word_use_initial_hindo & 0x7f) == -1) {
6822 env_wnn_errorno_copy(env);
6823 if_dead_disconnect(env);
6824 return(-1);
6825 }
6826 }
6827 return(0);
6828 }
6829
6830 int
jl_word_use_e(env,dic_no,entry)6831 jl_word_use_e(env, dic_no, entry)
6832 register struct wnn_env *env;
6833 int dic_no, entry;
6834 {
6835 int x;
6836
6837 if(!env) return(-1);
6838 LockMutex(&ENV_LOCK(env));
6839 env_wnn_errorno_set = 0;
6840 x = jl_word_use_e_body((WNN_ENV_INT *)env, dic_no, entry);
6841 UnlockMutex(&ENV_LOCK(env));
6842 return x;
6843 }
6844
6845 int
jl_word_use(buf,dic_no,entry)6846 jl_word_use(buf, dic_no, entry)
6847 register struct wnn_buf *buf;
6848 int dic_no, entry;
6849 {
6850 int x;
6851
6852 if(!buf || !(buf->env)) return(-1);
6853 LockMutex(&BUF_LOCK(buf));
6854 LockMutex(&(envmt->env_lock));
6855 buf_wnn_errorno_set = 0;
6856 x = jl_word_use_e_body((WNN_ENV_INT *)buf->env, dic_no, entry);
6857 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
6858 UnlockMutex(&(envmt->env_lock));
6859 UnlockMutex(&BUF_LOCK(buf));
6860 return x;
6861 }
6862
6863 void
jl_env_set(buf,env)6864 jl_env_set(buf, env)
6865 register struct wnn_env *env;
6866 register struct wnn_buf *buf;
6867 {
6868 if(!buf) return;
6869 LockMutex(&BUF_LOCK(buf));
6870 buf_wnn_errorno_set = 0;
6871 buf->env = env;
6872 UnlockMutex(&BUF_LOCK(buf));
6873 }
6874
6875
6876 struct wnn_env *
jl_env_get(buf)6877 jl_env_get(buf)
6878 register struct wnn_buf *buf;
6879 {
6880 struct wnn_env *x;
6881
6882 if(!buf) return(NULL);
6883 LockMutex(&BUF_LOCK(buf));
6884 buf_wnn_errorno_set = 0;
6885 x = buf->env;
6886 UnlockMutex(&BUF_LOCK(buf));
6887 return x;
6888 }
6889
6890 static int
jl_param_set_e_body(env,para)6891 jl_param_set_e_body(env, para)
6892 register struct wnn_env_int *env;
6893 struct wnn_param *para;
6894 {
6895 register int x;
6896
6897 if((x = js_param_set(env, para)) == -1) {
6898 env_wnn_errorno_copy(env);
6899 if_dead_disconnect(env);
6900 return(-1);
6901 }
6902 return (x);
6903 }
6904
6905 int
jl_param_set_e(env,para)6906 jl_param_set_e(env, para)
6907 register struct wnn_env *env;
6908 struct wnn_param *para;
6909 {
6910 int x;
6911
6912 if(!env) return(-1);
6913 LockMutex(&ENV_LOCK(env));
6914 env_wnn_errorno_set = 0;
6915 x = jl_param_set_e_body((WNN_ENV_INT *)env, para);
6916 UnlockMutex(&ENV_LOCK(env));
6917 return x;
6918 }
6919
6920 int
jl_param_set(buf,para)6921 jl_param_set(buf, para)
6922 register struct wnn_buf *buf;
6923 struct wnn_param *para;
6924 {
6925 int x;
6926
6927 if(!buf || !(buf->env)) return(-1);
6928 LockMutex(&BUF_LOCK(buf));
6929 LockMutex(&(envmt->env_lock));
6930 buf_wnn_errorno_set = 0;
6931 x = jl_param_set_e_body((WNN_ENV_INT *)buf->env, para);
6932 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
6933 UnlockMutex(&(envmt->env_lock));
6934 UnlockMutex(&BUF_LOCK(buf));
6935 return x;
6936 }
6937
6938 static int
jl_set_henkan_env_e_body(env,valuemask,henv)6939 jl_set_henkan_env_e_body(env, valuemask, henv)
6940 register struct wnn_env_int *env;
6941 unsigned long valuemask;
6942 struct wnn_henkan_env *henv;
6943 {
6944 register int x;
6945
6946 if((x = js_set_henkan_env(env, valuemask, henv)) == -1) {
6947 env_wnn_errorno_copy(env);
6948 if_dead_disconnect(env);
6949 return(-1);
6950 }
6951 return (x);
6952 }
6953
6954 int
jl_set_henkan_env_e(env,valuemask,henv)6955 jl_set_henkan_env_e(env, valuemask, henv)
6956 register struct wnn_env *env;
6957 unsigned long valuemask;
6958 struct wnn_henkan_env *henv;
6959 {
6960 int x;
6961
6962 if(!env) return(-1);
6963 LockMutex(&ENV_LOCK(env));
6964 env_wnn_errorno_set = 0;
6965 x = jl_set_henkan_env_e_body((WNN_ENV_INT *)env, valuemask, henv);
6966 UnlockMutex(&ENV_LOCK(env));
6967 return x;
6968 }
6969
6970 int
jl_set_henkan_env(buf,valuemask,henv)6971 jl_set_henkan_env(buf, valuemask, henv)
6972 register struct wnn_buf *buf;
6973 unsigned long valuemask;
6974 struct wnn_henkan_env *henv;
6975 {
6976 int x;
6977
6978 if(!buf || !(buf->env)) return(-1);
6979 LockMutex(&BUF_LOCK(buf));
6980 LockMutex(&(envmt->env_lock));
6981 buf_wnn_errorno_set = 0;
6982 x = jl_set_henkan_env_e_body((WNN_ENV_INT *)buf->env, valuemask, henv);
6983 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
6984 UnlockMutex(&(envmt->env_lock));
6985 UnlockMutex(&BUF_LOCK(buf));
6986 return x;
6987 }
6988
6989 static int
jl_set_henkan_hinsi_e_body(env,mode,nhinsi,hname)6990 jl_set_henkan_hinsi_e_body(env, mode, nhinsi, hname)
6991 register struct wnn_env_int *env;
6992 int mode, nhinsi;
6993 char **hname;
6994 {
6995 int x, i, hsize, *hno = NULL;
6996 w_char tmp[32];
6997
6998 if(nhinsi) {
6999 hsize = abs(nhinsi);
7000 hno = (int *)malloc(hsize * sizeof(int));
7001 for(i = 0; i < hsize; i++) {
7002 _Sstrcpy(tmp, hname[i]);
7003 if((hno[i] = jl_hinsi_number_e_body(env, tmp)) == -1) {
7004 free((char *)hno);
7005 return(-1);
7006 }
7007 }
7008 }
7009
7010 if((x = js_set_henkan_hinsi(env, mode, nhinsi, hno)) == -1) {
7011 env_wnn_errorno_copy(env);
7012 if_dead_disconnect(env);
7013 if(nhinsi) free((char *)hno);
7014 return(-1);
7015 }
7016 if(nhinsi) free((char *)hno);
7017 return (x);
7018 }
7019
7020 int
jl_set_henkan_hinsi_e(env,mode,nhinsi,hname)7021 jl_set_henkan_hinsi_e(env, mode, nhinsi, hname)
7022 register struct wnn_env *env;
7023 int mode, nhinsi;
7024 char **hname;
7025 {
7026 int x;
7027
7028 if(!env) return(-1);
7029 LockMutex(&ENV_LOCK(env));
7030 env_wnn_errorno_set = 0;
7031 x = jl_set_henkan_hinsi_e_body((WNN_ENV_INT *)env, mode, nhinsi, hname);
7032 UnlockMutex(&ENV_LOCK(env));
7033 return x;
7034 }
7035
7036 int
jl_set_henkan_hinsi(buf,mode,nhinsi,hname)7037 jl_set_henkan_hinsi(buf, mode, nhinsi, hname)
7038 register struct wnn_buf *buf;
7039 int mode, nhinsi;
7040 char **hname;
7041 {
7042 int x;
7043
7044 if(!buf || !(buf->env)) return(-1);
7045 LockMutex(&BUF_LOCK(buf));
7046 LockMutex(&(envmt->env_lock));
7047 buf_wnn_errorno_set = 0;
7048 x = jl_set_henkan_hinsi_e_body((WNN_ENV_INT *)buf->env, mode, nhinsi, hname);
7049 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
7050 UnlockMutex(&(envmt->env_lock));
7051 UnlockMutex(&BUF_LOCK(buf));
7052 return x;
7053 }
7054
7055 static int
jl_param_get_e_body(env,para)7056 jl_param_get_e_body(env, para)
7057 struct wnn_env_int *env;
7058 struct wnn_param *para;
7059 {
7060 register int x;
7061
7062 if((x = js_param_get(env, para)) == -1) {
7063 env_wnn_errorno_copy(env);
7064 if_dead_disconnect(env);
7065 return(-1);
7066 }
7067 return (x);
7068 }
7069
7070 int
jl_param_get_e(env,para)7071 jl_param_get_e(env, para)
7072 struct wnn_env *env;
7073 struct wnn_param *para;
7074 {
7075 int x;
7076
7077 if(!env) return(-1);
7078 LockMutex(&ENV_LOCK(env));
7079 env_wnn_errorno_set = 0;
7080 x = jl_param_get_e_body((WNN_ENV_INT *)env, para);
7081 UnlockMutex(&ENV_LOCK(env));
7082 return x;
7083 }
7084
7085 int
jl_param_get(buf,para)7086 jl_param_get(buf, para)
7087 register struct wnn_buf *buf;
7088 struct wnn_param *para;
7089 {
7090 int x;
7091
7092 if(!buf || !(buf->env)) return(-1);
7093 LockMutex(&BUF_LOCK(buf));
7094 LockMutex(&(envmt->env_lock));
7095 buf_wnn_errorno_set = 0;
7096 x = jl_param_get_e_body((WNN_ENV_INT *)buf->env, para);
7097 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
7098 UnlockMutex(&(envmt->env_lock));
7099 UnlockMutex(&BUF_LOCK(buf));
7100 return x;
7101 }
7102
7103 /*:::DOC_START
7104 *
7105 * Function Name: jl_get_henkan_env_e_body
7106 * Description : ����������Ѵ��Ķ������륵�֥롼����
7107 * Parameter :
7108 * env : (In) �Ķ��ؤΥݥ���
7109 * henv : (Out) �Ѵ��Ķ���������ѹ�¤�ΤؤΥݥ���
7110 * local : (In) �Ѵ��Ķ��������оݥե饰
7111 * ��0 == jserver, else client��
7112 *
7113 * Return value : 0==SUCCESS, -1==ERROR
7114 *
7115 * Author : Hideyuki Kishiba
7116 *
7117 * Revision history:
7118 *
7119 *:::DOC_END
7120 */
7121 static int
jl_get_henkan_env_e_body(env,henv,local)7122 jl_get_henkan_env_e_body(env, henv, local)
7123 struct wnn_env_int *env;
7124 struct wnn_henkan_env *henv;
7125 int local;
7126 {
7127 register int x;
7128
7129 if ((local && ((x = js_get_henkan_env_local(env, henv)) == -1)) ||
7130 (!local && ((x = js_get_henkan_env(env, henv)) == -1))) {
7131 env_wnn_errorno_copy(env);
7132 if_dead_disconnect(env);
7133 return(-1);
7134 }
7135 return (x);
7136 }
7137
7138 /*:::DOC_START
7139 *
7140 * Function Name: jl_get_henkan_env_e
7141 * Description : ����������Ѵ��Ķ�������
7142 * Parameter :
7143 * env : (In) �Ķ��ؤΥݥ���
7144 * henv : (Out) �Ѵ��Ķ���������ѹ�¤�ΤؤΥݥ���
7145 *
7146 * Return value : 0==SUCCESS, -1==ERROR
7147 *
7148 * Author : Hideyuki Kishiba
7149 *
7150 * Revision history:
7151 *
7152 *:::DOC_END
7153 */
7154 int
jl_get_henkan_env_e(env,henv)7155 jl_get_henkan_env_e(env, henv)
7156 struct wnn_env *env;
7157 struct wnn_henkan_env *henv;
7158 {
7159 int x;
7160
7161 if(!env) return(-1);
7162 LockMutex(&ENV_LOCK(env));
7163 env_wnn_errorno_set = 0;
7164 x = jl_get_henkan_env_e_body((WNN_ENV_INT *)env, henv, 0);
7165 UnlockMutex(&ENV_LOCK(env));
7166 return x;
7167 } /* End of jl_get_henkan_env_e */
7168
7169 /*:::DOC_START
7170 *
7171 * Function Name: jl_get_henkan_env
7172 * Description : ����������Ѵ��Ķ�������
7173 * Parameter :
7174 * buf : (In) �Хåե��ؤΥݥ���
7175 * henv : (Out) �Ѵ��Ķ���������ѹ�¤�ΤؤΥݥ���
7176 *
7177 * Return value : 0==SUCCESS, -1==ERROR
7178 *
7179 * Author : Hideyuki Kishiba
7180 *
7181 * Revision history:
7182 *
7183 *:::DOC_END
7184 */
7185 int
jl_get_henkan_env(buf,henv)7186 jl_get_henkan_env(buf, henv)
7187 register struct wnn_buf *buf;
7188 struct wnn_henkan_env *henv;
7189 {
7190 int x;
7191
7192 if(!buf || !(buf->env)) return(-1);
7193 LockMutex(&BUF_LOCK(buf));
7194 LockMutex(&(envmt->env_lock));
7195 buf_wnn_errorno_set = 0;
7196 x = jl_get_henkan_env_e_body((WNN_ENV_INT *)buf->env, henv, 0);
7197 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
7198 UnlockMutex(&(envmt->env_lock));
7199 UnlockMutex(&BUF_LOCK(buf));
7200 return x;
7201 } /* End of jl_get_henkan_env */
7202
7203 /*:::DOC_START
7204 *
7205 * Function Name: jl_get_henkan_env_local_e
7206 * Description : �Ѵ��Ķ����⡤�饤�֥��ˤ����Τ���
7207 * ����������̡�����
7208 * Parameter :
7209 * env : (In) �Ķ��ؤΥݥ���
7210 * henv : (Out) �Ѵ��Ķ��ι�¤�ΤؤΥݥ���
7211 *
7212 * Return value : 0==SUCCESS,-1==ERROR
7213 *
7214 * Author : Seiji KUWARI
7215 *
7216 * Revision history:
7217 *
7218 *:::DOC_END
7219 */
7220 int
jl_get_henkan_env_local_e(env,henv)7221 jl_get_henkan_env_local_e(env, henv)
7222 struct wnn_env *env;
7223 struct wnn_henkan_env *henv;
7224 {
7225 int x;
7226
7227 if(!env) return(-1);
7228 LockMutex(&ENV_LOCK(env));
7229 env_wnn_errorno_set = 0;
7230 x = jl_get_henkan_env_e_body((WNN_ENV_INT *)env, henv, 1);
7231 UnlockMutex(&ENV_LOCK(env));
7232 return x;
7233 }
7234
7235 /*:::DOC_START
7236 *
7237 * Function Name: jl_get_henkan_env_local
7238 * Description : �Ѵ��Ķ����⡤�饤�֥��ˤ����Τ���
7239 * ����������̡�����
7240 * Parameter :
7241 * buf : (In) �Хåե��ؤΥݥ���
7242 * henv : (Out) �Ѵ��Ķ��ι�¤�ΤؤΥݥ���
7243 *
7244 * Return value : 0==SUCCESS,-1==ERROR
7245 *
7246 * Author : Seiji KUWARI
7247 *
7248 * Revision history:
7249 *
7250 *:::DOC_END
7251 */
7252 int
jl_get_henkan_env_local(buf,henv)7253 jl_get_henkan_env_local(buf, henv)
7254 register struct wnn_buf *buf;
7255 struct wnn_henkan_env *henv;
7256 {
7257 int x;
7258
7259 if(!buf || !(buf->env)) return(-1);
7260 LockMutex(&BUF_LOCK(buf));
7261 LockMutex(&(envmt->env_lock));
7262 buf_wnn_errorno_set = 0;
7263 x = jl_get_henkan_env_e_body((WNN_ENV_INT *)buf->env, henv, 1);
7264 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
7265 UnlockMutex(&(envmt->env_lock));
7266 UnlockMutex(&BUF_LOCK(buf));
7267 return x;
7268 }
7269
7270 /*:::DOC_START
7271 *
7272 * Function Name: jl_get_henkan_hinsi_e_body
7273 * Description : �Ѵ��ˡʻ��ѡ��Ի��ѡˤ����ʻ췲�����륵�֥롼����
7274 * Parameter :
7275 * env : (In) �Ķ��ؤΥݥ���
7276 * nhinsi : (Out) �����ʻ������ == �Ի���, �� ���ѡ�
7277 * hlist : (Out) �����ʻ�ꥹ�ȤؤΥݥ���
7278 *
7279 * Return value : 0==SUCCESS, -1==ERROR
7280 *
7281 * Author : Hideyuki Kishiba
7282 *
7283 * Revision history:
7284 *
7285 *:::DOC_END
7286 */
7287 static int
jl_get_henkan_hinsi_e_body(env,nhinsi,hlist)7288 jl_get_henkan_hinsi_e_body(env, nhinsi, hlist)
7289 struct wnn_env_int *env;
7290 int *nhinsi, **hlist;
7291 {
7292 register int x;
7293
7294 if((x = js_get_henkan_hinsi(env, nhinsi, hlist)) == -1) {
7295 env_wnn_errorno_copy(env);
7296 if_dead_disconnect(env);
7297 return(-1);
7298 }
7299 return (x);
7300 } /* End of jl_get_henkan_hinsi_e_body */
7301
7302 /*:::DOC_START
7303 *
7304 * Function Name: jl_get_henkan_hinsi_e
7305 * Description : �Ѵ��ˡʻ��ѡ��Ի��ѡˤ����ʻ췲������
7306 * Parameter :
7307 * env : (In) �Ķ��ؤΥݥ���
7308 * nhinsi : (Out) �����ʻ������ == �Ի���, �� ���ѡ�
7309 * hlist : (Out) �����ʻ�ꥹ�ȤؤΥݥ���
7310 *
7311 * Return value : 0==SUCCESS, -1==ERROR
7312 *
7313 * Author : Hideyuki Kishiba
7314 *
7315 * Revision history:
7316 *
7317 *:::DOC_END
7318 */
7319 int
jl_get_henkan_hinsi_e(env,nhinsi,hlist)7320 jl_get_henkan_hinsi_e(env, nhinsi, hlist)
7321 struct wnn_env *env;
7322 int *nhinsi, **hlist;
7323 {
7324 int x;
7325
7326 if(!env) return(-1);
7327 LockMutex(&ENV_LOCK(env));
7328 env_wnn_errorno_set = 0;
7329 x = jl_get_henkan_hinsi_e_body((WNN_ENV_INT *)env, nhinsi, hlist);
7330 UnlockMutex(&ENV_LOCK(env));
7331 return x;
7332 } /* End of jl_get_henkan_hinsi_e */
7333
7334 /*:::DOC_START
7335 *
7336 * Function Name: jl_get_henkan_hinsi
7337 * Description : �Ѵ��ˡʻ��ѡ��Ի��ѡˤ����ʻ췲������
7338 * Parameter :
7339 * env : (In) �Хåե��ؤΥݥ���
7340 * nhinsi : (Out) �����ʻ������ == �Ի���, �� ���ѡ�
7341 * hlist : (Out) �����ʻ�ꥹ�ȤؤΥݥ���
7342 *
7343 * Return value : 0==SUCCESS, -1==ERROR
7344 *
7345 * Author : Hideyuki Kishiba
7346 *
7347 * Revision history:
7348 *
7349 *:::DOC_END
7350 */
7351 int
jl_get_henkan_hinsi(buf,nhinsi,hlist)7352 jl_get_henkan_hinsi(buf, nhinsi, hlist)
7353 register struct wnn_buf *buf;
7354 int *nhinsi, **hlist;
7355 {
7356 int x;
7357
7358 if(!buf || !(buf->env)) return(-1);
7359 LockMutex(&BUF_LOCK(buf));
7360 LockMutex(&(envmt->env_lock));
7361 buf_wnn_errorno_set = 0;
7362 x = jl_get_henkan_hinsi_e_body((WNN_ENV_INT *)buf->env, nhinsi, hlist);
7363 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
7364 UnlockMutex(&(envmt->env_lock));
7365 UnlockMutex(&BUF_LOCK(buf));
7366 return x;
7367 } /* End of jl_get_henkan_hinsi */
7368
7369 static int
jl_dic_use_e_body(env,dic_no,flag)7370 jl_dic_use_e_body(env, dic_no, flag)
7371 struct wnn_env_int *env;
7372 int dic_no,flag;
7373 {
7374 register int x;
7375
7376 if((x = js_dic_use(env, dic_no, flag)) == -1) {
7377 env_wnn_errorno_copy(env);
7378 if_dead_disconnect(env);
7379 return(-1);
7380 }
7381 return (x);
7382 }
7383
7384 int
jl_dic_use_e(env,dic_no,flag)7385 jl_dic_use_e(env, dic_no, flag)
7386 struct wnn_env *env;
7387 int dic_no,flag;
7388 {
7389 int x;
7390
7391 if(!env) return(-1);
7392 LockMutex(&ENV_LOCK(env));
7393 env_wnn_errorno_set = 0;
7394 x = jl_dic_use_e_body((WNN_ENV_INT *)env, dic_no, flag);
7395 UnlockMutex(&ENV_LOCK(env));
7396 return x;
7397 }
7398
7399 int
jl_dic_use(buf,dic_no,flag)7400 jl_dic_use(buf, dic_no, flag)
7401 register struct wnn_buf *buf;
7402 int dic_no,flag;
7403 {
7404 int x;
7405
7406 if(!buf || !(buf->env)) return(-1);
7407 LockMutex(&BUF_LOCK(buf));
7408 LockMutex(&(envmt->env_lock));
7409 buf_wnn_errorno_set = 0;
7410 x = jl_dic_use_e_body((WNN_ENV_INT *)buf->env, dic_no, flag);
7411 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
7412 UnlockMutex(&(envmt->env_lock));
7413 UnlockMutex(&BUF_LOCK(buf));
7414 return x;
7415 }
7416
7417 static int
jl_word_add_e_body(env,dic_no,yomi,kanji,comment,hinsi,init_hindo)7418 jl_word_add_e_body(env, dic_no, yomi, kanji, comment, hinsi, init_hindo)
7419 struct wnn_env_int *env;
7420 int dic_no;
7421 w_char *yomi,*kanji,*comment;
7422 int hinsi,init_hindo;
7423 {
7424 register int x;
7425
7426 if((x = js_word_add(env, dic_no, yomi, kanji, comment, hinsi, init_hindo)) == -1) {
7427 env_wnn_errorno_copy(env);
7428 if_dead_disconnect(env);
7429 return(-1);
7430 }
7431 return (x);
7432 }
7433
7434 int
jl_word_add_e(env,dic_no,yomi,kanji,comment,hinsi,init_hindo)7435 jl_word_add_e(env, dic_no, yomi, kanji, comment, hinsi, init_hindo)
7436 struct wnn_env *env;
7437 int dic_no;
7438 w_char *yomi,*kanji,*comment;
7439 int hinsi,init_hindo;
7440 {
7441 int x;
7442
7443 if(!env) return(-1);
7444 LockMutex(&ENV_LOCK(env));
7445 env_wnn_errorno_set = 0;
7446 x = jl_word_add_e_body((WNN_ENV_INT *)env, dic_no, yomi, kanji, comment, hinsi, init_hindo);
7447 UnlockMutex(&ENV_LOCK(env));
7448 return x;
7449 }
7450
7451 int
jl_word_add(buf,dic_no,yomi,kanji,comment,hinsi,init_hindo)7452 jl_word_add(buf, dic_no, yomi, kanji, comment, hinsi, init_hindo)
7453 register struct wnn_buf *buf;
7454 int dic_no;
7455 w_char *yomi,*kanji,*comment;
7456 int hinsi,init_hindo;
7457 {
7458 int x;
7459
7460 if(!buf || !(buf->env)) return(-1);
7461 LockMutex(&BUF_LOCK(buf));
7462 LockMutex(&(envmt->env_lock));
7463 buf_wnn_errorno_set = 0;
7464 x = jl_word_add_e_body((WNN_ENV_INT *)buf->env, dic_no, yomi, kanji,
7465 comment, hinsi, init_hindo);
7466 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
7467 UnlockMutex(&(envmt->env_lock));
7468 UnlockMutex(&BUF_LOCK(buf));
7469 return x;
7470 }
7471
7472 static int
jl_word_delete_e_body(env,dic_no,entry)7473 jl_word_delete_e_body(env, dic_no, entry)
7474 struct wnn_env_int *env;
7475 int dic_no;
7476 int entry;
7477 {
7478 register int x;
7479
7480 if((x = js_word_delete(env, dic_no, entry)) == -1) {
7481 env_wnn_errorno_copy(env);
7482 if_dead_disconnect(env);
7483 return(-1);
7484 }
7485 return (x);
7486 }
7487
7488 int
jl_word_delete_e(env,dic_no,entry)7489 jl_word_delete_e(env, dic_no, entry)
7490 struct wnn_env *env;
7491 int dic_no;
7492 int entry;
7493 {
7494 int x;
7495
7496 if(!env) return(-1);
7497 LockMutex(&ENV_LOCK(env));
7498 env_wnn_errorno_set = 0;
7499 x = jl_word_delete_e_body((WNN_ENV_INT *)env, dic_no, entry);
7500 UnlockMutex(&ENV_LOCK(env));
7501 return x;
7502 }
7503
7504 int
jl_word_delete(buf,dic_no,entry)7505 jl_word_delete(buf, dic_no, entry)
7506 register struct wnn_buf *buf;
7507 int dic_no;
7508 int entry;
7509 {
7510 int x;
7511
7512 if(!buf || !(buf->env)) return(-1);
7513 LockMutex(&BUF_LOCK(buf));
7514 LockMutex(&(envmt->env_lock));
7515 buf_wnn_errorno_set = 0;
7516 x = jl_word_delete_e_body((WNN_ENV_INT *)buf->env, dic_no, entry);
7517 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
7518 UnlockMutex(&(envmt->env_lock));
7519 UnlockMutex(&BUF_LOCK(buf));
7520 return x;
7521 }
7522
7523 static int
file_read(env,fname)7524 file_read(env, fname)
7525 struct wnn_env_int *env;
7526 char *fname;
7527 {
7528 register int fid;
7529 if(fname[0] == C_LOCAL){
7530 fid = js_file_send(env, fname + 1);
7531 }else{
7532 fid = js_file_read(env, fname);
7533 }
7534 if(fid >= 0){
7535 add_file_to_env(env, fid, fname);
7536 }
7537 return(fid);
7538 }
7539
7540 static int
file_remove(server,fname,pwd)7541 file_remove(server, fname, pwd)
7542 register WNN_JSERVER_ID *server;
7543 char *fname;
7544 char *pwd;
7545 {
7546 if(fname[0] == C_LOCAL){
7547 return(js_file_remove_client(server, fname + 1, pwd));
7548 }else{
7549 return(js_file_remove(server, fname, pwd));
7550 }
7551 }
7552
7553
7554 static int
file_discard(env,fid)7555 file_discard(env, fid)
7556 register struct wnn_env_int *env;
7557 register int fid;
7558 {
7559 delete_file_from_env(env, fid);
7560 return(js_file_discard(env, fid));
7561 }
7562
7563 static int
jl_hinsi_number_e_body(env,name)7564 jl_hinsi_number_e_body(env, name)
7565 register struct wnn_env_int *env;
7566 w_char *name;
7567 {
7568 register int x;
7569
7570 if((x = js_hinsi_number(env->orig.js_id, name)) == -1) {
7571 env_wnn_errorno_copy(env);
7572 if_dead_disconnect(env);
7573 return(-1);
7574 }
7575 return (x);
7576 }
7577
7578 int
jl_hinsi_number_e(env,name)7579 jl_hinsi_number_e(env, name)
7580 register struct wnn_env *env;
7581 w_char *name;
7582 {
7583 int x;
7584
7585 if(!env) return(-1);
7586 LockMutex(&ENV_LOCK(env));
7587 env_wnn_errorno_set = 0;
7588 x = jl_hinsi_number_e_body((WNN_ENV_INT *)env, name);
7589 UnlockMutex(&ENV_LOCK(env));
7590 return x;
7591 }
7592
7593 int
jl_hinsi_number(buf,name)7594 jl_hinsi_number(buf, name)
7595 register struct wnn_buf *buf;
7596 w_char *name;
7597 {
7598 int x;
7599
7600 if(!buf || !(buf->env)) return(-1);
7601 LockMutex(&BUF_LOCK(buf));
7602 LockMutex(&(envmt->env_lock));
7603 buf_wnn_errorno_set = 0;
7604 x = jl_hinsi_number_e_body((WNN_ENV_INT *)buf->env, name);
7605 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
7606 UnlockMutex(&(envmt->env_lock));
7607 UnlockMutex(&BUF_LOCK(buf));
7608 return x;
7609 }
7610
jl_hinsi_name_e_body(env,no)7611 static w_char *jl_hinsi_name_e_body(env, no)
7612 register struct wnn_env_int *env;
7613 register int no;
7614 {
7615 w_char *x;
7616
7617 if(js_hinsi_name(env->orig.js_id, no, &env_rb) == -1) {
7618 env_wnn_errorno_copy(env);
7619 if_dead_disconnect(env);
7620 return(NULL);
7621 }
7622 x = (w_char *)(env_rb.buf);
7623 return x;
7624 }
7625
jl_hinsi_name_e(env,no)7626 w_char *jl_hinsi_name_e(env, no)
7627 register struct wnn_env *env;
7628 register int no;
7629 {
7630 w_char *x;
7631
7632 if(!env) return(NULL);
7633 LockMutex(&ENV_LOCK(env));
7634 env_wnn_errorno_set = 0;
7635 x = jl_hinsi_name_e_body((WNN_ENV_INT *)env, no);
7636 UnlockMutex(&ENV_LOCK(env));
7637 return x;
7638 }
7639
7640 w_char *
jl_hinsi_name(buf,no)7641 jl_hinsi_name(buf, no)
7642 register struct wnn_buf *buf;
7643 register int no;
7644 {
7645 w_char *x;
7646
7647 if(!buf || !(buf->env)) return(NULL);
7648 LockMutex(&BUF_LOCK(buf));
7649 LockMutex(&(envmt->env_lock));
7650 buf_wnn_errorno_set = 0;
7651 x = jl_hinsi_name_e_body((WNN_ENV_INT *)buf->env, no);
7652 if(x == NULL) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
7653 UnlockMutex(&(envmt->env_lock));
7654 UnlockMutex(&BUF_LOCK(buf));
7655 return x;
7656 }
7657
7658 static int
jl_hinsi_list_e_body(env,dic_no,name,area)7659 jl_hinsi_list_e_body(env, dic_no, name, area)
7660 register struct wnn_env_int *env;
7661 int dic_no;
7662 w_char *name;
7663 w_char ***area;
7664 {
7665 int x;
7666
7667 if((x = js_hinsi_list(env, dic_no, name, &env_rb)) == -1) {
7668 env_wnn_errorno_copy(env);
7669 if_dead_disconnect(env);
7670 return(-1);
7671 }
7672 *area = (w_char **)(env_rb.buf);
7673 return(x);
7674 }
7675
7676 int
jl_hinsi_list_e(env,dic_no,name,area)7677 jl_hinsi_list_e(env, dic_no, name, area)
7678 register struct wnn_env *env;
7679 int dic_no;
7680 w_char *name;
7681 w_char ***area;
7682 {
7683 int x;
7684
7685 if(!env) return(-1);
7686 LockMutex(&ENV_LOCK(env));
7687 env_wnn_errorno_set = 0;
7688 x = jl_hinsi_list_e_body((WNN_ENV_INT *)env, dic_no, name, area);
7689 UnlockMutex(&ENV_LOCK(env));
7690 return x;
7691 }
7692
7693 int
jl_hinsi_list(buf,dic_no,name,area)7694 jl_hinsi_list(buf, dic_no, name, area)
7695 register struct wnn_buf *buf;
7696 int dic_no;
7697 w_char *name;
7698 w_char ***area;
7699 {
7700 int x;
7701
7702 if(!buf || !(buf->env)) return(-1);
7703 LockMutex(&BUF_LOCK(buf));
7704 LockMutex(&(envmt->env_lock));
7705 buf_wnn_errorno_set = 0;
7706 x = jl_hinsi_list_e_body((WNN_ENV_INT *)buf->env, dic_no, name, area);
7707 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
7708 UnlockMutex(&(envmt->env_lock));
7709 UnlockMutex(&BUF_LOCK(buf));
7710 return x;
7711 }
7712
7713 static int
jl_hinsi_dicts_e_body(env,no,area)7714 jl_hinsi_dicts_e_body(env, no, area)
7715 register struct wnn_env_int *env;
7716 int no;
7717 int **area;
7718 {
7719 int x;
7720
7721 if((x = js_hinsi_dicts(env, no, &env_rb)) == -1) {
7722 env_wnn_errorno_copy(env);
7723 if_dead_disconnect(env);
7724 return(-1);
7725 }
7726 *area = (int *)(env_rb.buf);
7727 return(x);
7728 }
7729
7730 int
jl_hinsi_dicts_e(env,no,area)7731 jl_hinsi_dicts_e(env, no, area)
7732 register struct wnn_env *env;
7733 int no;
7734 int **area;
7735 {
7736 int x;
7737
7738 if(!env) return(-1);
7739 LockMutex(&ENV_LOCK(env));
7740 env_wnn_errorno_set = 0;
7741 x = jl_hinsi_dicts_e_body((WNN_ENV_INT *)env, no, area);
7742 UnlockMutex(&ENV_LOCK(env));
7743 return x;
7744 }
7745
7746 int
jl_hinsi_dicts(buf,no,area)7747 jl_hinsi_dicts(buf, no, area)
7748 register struct wnn_buf *buf;
7749 int no;
7750 int **area;
7751 {
7752 int x;
7753
7754 if(!buf || !(buf->env)) return(-1);
7755 LockMutex(&BUF_LOCK(buf));
7756 LockMutex(&(envmt->env_lock));
7757 buf_wnn_errorno_set = 0;
7758 x = jl_hinsi_dicts_e_body((WNN_ENV_INT *)buf->env, no, area);
7759 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
7760 UnlockMutex(&(envmt->env_lock));
7761 UnlockMutex(&BUF_LOCK(buf));
7762 return x;
7763 }
7764
7765 static int
jl_word_comment_set_e_body(env,dic_no,entry,comment)7766 jl_word_comment_set_e_body(env, dic_no, entry, comment)
7767 register struct wnn_env_int *env;
7768 int dic_no,entry;
7769 w_char *comment;
7770 {
7771 register int x;
7772
7773 if((x = js_word_comment_set(env, dic_no, entry, comment)) == -1) {
7774 env_wnn_errorno_copy(env);
7775 if_dead_disconnect(env);
7776 return(-1);
7777 }
7778 return (x);
7779 }
7780
7781 int
jl_word_comment_set_e(env,dic_no,entry,comment)7782 jl_word_comment_set_e(env, dic_no, entry, comment)
7783 register struct wnn_env *env;
7784 int dic_no,entry;
7785 w_char *comment;
7786 {
7787 int x;
7788
7789 if(!env) return(-1);
7790 LockMutex(&ENV_LOCK(env));
7791 env_wnn_errorno_set = 0;
7792 x = jl_word_comment_set_e_body((WNN_ENV_INT *)env, dic_no, entry, comment);
7793 UnlockMutex(&ENV_LOCK(env));
7794 return x;
7795 }
7796
7797 int
jl_word_comment_set(buf,dic_no,entry,comment)7798 jl_word_comment_set(buf, dic_no, entry, comment)
7799 register struct wnn_buf *buf;
7800 int dic_no,entry;
7801 w_char *comment;
7802 {
7803 int x;
7804
7805 if(!buf || !(buf->env)) return(-1);
7806 LockMutex(&BUF_LOCK(buf));
7807 LockMutex(&(envmt->env_lock));
7808 buf_wnn_errorno_set = 0;
7809 x = jl_word_comment_set_e_body((WNN_ENV_INT *)buf->env, dic_no, entry,
7810 comment);
7811 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
7812 UnlockMutex(&(envmt->env_lock));
7813 UnlockMutex(&BUF_LOCK(buf));
7814 return x;
7815 }
7816
7817 static int
jl_dic_comment_set_e_body(env,dic_no,comment)7818 jl_dic_comment_set_e_body(env, dic_no, comment)
7819 register struct wnn_env_int *env;
7820 int dic_no;
7821 w_char *comment;
7822 {
7823 register int x;
7824 WNN_DIC_INFO dic;
7825 WNN_FILE_INFO_STRUCT file;
7826
7827 if(js_dic_info(env,dic_no,&dic) < 0) {
7828 env_wnn_errorno_copy(env);
7829 if_dead_disconnect(env);
7830 return(-1);
7831 }
7832 /* dic Body */
7833 if (js_file_info(env,dic.body,&file) < 0) {
7834 env_wnn_errorno_copy(env);
7835 if_dead_disconnect(env);
7836 return(-1);
7837 }
7838 if((x = js_file_comment_set(env, file.fid, comment)) == -1) {
7839 env_wnn_errorno_copy(env);
7840 if_dead_disconnect(env);
7841 return(-1);
7842 }
7843 return (x);
7844 }
7845
7846 int
jl_dic_comment_set_e(env,dic_no,comment)7847 jl_dic_comment_set_e(env, dic_no, comment)
7848 register struct wnn_env *env;
7849 int dic_no;
7850 w_char *comment;
7851 {
7852 int x;
7853
7854 if(!env) return(-1);
7855 LockMutex(&ENV_LOCK(env));
7856 env_wnn_errorno_set = 0;
7857 x = jl_dic_comment_set_e_body((WNN_ENV_INT *)env, dic_no, comment);
7858 UnlockMutex(&ENV_LOCK(env));
7859 return x;
7860 }
7861
7862 int
jl_dic_comment_set(buf,dic_no,comment)7863 jl_dic_comment_set(buf, dic_no, comment)
7864 register struct wnn_buf *buf;
7865 int dic_no;
7866 w_char *comment;
7867 {
7868 int x;
7869
7870 if(!buf || !(buf->env)) return(-1);
7871 LockMutex(&BUF_LOCK(buf));
7872 LockMutex(&(envmt->env_lock));
7873 buf_wnn_errorno_set = 0;
7874 x = jl_dic_comment_set_e_body((WNN_ENV_INT *)buf->env, dic_no, comment);
7875 if(x == -1) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
7876 UnlockMutex(&(envmt->env_lock));
7877 UnlockMutex(&BUF_LOCK(buf));
7878 return x;
7879 }
7880
7881
7882 int
jl_bun_suu(buf)7883 jl_bun_suu(buf)
7884 register struct wnn_buf *buf;
7885 {
7886 int x;
7887
7888 if(!buf) return(0);
7889 LockMutex(&BUF_LOCK(buf));
7890 x = buf->bun_suu;
7891 UnlockMutex(&BUF_LOCK(buf));
7892 return x;
7893 }
7894
7895 int
jl_zenkouho_suu(buf)7896 jl_zenkouho_suu(buf)
7897 register struct wnn_buf *buf;
7898 {
7899 int x;
7900
7901 if(!buf) return(0);
7902 LockMutex(&BUF_LOCK(buf));
7903 if(buf->zenkouho_daip)
7904 x = buf->zenkouho_dai_suu;
7905 else
7906 x = buf->zenkouho_suu;
7907 UnlockMutex(&BUF_LOCK(buf));
7908 return x;
7909 }
7910
7911 int
jl_zenkouho_bun(buf)7912 jl_zenkouho_bun(buf)
7913 register struct wnn_buf *buf;
7914 {
7915 int x;
7916
7917 if(!buf) return(0);
7918 LockMutex(&BUF_LOCK(buf));
7919 x = buf->zenkouho_bun;
7920 UnlockMutex(&BUF_LOCK(buf));
7921 return x;
7922 }
7923
7924 int
jl_c_zenkouho(buf)7925 jl_c_zenkouho(buf)
7926 register struct wnn_buf *buf;
7927 {
7928 int x;
7929
7930 if(!buf) return(0);
7931 LockMutex(&BUF_LOCK(buf));
7932 x = buf->c_zenkouho;
7933 UnlockMutex(&BUF_LOCK(buf));
7934 return x;
7935 }
7936
7937 int
jl_zenkouho_daip(buf)7938 jl_zenkouho_daip(buf)
7939 register struct wnn_buf *buf;
7940 {
7941 int x;
7942
7943 if(!buf) return(0);
7944 LockMutex(&BUF_LOCK(buf));
7945 x = buf->zenkouho_daip;
7946 UnlockMutex(&BUF_LOCK(buf));
7947 return x;
7948 }
7949
7950 int
jl_dai_top(buf,k)7951 jl_dai_top(buf, k)
7952 register struct wnn_buf *buf;
7953 int k;
7954 {
7955 int x;
7956
7957 if(!buf) return(0);
7958 LockMutex(&BUF_LOCK(buf));
7959 x = buf->bun[k]->dai_top;
7960 UnlockMutex(&BUF_LOCK(buf));
7961 return x;
7962 }
7963
7964 int
jl_jiri_len(buf,k)7965 jl_jiri_len(buf, k)
7966 register struct wnn_buf *buf;
7967 int k;
7968 {
7969 int x;
7970
7971 if(!buf) return(0);
7972 LockMutex(&BUF_LOCK(buf));
7973 x = buf->bun[k]->jirilen;
7974 UnlockMutex(&BUF_LOCK(buf));
7975 return x;
7976 }
7977
7978 struct wnn_env *
jl_env(buf)7979 jl_env(buf)
7980 register struct wnn_buf *buf;
7981 {
7982 struct wnn_env *x;
7983
7984 if(!buf) return(NULL);
7985 LockMutex(&BUF_LOCK(buf));
7986 x = buf->env;
7987 UnlockMutex(&BUF_LOCK(buf));
7988 return x;
7989 }
7990
7991 int
jl_get_wnn_errorno_env(env)7992 jl_get_wnn_errorno_env(env)
7993 register struct wnn_env *env;
7994 {
7995 int x;
7996
7997 if(!env) return(-1);
7998 LockMutex(&ENV_LOCK(env));
7999 x = env_wnn_errorno_eql;
8000 UnlockMutex(&ENV_LOCK(env));
8001 return x;
8002 }
8003
8004 int
jl_get_wnn_errorno_buf(buf)8005 jl_get_wnn_errorno_buf(buf)
8006 register struct wnn_buf *buf;
8007 {
8008 int x;
8009
8010 if(!buf) return(-1);
8011 LockMutex(&BUF_LOCK(buf));
8012 x = buf_wnn_errorno_eql;
8013 UnlockMutex(&BUF_LOCK(buf));
8014 return x;
8015 }
8016
8017 struct wnn_jdata *
jl_inspect(buf,bun_no)8018 jl_inspect(buf, bun_no)
8019 register struct wnn_buf *buf;
8020 int bun_no;
8021 {
8022 struct wnn_jdata *x;
8023
8024 if(!buf || !(buf->env)) return(NULL);
8025 LockMutex(&BUF_LOCK(buf));
8026 LockMutex(&(envmt->env_lock));
8027 buf_wnn_errorno_set = 0;
8028 x = jl_word_info_e_body((WNN_ENV_INT *)buf->env, buf->bun[bun_no]->dic_no,
8029 buf->bun[bun_no]->entry);
8030 if(x == NULL) buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
8031 UnlockMutex(&(envmt->env_lock));
8032 UnlockMutex(&BUF_LOCK(buf));
8033 return x;
8034 }
8035
8036 int
jl_env_sticky_e(env)8037 jl_env_sticky_e(env)
8038 register struct wnn_env *env;
8039 {
8040 int x;
8041
8042 if(!env) return(-1);
8043 LockMutex(&ENV_LOCK(env));
8044 env_wnn_errorno_set = 0;
8045 if((x = js_env_sticky(env)) == -1) env_wnn_errorno_copy((WNN_ENV_INT *)env);
8046 UnlockMutex(&ENV_LOCK(env));
8047 return x;
8048 }
8049
8050 int
jl_env_sticky(buf)8051 jl_env_sticky(buf)
8052 register struct wnn_buf *buf;
8053 {
8054 int x;
8055
8056 if(!buf || !(buf->env)) return(-1);
8057 LockMutex(&BUF_LOCK(buf));
8058 LockMutex(&(envmt->env_lock));
8059 buf_wnn_errorno_set = 0;
8060 if((x = jl_env_sticky_e((WNN_ENV_INT *)buf->env)) == -1)
8061 buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
8062 UnlockMutex(&(envmt->env_lock));
8063 UnlockMutex(&BUF_LOCK(buf));
8064 return x;
8065 }
8066
8067 int
jl_env_un_sticky_e(env)8068 jl_env_un_sticky_e(env)
8069 register struct wnn_env *env;
8070 {
8071 int x;
8072
8073 if(!env) return(-1);
8074 LockMutex(&ENV_LOCK(env));
8075 if((x = js_env_un_sticky(env)) == -1) env_wnn_errorno_copy((WNN_ENV_INT *)env);
8076 UnlockMutex(&ENV_LOCK(env));
8077 return x;
8078 }
8079
8080 int
jl_env_un_sticky(buf)8081 jl_env_un_sticky(buf)
8082 register struct wnn_buf *buf;
8083 {
8084 int x;
8085
8086 if(!buf || !(buf->env)) return(-1);
8087 LockMutex(&BUF_LOCK(buf));
8088 LockMutex(&(envmt->env_lock));
8089 buf_wnn_errorno_set = 0;
8090 if((x = jl_env_un_sticky_e((WNN_ENV_INT *)buf->env)) == -1)
8091 buf_wnn_errorno_copy((WNN_BUF_MT *)buf);
8092 UnlockMutex(&(envmt->env_lock));
8093 UnlockMutex(&BUF_LOCK(buf));
8094 return x;
8095 }
8096
8097 char *
jl_get_lang(buf)8098 jl_get_lang(buf)
8099 register struct wnn_buf *buf;
8100 {
8101 char *x;
8102
8103 if(!buf || !(buf->env)) return(NULL);
8104 LockMutex(&BUF_LOCK(buf));
8105 LockMutex(&(envmt->env_lock));
8106 buf_wnn_errorno_set = 0;
8107 x = js_get_lang((WNN_ENV_INT *)buf->env);
8108 UnlockMutex(&(envmt->env_lock));
8109 UnlockMutex(&BUF_LOCK(buf));
8110 return x;
8111 }
8112
8113
8114 /* �ѥ��������ȥ��塼�˥� */
8115 typedef struct _InfoShoRec {
8116 int hindo;
8117 int ima;
8118 int jirilength;
8119 int bunlength;
8120 int dictnice;
8121 int hyoka;
8122 int daihyoka;
8123 int dai_top;
8124 w_char *yomi;
8125 int serial;
8126 int kangovect;
8127 struct _InfoShoRec *next;
8128 } InfoShoRec;
8129
8130 typedef struct _InfoDaiRec {
8131 int n;
8132 int hindo;
8133 int ima;
8134 int jirilength;
8135 int sholength;
8136 int dictnice;
8137 int dailength;
8138 struct _InfoDaiRec *next;
8139 } InfoDaiRec;
8140
8141 typedef InfoDaiRec InfoTotalRec;
8142
8143 typedef struct _WnnAutoTune {
8144 InfoDaiRec *s_dai_info;
8145 InfoDaiRec *e_dai_info;
8146 InfoShoRec *s_sho_info;
8147 InfoShoRec *e_sho_info;
8148 InfoTotalRec *s_total_info;
8149 InfoTotalRec *e_total_info;
8150 struct wnn_param new_param;
8151 struct wnn_param get_param;
8152 } WnnAutoTune;
8153
8154 static int
Giji_Hinsi_Check(info)8155 Giji_Hinsi_Check(info)
8156 InfoShoRec *info;
8157 {
8158 InfoShoRec *p = info;
8159
8160 for (; p; p = p->next) {
8161 if ((p->serial == -11) || (p->serial == -1)) {
8162 return(0);
8163 }
8164 }
8165 return(1);
8166 }
8167
8168 static int
Chval(h,o)8169 Chval(h, o)
8170 int h, o;
8171 {
8172 if (h > o) return(-1);
8173 if (h == o) return(0);
8174 return(1);
8175 }
8176
8177 static int
Sho_Info(buf,bun_no,info)8178 Sho_Info(buf, bun_no, info)
8179 struct wnn_buf *buf;
8180 int bun_no;
8181 InfoShoRec *info;
8182 {
8183 WNN_BUN *data = NULL;
8184 WNN_DIC_INFO dic;
8185 w_char *yomi;
8186
8187 if (!buf || !buf->bun || !(data = buf->bun[bun_no])) return(-1);
8188 if (js_dic_info(buf->env, data->dic_no, &dic) < 0)
8189 return(-1);
8190 if (!(yomi = (w_char *)malloc(sizeof(w_char) * (data->yomilen + 1))))
8191 return(-1);
8192 wnn_Strncpy(yomi, data->yomi, data->yomilen);
8193 yomi[data->yomilen] = (w_char)0;
8194 info->yomi = yomi;
8195 info->serial = data->entry;
8196 info->hindo = data->hindo;
8197 info->dictnice = dic.nice;
8198 info->ima = data->ima;
8199 info->hyoka = data->hyoka;
8200 info->daihyoka = data->daihyoka;
8201 info->kangovect = data->kangovect;
8202 info->dai_top = data->dai_top;
8203 info->jirilength = data->jirilen;
8204 info->bunlength = data->kanjilen;
8205 return(0);
8206 }
8207
8208 static InfoShoRec *
Atume(buf)8209 Atume(buf)
8210 register struct wnn_buf *buf;
8211 {
8212 int max = jl_bun_suu(buf);
8213 int i;
8214 InfoShoRec *info, *prev;
8215
8216 if (max <= 0) return(NULL);
8217 if (!(info = (InfoShoRec *)malloc(sizeof(InfoShoRec) * max))) return(NULL);
8218 bzero((char *)info, sizeof(InfoShoRec) * max);
8219
8220 for (i = 0; i < max; i++) {
8221 if (Sho_Info(buf, i, &info[i]) < 0) {
8222 free((char *)info);
8223 return(NULL);
8224 }
8225 info[i].next = NULL;
8226 if (i > 0) prev->next = &info[i];
8227 prev = &info[i];
8228 }
8229 return(info);
8230 }
8231
8232 static InfoTotalRec *
Total(p)8233 Total(p)
8234 InfoDaiRec *p;
8235 {
8236 int nn;
8237 InfoTotalRec *info;
8238
8239 if (!p) return(NULL);
8240 if (!(info = (InfoTotalRec *)malloc(sizeof(InfoTotalRec)))) return(NULL);
8241 bzero((char *)info, sizeof(InfoTotalRec));
8242
8243 for (; p; p = p->next) {
8244 nn = p->n;
8245 info->n += nn;
8246 info->hindo += p->hindo/nn;
8247 info->ima += p->ima/nn;
8248 info->jirilength += p->jirilength/nn;
8249 info->sholength += p->sholength/nn;
8250 info->dictnice += p->dictnice/nn;
8251 info->dailength += p->dailength;
8252 }
8253 return(info);
8254 }
8255
8256 static InfoDaiRec *
Dai_Info(sho_p)8257 Dai_Info(sho_p)
8258 InfoShoRec *sho_p;
8259 {
8260 int cnt, i;
8261 InfoShoRec *p = sho_p;
8262 InfoDaiRec *d, *info, *prev;
8263
8264 for (cnt = 0; p; p = p->next) {
8265 if (p->dai_top) cnt++;
8266 }
8267
8268 if (cnt <= 0) return(NULL);
8269 if (!(info = (InfoDaiRec *)malloc(sizeof(InfoDaiRec) * cnt))) return(NULL);
8270 bzero((char *)info, sizeof(InfoDaiRec) * cnt);
8271
8272 d = &info[0];
8273 for (i = 0, p = sho_p; p; p = p->next) {
8274 if (p->dai_top) {
8275 d = &info[i];
8276 if (i > 0) prev->next = d;
8277 prev = d;
8278 i++;
8279 }
8280 d->n++;
8281 d->hindo += p->hindo;
8282 d->ima += p->ima;
8283 d->jirilength += p->jirilength;
8284 d->sholength += p->bunlength;
8285 d->dictnice += p->dictnice;
8286 d->dailength = d->sholength;
8287 }
8288 return(info);
8289 }
8290
8291
8292 static int
wnn_set_area_body(buf,bun_no,area,kanjip)8293 wnn_set_area_body(buf, bun_no, area, kanjip)
8294 struct wnn_buf_mt *buf;
8295 register int bun_no;
8296 w_char *area;
8297 int kanjip;
8298 {
8299 register WNN_BUN *wb, *wb1;
8300 w_char *c, *end, *area1 = area;
8301 int len;
8302
8303 if ((kanjip != WNN_KANJI ) || (bun_no < 0) ||
8304 !(wb = buf->orig.bun[bun_no])) {
8305 return(0);
8306 }
8307
8308 for(wb1 = wb; ;){
8309 if(wb1 != wb) c = (w_char *)wb1;
8310 else c = wb1->yomi;
8311 end = (w_char *)&wb1->next;
8312 for(;c < end;){
8313 if(!kanjip){
8314 if((*c++ = *area++) == 0){ area--; goto out;}
8315 }else{
8316 if(*c++ == 0) kanjip--;
8317 }
8318 }
8319 if (!*end) {
8320 wb1->next = get_new_bun(buf);
8321 }
8322 wb1 = wb1->next;
8323 }
8324 out:
8325 wb1->next = NULL; /* 95/6/13 waya */
8326 len = area - area1;
8327 wb->kanjilen = wb->real_kanjilen = len;
8328 wb->jirilen = wb->yomilen;
8329 return 0;
8330 }
8331
8332 int
wnn_set_area(buf,bun_no,area,kanjip)8333 wnn_set_area(buf, bun_no, area, kanjip)
8334 struct wnn_buf *buf;
8335 register int bun_no;
8336 w_char *area;
8337 int kanjip;
8338 {
8339 int x;
8340
8341 if(!buf) return(0);
8342 LockMutex(&BUF_LOCK(buf));
8343 x = wnn_set_area_body((WNN_BUF_MT *)buf, bun_no, area, kanjip);
8344 UnlockMutex(&BUF_LOCK(buf));
8345 return x;
8346 }
8347
8348 /* --------------- for ikeiji ---------- */
8349 extern int js_ikeiji_with_data();
8350 int jl_zenikeiji_dai_with_hinsi_name();
8351
8352 /*:::DOC_START
8353 *
8354 * Function Name: jl_zenikeiji_dai
8355 * Description :
8356 * do ikeiji-henkan with some conditions
8357 *
8358 * Parameter :
8359 * buf : (InOut) kanji buffer
8360 * bun_no : (In) staring bun no.
8361 * bun_no2 : (In) ending bun no. (exclusive)
8362 * use_maep : (In) connective info.
8363 * uniq_level : (In) unique level
8364 *
8365 * Return value : no. of dai-bunsetsu
8366 *
8367 * Author : fujimori
8368 *
8369 * Revision history:
8370 * 20-Dec-94: initial release
8371 *
8372 *:::DOC_END
8373 */
8374 int
jl_zenikeiji_dai(buf,bun_no,bun_no2,use_maep,uniq_level)8375 jl_zenikeiji_dai(buf, bun_no, bun_no2, use_maep, uniq_level)
8376 register struct wnn_buf *buf;
8377 int bun_no, bun_no2, use_maep, uniq_level;
8378 {
8379 int nhinsi = 1; char hname[32];
8380 char * p_hname = &hname[0];
8381 int x;
8382 strcpy(hname, "�۷���");
8383 x = jl_zenikeiji_dai_with_hinsi_name(buf, bun_no, bun_no2, use_maep, uniq_level, nhinsi, &p_hname );
8384 return x;
8385 }
8386
8387 /*:::DOC_START
8388 *
8389 * Function Name: zen_conv_dai_ikeiji1
8390 * Description :
8391 * do ikeiji-henkan with some conditions
8392 *
8393 * Parameter :
8394 * buf : (InOut) kanji buffer
8395 * bun_no : (In) staring bun no.
8396 * bun_no2 : (In) ending bun no. (exclusive)
8397 * use_maep : (In) connective info.
8398 * uniq_level : (In) unique level
8399 * fuku : (In) fukugou-go
8400 * nhinsi : (In) no. of hinsi
8401 * hlist : (In) hinsi-list
8402 *
8403 * Return value : no. of dai-bunsetsu
8404 *
8405 * Author : fujimori
8406 *
8407 * Revision history:
8408 * 20-Dec-94: initial release
8409 *
8410 *:::DOC_END
8411 */
8412 static int
zen_conv_dai_ikeiji1(buf,bun_no,bun_no2,use_maep,uniq_level,fuku,nhinsi,hlist)8413 zen_conv_dai_ikeiji1(buf, bun_no, bun_no2, use_maep, uniq_level, fuku, nhinsi, hlist)
8414 register struct wnn_buf *buf;
8415 int bun_no, bun_no2, use_maep, uniq_level, fuku, nhinsi, *hlist;
8416 {
8417 register struct wnn_buf_mt *buf_m = (WNN_BUF_MT *)buf;
8418 int cnt;
8419 w_char yomi[LENGTHBUNSETSU], yomi1[LENGTHBUNSETSU];
8420 struct wnn_dai_bunsetsu *dp;
8421 int tmp;
8422 register int k;
8423 int x;
8424 int nobi_top;
8425 w_char yomi_orig[LENGTHBUNSETSU];
8426
8427 if(bun_no2 > (tmp = dai_end(buf_m, bun_no)) ||
8428 bun_no2 < 0) bun_no2 = tmp;
8429 jl_get_kanji_body(buf_m, bun_no, bun_no2, yomi);
8430 jl_get_yomi_body(buf_m, bun_no, bun_no2, yomi_orig);
8431
8432 if(bun_no == buf->zenkouho_bun && buf->zenkouho_daip == IKEIJI){
8433 x = buf->c_zenkouho;
8434 return x;
8435 }
8436 if (use_maep & WNN_USE_MAE && bun_no > 0) {
8437 dumbhinsi = buf->bun[bun_no - 1]->hinsi;
8438 jl_get_yomi_body(buf_m, bun_no - 1, bun_no, yomi1);
8439 mae_fzk = yomi1 + buf->bun[bun_no - 1]->jirilen;
8440 } else {
8441 dumbhinsi = WNN_BUN_SENTOU;
8442 mae_fzk = (w_char *)0;
8443 }
8444 if(use_maep & WNN_USE_ATO && bun_no2 < buf->bun_suu){
8445 syuutanv = buf->bun[bun_no2]->kangovect;
8446 syuutanv1 = WNN_VECT_KANZEN;
8447 buf->zenkouho_endvect = syuutanv;
8448 }else{
8449 syuutanv = WNN_VECT_KANZEN;
8450 syuutanv1 = WNN_VECT_NO;
8451 if(bun_no2 < buf->bun_suu){
8452 buf->bun[bun_no2]->dai_top = 1;
8453 }
8454 buf->zenkouho_endvect = -1;
8455 }
8456 if(!(buf->env)) return(-1);
8457 LockMutex(&(envmt->env_lock));
8458 if(fuku == 0 && nhinsi == 0) {
8459 /* ?? error for this henkan */
8460 #if 0
8461 if(buf->bun[bun_no]->fukugou == 0 && buf->bun[bun_no]->num_hinsi == 0) {
8462 if((cnt = js_kanzen_dai(buf->env, yomi, dumbhinsi, mae_fzk,
8463 syuutanv, syuutanv1, &buf_rb)) < 0){
8464 buf_wnn_errorno_copy(buf_m);
8465 if_dead_disconnect_b(buf_m);
8466 UnlockMutex(&(envmt->env_lock));
8467 return(-1);
8468 }
8469 } else {
8470 if((cnt = js_ikeiji_with_data(buf->env, buf->bun[bun_no]->fukugou,
8471 buf->bun[bun_no]->num_hinsi, buf->bun[bun_no]->hinsi_list,
8472 WNN_IKEIJI_DAI, yomi, dumbhinsi, mae_fzk, syuutanv,
8473 syuutanv1, WNN_VECT_BUNSETSU,
8474 /* need fugokugo-len, hinsi, etc */ buf->bun[bun_no], yomi_orig,
8475 &buf_rb)) < 0) {
8476 buf_wnn_errorno_copy(buf_m);
8477 if_dead_disconnect_b(buf_m);
8478 UnlockMutex(&(envmt->env_lock));
8479 return(-1);
8480 }
8481 }
8482 #else
8483 /* ?? need set
8484 buf_wnn_errorno_copy(buf_m);
8485 */
8486 if_dead_disconnect_b(buf_m);
8487 UnlockMutex(&(envmt->env_lock));
8488 return(-1);
8489 #endif /* 0 */
8490 } else {
8491 if((cnt = js_ikeiji_with_data(buf->env, fuku, nhinsi, hlist,
8492 WNN_IKEIJI_DAI, yomi, dumbhinsi, mae_fzk, syuutanv,
8493 syuutanv1, WNN_VECT_BUNSETSU,
8494 /* need fugokugo-len, hinsi, etc */ buf->bun[bun_no], yomi_orig,
8495 &buf_rb)) < 0) {
8496 buf_wnn_errorno_copy(buf_m);
8497 if_dead_disconnect_b(buf_m);
8498 UnlockMutex(&(envmt->env_lock));
8499 return(-1);
8500 }
8501 }
8502
8503 dp = (struct wnn_dai_bunsetsu *)buf_rb.buf;
8504
8505 free_zenkouho(buf_m);
8506 /* Wander if it is OK, that is, only when all the
8507 * zenkouho's are got from zenkouho_dai, we need not move
8508 * the current dai-bunsetsu to the top of zenkouho's
8509 */
8510 for(k = bun_no; k < bun_no2; k++){
8511 if(buf->bun[k]->from_zenkouho != ZENKOUHO_IKEIJI_DAI)break;
8512 }
8513 nobi_top = buf->bun[k]->nobi_top;
8514 if(k != bun_no2){ /* move the current to the top. */
8515 make_space_for(buf_m, ZENKOUHO, buf->zenkouho_suu, buf->zenkouho_suu,
8516 bun_no2 - bun_no);
8517 set_dai(&buf->bun[bun_no], &buf->zenkouho[0], bun_no2 - bun_no);
8518 buf->zenkouho_dai[0] = 0;
8519 buf->zenkouho_dai[1] = bun_no2 - bun_no;
8520 buf->zenkouho_dai_suu = 1;
8521 buf->zenkouho_suu = bun_no2 - bun_no;
8522 k = get_c_jikouho_dai(dp, cnt, buf->bun, bun_no);
8523 if(k >= 0){
8524 buf->zenkouho[0]->dai_top =
8525 (dp[k].sbn->status == WNN_CONNECT)? 0:1;
8526 buf->zenkouho[bun_no2-bun_no-1]->dai_end =
8527 (dp[k].sbn[dp[k].sbncnt-1].status_bkwd == WNN_CONNECT_BK)? 0:1;
8528 /* KURI *//* USO*?*/
8529 } else if (cnt == 0) {
8530 /* �֡��פϸ������ 0 �ʤΤǡ�dai_top, dai_end ��
8531 ����Ū�� 1 �ˤ��� */
8532 buf->zenkouho[0]->dai_top = 1;
8533 buf->zenkouho[bun_no2-bun_no-1]->dai_end = 1;
8534 }
8535 if(uniq_level || k < 0){
8536 insert_dai_or_ikeiji(buf_m, ZENKOUHO, -1, -1, dp, cnt, uniq_level, 0, 0, NULL, IKEIJI);
8537 }else{
8538 insert_dai_or_ikeiji(buf_m, ZENKOUHO, -1, -1, dp, k, uniq_level, 0, 0, NULL, IKEIJI);
8539 insert_dai_or_ikeiji(buf_m, ZENKOUHO, -1, -1, dp + k + 1, cnt - k - 1,
8540 uniq_level, 0, 0, NULL, IKEIJI);
8541 }
8542 buf->c_zenkouho = 0;
8543 }else{
8544 insert_dai_or_ikeiji(buf_m, ZENKOUHO, -1, -1, dp, cnt, uniq_level, 0, 0, NULL, IKEIJI);
8545 k = get_c_jikouho_from_zenkouho_dai(buf_m, buf->bun[bun_no]);
8546 if(k < 0){
8547 k = 0; /* Only when the kouho has been removed from dict. */
8548 }
8549 buf->c_zenkouho = k;
8550 }
8551 buf->zenkouho_bun = bun_no;
8552 buf->zenkouho_end_bun = bun_no2;
8553 buf->zenkouho_daip = IKEIJI;
8554 for(k = 0 ; k < buf->zenkouho_suu; k++){
8555 if(buf->zenkouho[k]->ima && buf->zenkouho[k]->dic_no != -1){
8556 add_down_bnst(buf_m, bun_no, buf->zenkouho[k]);
8557 }
8558 /*
8559 * ʸ�῭�Ф�/�̤��Ԥä��弡������ä����ˤϡ��������ʸ�����
8560 * �ˤ�ʸ�῭�Ф�/�̤�ξ����Ĥ��Ƥ�����ʸ���ڤ�ؽ��ǻ��Ѥ��롣
8561 */
8562 if (nobi_top) buf->zenkouho[k]->nobi_top = 1;
8563 }
8564 x = buf->c_zenkouho;
8565 UnlockMutex(&(envmt->env_lock));
8566 return x;
8567 }
8568
8569 /*:::DOC_START
8570 *
8571 * Function Name: jl_zenikeiji_dai_with_hinsi_name
8572 * Description :
8573 * do ikeiji-henkan with some conditions
8574 *
8575 * Parameter :
8576 * buf : (InOut) kanji buffer
8577 * bun_no : (In) staring bun no.
8578 * bun_no2 : (In) ending bun no. (exclusive)
8579 * use_maep : (In) connective info.
8580 * uniq_level : (In) unique level
8581 * nhinsi : (In) no. of hinsi-name
8582 * hname : (In) hinsi name-list
8583 *
8584 * Return value : no. of dai-bunsetsu
8585 *
8586 * Author : fujimori
8587 *
8588 * Revision history:
8589 * 20-Dec-94: initial release
8590 *
8591 *:::DOC_END
8592 */
8593 int
jl_zenikeiji_dai_with_hinsi_name(buf,bun_no,bun_no2,use_maep,uniq_level,nhinsi,hname)8594 jl_zenikeiji_dai_with_hinsi_name(buf, bun_no, bun_no2, use_maep, uniq_level, nhinsi, hname)
8595 register struct wnn_buf *buf;
8596 int bun_no, bun_no2, use_maep, uniq_level, nhinsi;
8597 char **hname;
8598 {
8599 int x, i, hsize, *hno = NULL;
8600 w_char tmp[64];
8601
8602 if(!buf) return(-1);
8603 LockMutex(&BUF_LOCK(buf));
8604 buf_wnn_errorno_set = 0;
8605 /* if(strncmp(js_get_lang(buf->env), WNN_J_LANG, 5) || nhinsi == 0) {
8606 UnlockMutex(&BUF_LOCK(buf));
8607 return(-1);
8608 } */
8609 if(nhinsi){
8610 hsize = abs(nhinsi);
8611 hno = (int *)malloc(hsize * sizeof(int));
8612 for(i = 0; i < hsize; i++) {
8613 _Sstrcpy(tmp, hname[i]);
8614 if((hno[i] = jl_hinsi_number_e(buf->env, tmp)) == -1) {
8615 free((char *)hno);
8616 UnlockMutex(&BUF_LOCK(buf));
8617 return(-1);
8618 }
8619 }
8620 }
8621 x = zen_conv_dai_ikeiji1(buf, bun_no, bun_no2, use_maep, uniq_level, 0, nhinsi, hno);
8622 if(nhinsi) free((char *)hno);
8623 UnlockMutex(&BUF_LOCK(buf));
8624 return x;
8625 }
8626 /* end of jl_zenikeiji_dai_with_hinsi_name */
8627
8628 /*:::DOC_START
8629 *
8630 * Function Name: insert_dai_or_ikeiji
8631 * Description :
8632 * insert dai-bunsetsu in to kanji-buffer
8633 *
8634 * Parameter :
8635 * buf : (InOut) kanji buffer
8636 * zenp : (In) zen-kouho type.
8637 * bun_no : (In) staring bun no.
8638 * bun_no2 : (In) ending bun no. (exclusive)
8639 * dp : (In) dai-bunsetsu
8640 * dcnt : (In) no. of dai-bunsetsu
8641 * uniq_level : (In) unique level
8642 * fuku : (In) fukugou-go
8643 * nhinsi : (In) no. of hinsi
8644 * hlist : (In) hinsi list
8645 * daip : (In) henkan type
8646 *
8647 * Return value : no. of dai-bunsetsu
8648 *
8649 * Author : fujimori
8650 *
8651 * Revision history:
8652 * 20-Dec-94: initial release
8653 *
8654 *:::DOC_END
8655 */
8656 /* from insert_dai */
8657 /* for zenkouho, assume bun_no = bun_no2 = zenkouho_suu */
8658 static int
insert_dai_or_ikeiji(buf,zenp,bun_no,bun_no2,dp,dcnt,uniq_level,fuku,nhinsi,hlist,daip)8659 insert_dai_or_ikeiji(buf, zenp, bun_no, bun_no2, dp, dcnt, uniq_level, fuku, nhinsi, hlist, daip)
8660 struct wnn_buf_mt *buf;
8661 int bun_no, bun_no2;
8662 struct wnn_dai_bunsetsu *dp;
8663 int dcnt;
8664 int zenp;
8665 int uniq_level;
8666 int fuku, nhinsi, *hlist;
8667 int daip;
8668 {
8669 register WNN_BUN **b, **b0;
8670 register int k, l, m;
8671 register int cnt = 0;
8672 struct wnn_sho_bunsetsu *sp, *sp1;
8673
8674 if(bun_no == -1){
8675 bun_no = bun_no2 = (zenp == BUN)? buf->orig.bun_suu: buf->orig.zenkouho_suu;
8676 }
8677
8678 for(k = 0; k < dcnt ; k++){
8679 cnt += dp[k].sbncnt;
8680 }
8681 make_space_for(buf, zenp, bun_no, bun_no2, cnt);
8682 /* zenkouho_dai_suu must not be initialized */
8683
8684 b = ((zenp == BUN)? buf->orig.bun: buf->orig.zenkouho) + bun_no;
8685
8686 for(k = 0, m = buf->orig.zenkouho_dai_suu ; k < dcnt; k++){
8687 /* �۷����Ѵ��κݤϡ�find_same_kouho_dai() ���ơ�
8688 ������ꥹ�ȤΥ��֥���ɤ� */
8689 if(uniq_level){
8690 if(find_same_kouho_dai(&dp[k], buf, m, uniq_level))
8691 continue;
8692 }
8693 sp = dp[k].sbn;
8694 if(zenp == ZENKOUHO){
8695 buf->orig.zenkouho_dai[m++] = b - buf->orig.zenkouho;
8696 }
8697 b0 = b;
8698 sp1 = sp;
8699 for(l = 0 ; l < dp[k].sbncnt; l++){
8700 *b = get_sho(buf, sp, zenp, daip, fuku, nhinsi, hlist);
8701 if(zenp == ZENKOUHO){
8702 if (l == dp[k].sbncnt -1){
8703 if(buf->orig.zenkouho_endvect != -1){
8704 (*b)->dai_end = (sp->status_bkwd == WNN_CONNECT_BK)? 0:1;
8705 }else{
8706 (*b)->dai_end = 0;
8707 }
8708 }else{
8709 (*b)->dai_end = 0;
8710 }
8711 }
8712 b++;
8713 sp++;
8714 }
8715 (*b0)->dai_top = (sp1->status == WNN_CONNECT)? 0:1;
8716 (*b0)->daihyoka = dp[k].hyoka;
8717 }
8718 if(zenp == ZENKOUHO){
8719 buf->orig.zenkouho_dai[m] = b - buf->orig.zenkouho;
8720 buf->orig.zenkouho_suu = b - buf->orig.zenkouho;
8721 buf->orig.zenkouho_dai_suu = m;
8722 }
8723 return(cnt + bun_no);
8724 }
8725
8726
8727 /*:::DOC_START
8728 *
8729 * Function Name: jl_set_ikeiji_dai
8730 * Description :
8731 * set current kouho
8732 *
8733 * Parameter :
8734 * buf : (InOut) kanji buffer
8735 * offset : (In) target bun no.
8736 *
8737 * Return value : current bun no.
8738 *
8739 * Author : fujimori
8740 *
8741 * Revision history:
8742 * 20-Dec-94: initial release
8743 *
8744 *:::DOC_END
8745 */
8746 /* ?? need, identical jl_set_jikouho_dai */
8747 int
jl_set_ikeiji_dai(buf,offset)8748 jl_set_ikeiji_dai(buf, offset)
8749 register struct wnn_buf *buf;
8750 int offset;
8751 {
8752 register int st, end, bun, k;
8753
8754 if(!buf) return(-1);
8755 LockMutex(&BUF_LOCK(buf));
8756 buf_wnn_errorno_set = 0;
8757 if(buf->zenkouho_suu <= 0) {
8758 UnlockMutex(&BUF_LOCK(buf));
8759 return(-1);
8760 }
8761 if(buf->zenkouho_daip == SHO){
8762 UnlockMutex(&BUF_LOCK(buf));
8763 return(-1);
8764 }
8765 offset = (offset + buf->zenkouho_dai_suu) % buf->zenkouho_dai_suu;
8766 if(buf->zenkouho_end_bun < buf->bun_suu && buf->zenkouho_endvect != -1)
8767 buf->bun[buf->zenkouho_end_bun]->dai_top =
8768 buf->zenkouho[buf->zenkouho_dai[offset+1]-1]->dai_end;
8769 free_bun((WNN_BUF_MT *)buf, buf->zenkouho_bun, buf->zenkouho_end_bun);
8770 st = buf->zenkouho_dai[offset];
8771 end = buf->zenkouho_dai[offset + 1];
8772 make_space_for((WNN_BUF_MT *)buf, BUN, buf->zenkouho_bun,
8773 buf->zenkouho_end_bun, end - st);
8774 for(bun = buf->zenkouho_bun, k = st; k < end;){
8775 set_sho(buf->zenkouho[k++], &buf->bun[bun++]);
8776 }
8777 buf->zenkouho_end_bun = buf->zenkouho_bun + end - st;
8778 buf->c_zenkouho = offset;
8779 UnlockMutex(&BUF_LOCK(buf));
8780 return(offset);
8781 }
8782
8783