1 /*
2  *  $Id: rk_main.c,v 1.4 2005/04/10 15:26:38 aonoto Exp $
3  */
4 
5 /*
6  * FreeWnn is a network-extensible Kana-to-Kanji conversion system.
7  * This file is part of FreeWnn.
8  *
9  * Copyright Kyoto University Research Institute for Mathematical Sciences
10  *                 1987, 1988, 1989, 1990, 1991, 1992
11  * Copyright OMRON Corporation. 1987, 1988, 1989, 1990, 1991, 1992, 1999
12  * Copyright ASTEC, Inc. 1987, 1988, 1989, 1990, 1991, 1992
13  * Copyright FreeWnn Project 1999, 2000
14  *
15  * Maintainer:  FreeWnn Project   <freewnn@tomo.gr.jp>
16  *
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2 of the License, or (at your option) any later version.
21  *
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  *
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the
29  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
30  * Boston, MA 02111-1307, USA.
31  */
32 
33 /***********************************************************************
34                         rk_main.c
35                                                 88. 6.10  �� ��
36 
37         ���޻������Ѵ�������¾�����ϥ����ɤ��Ѵ�����ץ���ࡣ
38         ASCII�����ɻ��Ѥ�����Ȥ��Ƥ��롣
39         ���Υե�����ϡ��Ѵ��Υᥤ��롼����
40 ***********************************************************************/
41 
42 #include "rk_header.h"
43 #include "rk_extvars.h"
44 #include "rk_fundecl.h"
45 
46 struct matchpair                /*    ���ߥޥå�����Ƥ����ѿ����ֹ�ȡ��ޥå�����ʸ����
47                                    �Ȥ��ݻ��� */
48 {
49   int hennum;
50   letter ltrmch;
51 };
52 
53 letter memory[SIZALL];          /* �Ѵ��б�ɽ�䡢�ѿ����Ѱ�ʤɤ�������ΰ� */
54 struct dat data[LINALL];        /* �б�ɽ�ΰ�Ԥ��ȤΥǡ����ؤΥݥ��� */
55 letter *hensudefhyo[VARTOT];    /* �ѿ����Ȥ��Ѱ�ǡ����ؤΥݥ��� */
56 struct matchpair henmatch[VARTOT];      /* �ѿ��Υޥå���������Ƥ��� */
57 
58 #ifdef KDSP
59 #  ifdef MVUX
60 letter displine[DSPLIN];        /* �ǥХå���  ɽ���ΰ��ʬ���� */
61 #  endif
62 #endif
63 
64 letter *curdis;
65 int codein_len;
66 letter *codeout, *remainkbf;
67 letter ungetc_buf = EOLTTR;     /* romkan_ungetc����ʸ�������Ƥ����Хåե� */
68 letter unnext_buf = EOLTTR;     /* romkan_unnext��            ��             */
69 
70 letter (*keyin_method) ();      /* ��������ؿ��Υ��ɥ쥹 */
71 int (*bytcnt_method) ();        /* �Х��ȥ�����ȴؿ��Υ��ɥ쥹 */
72 int (*kbytcnt_method) ();       /* �������ϲ���ѥХ��ȥ�����ȴؿ��Υ��ɥ쥹 */
73 char prv_modfnm[REALFN] = "\0"; /* �⡼��ɽ̾�����Ϥ��Υѥ�̾�ˤ���¸ */
74             /* ������꤬�����ø�! */
75 
76 #define DISOUT ((flags & RK_NONISE) ? rk_output : disout)
77  /* �ե饰���ͤ�romkan_init3()��������ꤵ�졢����RK_NONISE�ΥӥåȤ��ͤ�
78     ɸ���0�����ä�DISOUT��ɸ���ͤ�disout�������rk_output���Ѥ���ȡ���������
79     �ʽ���LTREOF�ˤ���ڽФ��ʤ���â�����������Ϥ������ɬ���������֤��褦��
80     ���Ƥ�����˸¤ꡢEOLTTR����֤��ˡ� */
81 
82 char eofflg;                    /* romkan_next()����LTREOF���褿�Ȥ��ˡ�romkan_henkan()���1
83                                    �ˤ��롣������ͤ���0�ʤ��Ѵ��б�ɽ��(error)��̵�뤷�ơ�
84                                    �ܽ����Хåե����̤���ꥳ���ɤ⡢����Ū���Ѵ������롣����
85                                    LTREOF���褿�������̤ˤ�����Ϥ�Ф��褦�˻��ꤵ��Ƥ����
86                                    ���ν�����Ԥ���â�������ν����ϵޤ����館���Դ����ˡ�����
87                                    �������eofflg��2�� */
88 
89 letter evalbuf[2][2][OUTSIZ];
90 char ebf_sw = 0;
91 letter saishu_out[OUTSIZ];
92 letter delchr, delchr2 = EOLTTR, nisedl;        /* DEL�Υ���饯������Ĥޤǻ��Ƥ� */
93 
94 modetyp chgmod (), incmod (), decmod ();
95 
96 
97 /* letter���֤��ؿ�������ڤ�����ʰ����ˤ�char�Τ�Τ⺮���äƤ���� */
98 
99 static letter mchedsrc ();
100 letter romkan_next (), romkan_unnext ();
101 letter romkan_getc (), romkan_ungetc (), *romkan_henkan ();
102 letter to_zenalpha (), to_zenhira (), to_zenkata ();
103  /* to_zenhira;kata �����������ʸ�����ޤȤ�ˤ��ʤ��� */
104 
105 void BUGreport ();
106 static void maeato_henkan (), add_at_eof (), rk_delete (), set_rubout (), mchevl (), codeout_chg (), ltrevlcpy ();
107 int match ();
108 static int p_eq (), hen_ikisrc (), henkan_ok (), rk_rst (), head_bytecount ();
109 extern void readdata (), romkan_reset (), hank_setup (), to_hankata (), to_digit (), dakuadd (), handakuadd (), allchgmod ();
110 extern int ltov ();
111 
112 static letter *
ltrcpy(lp1,lp2)113 ltrcpy (lp1, lp2)
114      letter *lp1, *lp2;
115 {
116   letter *org;
117 
118   org = lp1;
119   while ((*lp1++ = *lp2++) != EOLTTR);
120   return (org);
121 }
122 
123 #ifdef notuse
124 letter *
ltrncpy(lp1,lp2,n)125 ltrncpy (lp1, lp2, n)           /* ������'EOLTTR'���å� */
126      letter *lp1, *lp2;
127      int n;
128 {
129   letter *org;
130 
131   org = lp1;
132   for (; n; --n)
133     if (EOLTTR == (*lp1++ = *lp2++))
134       return (org);
135   *lp1 = EOLTTR;
136   return (org);
137 }
138 #endif
139 
140  /** letter����������˰�ʸ���Ĥʤ��� */
141 static letter *
ltr1cat(lp,l)142 ltr1cat (lp, l)
143      letter *lp, l;
144 {
145   letter *org;
146 
147   org = lp;
148   totail (lp);
149   *lp++ = l;
150   *lp = EOLTTR;
151   return (org);
152 }
153 
154  /** ʸ����������˰�ʸ���Ĥʤ��롣ltr1cat��char�� */
155 char *
chrcat(s,c)156 chrcat (s, c)
157      char *s, c;
158 {
159   char *org;
160 
161   org = s;
162   strtail (s);
163   *s++ = c;
164   *s = '\0';
165   return (org);
166 }
167 
168 static letter *
ltrcat(lp1,lp2)169 ltrcat (lp1, lp2)
170      letter *lp1, *lp2;
171 {
172   letter *org;
173 
174   org = lp1;
175   totail (lp1);
176   ltrcpy (lp1, lp2);
177   return (org);
178 }
179 
180  /** letter����lp2�γ����ǤκǾ�̥ӥåȤ�Ω�ƤƤ��顢lp1�θ��ˤĤʤ��롣*/
181 static letter *
bitup_ltrcat(lp1,lp2)182 bitup_ltrcat (lp1, lp2)
183      letter *lp1, *lp2;
184 {
185   letter *org;
186 
187   org = lp1;
188   totail (lp1);
189 
190   while ((*lp1 = *lp2++) != EOLTTR)
191     *lp1++ |= HG1BIT;
192          /** lp2 ���������ƤκǾ�̥ӥåȤ�Ω�Ƥ롣*lp2��NISEBP(rk_spclval.h
193              ��define)�ʤɤΤȤ��Ϻǽ餫��Ǿ�̤�Ω�äƤ뤫��褤 */
194 
195   return (org);
196 }
197 
198  /** ltrcat�������ȡ���̤�ʸ����������˥ݥ������äƤ�����*/
199 letter *
ltrgrow(lp1,lp2)200 ltrgrow (lp1, lp2)
201      letter *lp1, *lp2;
202 {
203   totail (lp1);
204   while ((*lp1 = *lp2++) != EOLTTR)
205     lp1++;
206   return (lp1);
207 }
208 
209 static int
ltrlen(lp)210 ltrlen (lp)
211      letter *lp;
212 {
213   letter *org;
214 
215   for (org = lp; *lp != EOLTTR; lp++);
216   return (lp - org);
217 }
218 
219  /**    letter����κǸ��ʸ���ؤΥݥ������֤���â����ʸ������Ф��Ƥ�
220         ���Τޤ��֤���*/
221 letter *
ltrend(lp)222 ltrend (lp)
223      letter *lp;
224 {
225   return ((*lp != EOLTTR) ? (lp + ltrlen (lp) - 1) : lp);
226 }
227 
228  /**    ʸ����κǸ��ʸ���ؤΥݥ������֤���ltrend()��char�ǡ�ltrend()��
229         Ʊ�͡���ʸ����ΤȤ������㤬���롣*/
230 char *
strend(s)231 strend (s)
232      char *s;
233 {
234   return (*s ? (s + strlen (s) - 1) : s);
235 }
236 
237 int
ltrcmp(lp1,lp2)238 ltrcmp (lp1, lp2)
239      letter *lp1, *lp2;
240 {
241   for (; *lp1 == *lp2; lp1++, lp2++)
242     if (*lp1 == EOLTTR)
243       return (0);
244   return (*lp1 > *lp2 ? 1 : -1);
245 }
246 
247 #ifdef notuse
248 int
ltrncmp(lp1,lp2,n)249 ltrncmp (lp1, lp2, n)
250      letter *lp1, *lp2;
251      int n;
252 {
253   for (; n && *lp1 == *lp2; n--, lp1++, lp2++)
254     if (*lp1 == EOLTTR)
255       return (0);
256   return (n == 0 ? 0 : (*lp1 > *lp2 ? 1 : -1));
257 }
258 
259 letter *
ltr_index(lp,l)260 ltr_index (lp, l)
261      letter l, *lp;
262 {
263   for (; *lp != EOLTTR; lp++)
264     if (*lp == l)
265       return (lp);
266   return (NULL);
267 }
268 #endif
269 
270 static letter *
ltr_rindex(lp,l)271 ltr_rindex (lp, l)
272      letter l, *lp;
273 {
274   letter *lp2;
275 
276   for (lp += ltrlen (lp2 = lp); lp2 != lp;)
277     if (*--lp == l)
278       return (lp);
279   return (NULL);
280 }
281 
282  /** ʸ�����������ʸ�����åȤ��롣*/
283 letter *
ltr1cut(lp)284 ltr1cut (lp)
285      letter *lp;
286 {
287   int l;
288 
289   if (0 == (l = ltrlen (lp)))
290     BUGreport (0);              /* Illegal POP */
291   *(lp + --l) = EOLTTR;
292   return (lp);
293 }
294 
295  /** letter�ΰ�ʸ����Ĺ������ʸ������Ѵ����� */
296 static letter *
ltr_to_ltrseq(lp,l)297 ltr_to_ltrseq (lp, l)
298      letter *lp, l;
299 {
300   *lp++ = l;
301   *lp-- = EOLTTR;
302   return (lp);
303 }
304 
305  /** char������letter���ļ��Ф���â��'\0'��EOLTTR���Ѥ��� */
306 /* *INDENT-OFF* */
307 letter
letterpick(lbfpptr)308 letterpick (lbfpptr)
309      uns_chr **lbfpptr;
310 /* *INDENT-ON* */
311 {
312   letter l = 0;
313   register int i;
314 
315   for (i = (*bytcnt_method) (*lbfpptr); i; i--)
316     l = (l << 8) + *(*lbfpptr)++;
317   return (l == 0 ? EOLTTR : l);
318 }
319 
320  /**    ���Ϥ��줿�����ɤ�ʸ��ñ�̤ˤޤȤ�롣â��EOF��LTREOF��rk_spclval.h
321         �ˤ�����ˤ��Ѥ��롣*/
322 /* *INDENT-OFF* */
323 letter
romkan_next()324 romkan_next ()
325 /* *INDENT-ON* */
326 {
327   letter in;
328   int i, n;
329   uns_chr c;
330 
331   /* unnext����Ƥ�����ϡ��������Ф��� */
332   if (unnext_buf != EOLTTR)
333     return (in = unnext_buf, unnext_buf = EOLTTR, in);
334 
335   if ((letter) EOF == (in = (*keyin_method) ()))
336     return (LTREOF);
337   c = (in &= 0xff);
338   n = (*kbytcnt_method) (&c);
339   for (i = 1; i < n; i++)
340     in = (in << 8) + ((*keyin_method) () & 0xff);
341   return (in);
342 }
343 
344  /*     letter��ʸ�� l ��char��ʸ�� c ����ӡ�����ɥޡ���Ʊ�Ρ�letter���
345     ����ɥޡ�����EOLTTR��char��Τ�'\0'�ˤ���פȤߤʤ��� */
346 #define ltrchreq(l, c) ((l) == ((c) != 0 ? (c) : EOLTTR))
347 
348  /** letter��ʸ�����char��ʸ�������� â���羮��Ӥ����ʤ��Ȥ��Ƥ�� */
349 int
ltrstrcmp(l,s)350 ltrstrcmp (l, s)
351      register letter *l;
352      register char *s;
353 {
354   for (; ltrchreq (*l, *s); l++, s++)
355     if (*s == 0)
356       return (0);
357   return ((*l < (uns_chr) * s || *l == EOLTTR) ? -1 : 1);
358 }
359 
360  /** �Ǹ�˥ޥå�����ʸ�� �Ĥޤ�urabuf�κǸ塣urabuf��������EOLTTR���֤� */
361 static letter
lastmch()362 lastmch ()
363 {
364   return (*(ltrend (urabuf)));
365 }
366 
367 /* end of 'letter' functions */
368 
369 
370 #ifdef  OMAKE
371  /** ��  ��  ��
372         �ԣ֥��˥�Τ�����ʰ����û���ޤ�ˡ����������������λ��Ϥɤ줫��ġ�
373         -1�ʤ����Ƥ���Ϥ�������ʳ��ʤ鲿����Ϥ��ʤ���������ξ��⡢�ǡ���
374         �θĿ����֤���*/
takeoka(i)375 takeoka (i)
376      int i;
377 {
378 #define OPIMAX (numberof(opinion))
379 
380   static char *opinion[] = {
381     "����ˡ�Υ����ɥ� �ѥ��ƥ�桼�ߡפ��ɤ����Ȥ���by�ݲ�",
382     "�ֵ�ư��Υ�����দ���פ��ϵ��Ԥ��ɤ����Ȥ���by����",
383     "����ˡ�Υ����� �ޥ����륨�ߡפ��ɤ����Ȥ���by�ݲ�",
384     "�ʻ��Ͱո��ˡ֥ޥ����륨�ߡ�������͡פ��ɤ����˥����by����",
385     "����ˡ��ŷ�� ���ꥣ�ߡ��ޥߡפ��ɤ����Ȥ���by�ݲ�",
386     "�֥���������פ��ɤ����Ȥ���by����",
387     "�֥ࡼ�ߥ�פ��ɤ����Ȥ���by����",
388     "�֥ޥ������פΥ��ɥ��ʡ����꡼�����ɤ����Ȥ���by����",
389     "�֥��ס����Ф���פ��ɤ����Ȥ���by��",
390     "�֤Ϥ���ʹ֥��㡼�ȥ륺�פ��ɤ����Ȥ���by�ٱ�",
391     "�ֱ���ε��Υƥå��ޥ�פ��ɤ����Ȥ���by����",
392     "���Ų��ʹ֥٥�פ��ɤ����Ȥ���by��",
393     "�֥���ץ��ξ����ϥ����פ��ɤ����Ȥ���by�ٱ�",
394     "�֤Ȥ��᤭�ȥ��ʥ��ȡפ��ɤ����Ȥ���by����",
395     "�֤������Υ��硼�פ��ɤ����Ȥ��ä��͡�byΩ�ڡʤĤ�����",
396     "�֤��ޤ��쥪��������ɡפ��ɤ����Ȥ���by����������",
397     "�֥��å�����ܡסʡ֥��å�����ܣǡפ�ޤ�ˤ��ɤ����Ȥ���by����",
398     "�֥ƥä����סʡ֤�����ҥ����פΤ��ȡˤ��ɤ����Ȥ���by����",
399     "�֥��������ޥ����ԥ졼���פ��ɤ����Ȥ���by����",
400     "�־�����������פ��ɤ����Ȥ���by����",
401     "����̩���⥴����㡼�פ��ɤ����Ȥ���by����",
402     "���������Ρˡ�Ŵ��28��פ��ɤ����Ȥ���by����"
403   };
404 
405   if (i >= 0)
406     printf ("%s\n", opinion[i % OPIMAX]);
407   else if (i == -1)
408     for (i = 0; i < OPIMAX; i++)
409       printf ("%s\n", opinion[i]);
410   return (OPIMAX);
411 }
412 #endif /* OMAKE */
413 
414 
415  /** �Ѵ��Хåե��Υ��ꥢ */
416 void
romkan_clear()417 romkan_clear ()
418 {
419 #ifdef KDSP
420 #  ifdef MVUX
421   *displine = EOLTTR;
422 #  endif
423 #endif
424   ungetc_buf = *keybuf = *urabuf = *disout = *rk_output = EOLTTR;
425   curdis = DISOUT;
426   lastoutlen = lastkbflen = 0;
427 }
428 
429  /**    ɽ���ɤ߹�����Ѵ��ν��������롣��part 1��*/
430 int
romkan_init(modhyo,delchr_,chmoutf,keyinfn,bytcntfn)431 romkan_init (modhyo, delchr_, chmoutf, keyinfn, bytcntfn)
432      char *modhyo, chmoutf;
433      letter delchr_;
434 letter (*keyinfn) ();
435      int (*bytcntfn) ();        /* �����ξܺ٤�romkan_init3���� */
436 {
437   return (romkan_init2 (modhyo, delchr_, chmoutf, keyinfn, bytcntfn, 0, 0, 0));
438 }
439 
440 #define ifflg(a, b) ((a) ? (b) : 0)
441 
442  /**    ɽ���ɤ߹�����Ѵ��ν��������롣��part 2: �������Ϥ��Ф�ɬ������
443         �֤��褦�ˤ��뤫�������Хåե����ꥢ���뤫�ɤ����ʤɤ����ġ�*/
444 int
romkan_init2(modhyo,delchr_,chmoutf,keyinfn,bytcntfn,keyackf,restartf,nonisecodf)445 romkan_init2 (modhyo, delchr_, chmoutf, keyinfn, bytcntfn, keyackf, restartf, nonisecodf)
446      char *modhyo, chmoutf, keyackf, restartf, nonisecodf;
447      letter delchr_;
448 letter (*keyinfn) ();
449      int (*bytcntfn) ();        /* �����ξܺ٤�romkan_init3���� */
450 {
451   return (romkan_init3 (modhyo, delchr_, toNISE (delchr_), EOLTTR,
452                         keyinfn, bytcntfn, (int (*)()) NULL, restartf, ifflg (chmoutf, RK_CHMOUT) | ifflg (keyackf, RK_KEYACK) | ifflg (nonisecodf, RK_NONISE) | RK_DSPNIL));
453 }
454 
455  /**    ɽ���ɤ߹�����Ѵ��ν��������롣��part 3��*/
456 int
romkan_init3(modhyo,delchr_,nisedl_,delchr2_,keyinfn,bytcntfn,kbytcntfn,restartf,flags_)457 romkan_init3 (modhyo, delchr_, nisedl_, delchr2_, keyinfn, bytcntfn, kbytcntfn, restartf, flags_)
458      char *modhyo;              /* �⡼�����ɽ��̾���Ϥ��Υѥ�̾ */
459      letter delchr_;            /* DEL�Ȥ��ƻȤ������� */
460      letter nisedl_;            /* ��DEL�Ȥ��ƻȤ������� */
461      letter delchr2_;           /* DEL�Ȥ��ƻȤ������ɤ���Ĥ����礽�Τ⤦���� */
462 letter (*keyinfn) ();           /* ��������ؿ� */
463      int (*bytcntfn) ();        /* �Х��ȥ�����ȴؿ� */
464      int (*kbytcntfn) ();       /* ��������β���ѥХ��ȥ�����ȴؿ���NULL����λ���
465                                    bytcntfn��Ʊ����Τ��Ȥ��� */
466      char restartf;
467  /*     rk_rst()�⤫��ƤФ줿����Ω�ĥե饰�����줬Ω�Ĥȡ��Хåե����ꥢ
468     �����˺Ѥޤ������λ��ϥ��顼���л��Υ�å������⾯���ۤʤ� */
469      int flags_;
470  /* �ʲ��Υե饰�����Ѳġ�������rk_spclval.h�ˤ������
471     RK_CHMOUT:�⡼�ɥ��������Τ餻�륳���ɤ��֤�����
472     RK_KEYACK:����������Ф�ɬ���������֤���
473     RK_DSPNIL:romkan_disp(off)mode�Υǥե���Ȥ��ʸ����ˤ��뤫
474     RK_NONISE:�������ɤ�Ф��ʤ��褦�ˤ��뤫
475     RK_REDRAW:Wnn���ü�ե饰��redraw�ѤΥե饰��Ф����ɤ�����
476     RK_SIMPLD:delete��ư���ñ��ˤ��뤫
477     RK_VERBOS:verbose�⡼�ɤǵ�������
478   */
479 {
480   int errcod;                   /* ���ν�1�Τ� */
481 
482   /* �������ɤ�Ф����������romkan_clear�ǻȤ��Τǡ��ե饰�������
483      ��ˤ�äƤ����ʤ��Ȥ����ʤ��� */
484   if ((flags = flags_) & RK_VERBOS)
485     {
486       fprintf (stderr, "romkan_init invoked.\r\n");
487       fflush (stderr);
488     }
489 
490 #ifdef  OMAKE
491   if (modhyo == NULL)
492     takeoka (-1);               /* ���ޤ����̾�ϼ¹Ԥ���ʤ� */
493 #endif /* OMAKE */
494 
495   keyin_method = keyinfn;
496   bytcnt_method = (bytcntfn == NULL ? head_bytecount : bytcntfn);
497   kbytcnt_method = (kbytcntfn == NULL ? bytcnt_method : kbytcntfn);
498   strcpy (prv_modfnm, modhyo);
499 
500   delchr = delchr_;
501   nisedl = nisedl_;
502   delchr2 = delchr2_;
503  /**    �¤�DEL�Υ���饯������Ĥޤǻ��Ƥ롣����ܡ�delchr2�ϡ�̤�����
504         �Ȥ����ͤ�EOLTTR�ˤ�̵�뤵��롣����ʳ��ϡ�delchr2�����Ϥ�����
505         delchr�����Ϥ��줿�Τ�Ʊ�����������롣*/
506 
507   if ((errcod = setjmp (env0)) != 0)
508     {
509       fprintf (stderr, "romkan_init failed.");
510       if (!restartf)
511         {
512           romkan_reset ();
513           /*     fprintf(stderr,
514              "No conversion is currently performed."); */
515           fprintf (stderr, "\r\n");
516         }
517       else
518         {
519           fprintf (stderr, "Conversion method was unchanged.\r\n");
520         }
521     }
522   else
523     {
524       readdata (memory, data, hensudefhyo, modhyo);
525       if (!restartf)
526         {
527           romkan_clear ();
528           hank_setup ();
529         }
530     }
531 
532   if (!errcod && (flags & RK_VERBOS))
533     {
534       fprintf (stderr, "romkan_init finished.\r\n");
535       fflush (stderr);
536     }
537   return (errcod);              /* ���ｪλ�ʤ�0 */
538 }
539 
540  /**    �Х��ȥ�����ȴؿ��Υǥե���ȡ�s�λؤ��Ƥ��������äƤ���Τ�
541         ���Х��ȥ����ɤ����֤���
542         romkan_next����ա�������Ǥϡ��Х��ȥ�����ȴؿ����ͤ�
543         �����ΰ�ʸ���ܤˤΤ߰�¸����Ȳ��ꤷ�Ƥ��롣*/
544 static int
head_bytecount(s)545 head_bytecount (s)
546      uns_chr *s;
547 {
548 #ifdef IKIS
549   return ((*s <= 0xa0 || *s == 0xff) ? 1 : 2);
550 #else
551   return (((*s <= 0xa0 && *s != HNKAK1) || *s == 0xff) ? 1 : 2);
552 #endif
553 }
554 
555  /** �Ѵ����줿ʸ����缡�֤� */
556 /* *INDENT-OFF* */
557 letter
romkan_getc()558 romkan_getc ()
559 /* *INDENT-ON* */
560 {
561   letter l;
562 
563   /* ungetc����Ƥ�����ϡ��������Ф��� */
564   if (ungetc_buf != EOLTTR)
565     return (l = ungetc_buf, ungetc_buf = EOLTTR, l);
566 
567   while (*curdis == EOLTTR)
568     {
569       /* romkan_next()���ͤ�LTREOF�λ��⡢���Τޤ�������ɤ��� */
570       curdis = romkan_henkan (romkan_next ());
571 
572       /* keyackflg����0�ʤ顢�������������ɬ�������֤�������
573          ���ᡢ�֤��٤���Τ��ʤ�����EOLTTR���֤����Ȥˤ��롣 */
574       if (flags & RK_KEYACK)
575         break;
576     }
577 
578   if (EOLTTR != (l = *curdis))
579     curdis++;
580   return (l);
581   /* ��ʪ��ʸ���ʤ顢HG1BIT��Ω�äƤ��롣 */
582   /* ���̤ʥ�����(�㤨�е���BEEP�Ȥ���NISEBP)���֤��Ȥ������롣������
583      rk_spclval.h���������Ƥ��롣 */
584 }
585 
586  /**    romkan_getc�β��̴ؿ��Ȥ��ơ����Ϥ��ʸ��������ä�
587         �Ѵ���̤�ʸ�������Ϥ��롣*/
588 letter *
romkan_henkan(mae_in)589 romkan_henkan (mae_in)
590      letter mae_in;
591 {
592   letter mae_out[2], *p;
593 
594   /* if(*curdis != EOLTTR){p = curdis; curdis = nil; return(p);} */
595   /* ������Ǥ�mae_in��̵�뤵��� */
596   curdis = nil;
597 
598   /* ����������ؤ����ϤϾ�ˤ�����ʸ�� */
599   mae_out[0] = mae_out[1] = EOLTTR;
600 
601   eofflg = rk_errstat = 0;
602   *rk_output = *disout = EOLTTR;
603 
604   maeato_henkan (mae_in, mae_out, usemaehyo);
605   rk_input = *mae_out;
606 
607   if (rk_input == LTREOF)
608     {
609       /* LTREOF���褿��硢(error)��̵�뤷���ܽ����Хåե���������
610          �����Ѵ����롣���Τ����eofflg��1�ˤ��롣���θ塢��̤�
611          �����ˡ�LTREOF���褿�������̥����ɡʻ��ꤵ��Ƥ���Сˤȡ�
612          LTREOF��Ĥʤ��� */
613       eofflg = 1;
614       match ();
615 
616       eofflg = 2;
617       add_at_eof ();            /* codeout�ˡ�LTREOF���褿���Ф������ɤ����롣 */
618       ltr1cat (codeout, LTREOF);
619 
620       ltrcat (disout, codeout);
621       ltrcat (rk_output, codeout);
622     }
623   else if (rk_input == EOLTTR)
624     {
625       /* EOLTTR���褿���⡢���Ʊ�ͤν�����Ԥ�����LTREOF��
626          �Ĥʤ��ʤ����ʤ��������romkan_getc()��Ƥ�Ǥ������
627          ������ʤ���romkan_next()��EOLTTR���֤��ʤ�����ˡ� */
628       eofflg = 1;
629       match ();
630     }
631   else if (rk_input == delchr || rk_input == delchr2)
632     {
633       /* delchr2��̤����ʤ餽���ͤ�EOLTTR�ʤΤ�rk_input���������ʤ��� */
634       rk_delete (rk_input);
635     }
636   else
637     {
638       ltr1cat (keybuf, rk_input);
639       ltr1cat (disout, toNISE (rk_input));
640       match ();
641     }
642 
643   if (!(flags & RK_CHMOUT))
644     {
645       /* chmoutflg��0�λ��ϡ�CHMSIG��Ф��ʤ��� */
646       for (p = DISOUT;; p++)
647         {
648           while (*p == CHMSIG)
649             ltrcpy (p, p + 1);
650           if (*p == EOLTTR)
651             break;
652         }
653     }
654 
655   if ((flags & RK_REDRAW) && NULL != (p = ltr_rindex (disout, nisedl)))
656     {
657       for (p++; *p != EOLTTR || (ltr1cat (disout, REDRAW), 0); p++)
658         if (!isSPCL (*p))
659           break;
660     }
661   /* wnn��redraw�Υե饰��Ω�äƤ��ơ�disout��nisedl�ʸ��ü쥳���ɤΤ�
662      �ǽ���äƤ����顢REDRAW��Ф��ơ�Wnn���Ѵ��Ԥ�redraw�����롣 */
663 
664   return (DISOUT);
665 }
666 
667 
668  /* �ǥХå��Ѵؿ� */
669 #ifdef KDSP
670 #  ifdef MVUX
671 
672 void
pridbg2(a,b,c)673 pridbg2 (a, b, c)
674      char *a, *c;
675      letter *b;
676 {
677   printf ("%s", a);
678   dump_fordbg (b);
679   printf ("%s", c);
680 }
681 
682 int
ltr_displen(l)683 ltr_displen (l)
684      letter l;
685 {
686   while (l >= 256)
687     l >>= 8;
688 
689   if (l == 0)
690     return (0);
691   if (l < ' ')
692     return (0);
693   if (168 <= l && l <= 170)
694     return (1);
695   return (l > 160 ? 2 : 1);
696 }
697 
698 void
dump_fordbg(lp)699 dump_fordbg (lp)
700      letter *lp;
701 {
702   while (*lp != EOLTTR)
703     printf ("%x/", *lp++);
704 }
705 
706 void
print_fordbg(lp)707 print_fordbg (lp)
708      letter *lp;
709 {
710   while (*lp != EOLTTR)
711     putletter (*lp++ & ~HG1BIT);
712 }
713 
714 void
print_ltrseq(lp)715 print_ltrseq (lp)
716      letter *lp;
717 {
718   while (*lp != EOLTTR)
719     print_ltr (*lp++ & ~HG1BIT);
720 }
721 
722 void
print_ltr(l)723 print_ltr (l)
724      letter l;
725 {
726   letter *disptail;
727   int i;
728 
729   if (!isSPCL (l))
730     l &= ~HG1BIT;
731 
732   if (l == CHMSIG)
733 #ifdef CHMDSP
734     printf ("...mode=%s\n", romkan_dispmode ())
735 #endif
736       ;
737   else
738 #define BEEPCH  '\007'
739 #define NEWLIN  '\n'
740   if (l == BEEPCH || l == NISEBP)
741     putchar (BEEPCH);
742   else if (l == NEWLIN)
743     {
744       *displine = *keybuf = *urabuf = EOLTTR;
745       lastoutlen = lastkbflen = 0;
746       putchar (l);
747     }
748   else if (l == delchr || l == nisedl)
749     {
750       if (*displine == EOLTTR)
751         putchar (BEEPCH);
752       else
753         {
754           disptail = ltrend (displine);
755           for (i = ltr_displen (*disptail); i; i--)
756             printf ("\031 \031");
757           *disptail = EOLTTR;
758         }
759     }
760   else
761     {
762       ltr1cat (displine, l);
763       putletter (l);
764     }
765 }
766 
767 #  endif /* of #ifdef MVUX */
768 #endif
769 /* �ǥХå��Ѵؿ������ */
770 
771 
772  /** DEL�����Ϥ��줿�Ȥ��ν������� */
773 static void
rk_delete(input_del)774 rk_delete (input_del)
775      letter input_del;
776 {
777   if (ltrlen (keybuf) > ((flags & RK_SIMPLD) ? 0 : lastkbflen))
778     {
779       ltr1cut (keybuf);
780       set_rubout (disout, 1, nisedl);
781     }
782   else
783     {
784       if (*urabuf != EOLTTR && !(flags & RK_SIMPLD))
785         {
786           ltr1cut (ltrcpy (keybuf, urabuf));
787           *urabuf = EOLTTR;
788 
789           set_rubout (rk_output, lastoutlen, input_del);
790 
791           set_rubout (disout, lastkbflen, nisedl);
792           bitup_ltrcat (ltrcat (disout, rk_output), keybuf);
793 
794           lastkbflen = lastoutlen = 0;
795         }
796       else
797         {
798           set_rubout (disout, 1, input_del);
799           set_rubout (rk_output, 1, input_del);
800         }
801     }
802 }
803 
804  /**    letter���� lp1 �� lp2 �Υޥå����ߤ롣���ͤϡ�lp1��lp2��Ƭ����
805         ���פλ� -1��lp1�ޤ��Ϥ���Ƭ����lp2�����פΤȤ��ϰ���Ĺ��lp2��
806         ��ʸ����λ���ޤࡣ���ξ�����ͤ�0�ˡ�����ʳ��� -2��
807         lp2¦�˼����ޤޤ�Ƥ�����ɾ�����롣lp1¦�ˤϼ���ޤ�ǤϤ��� */
808 static int
prefixp(lp1,lp2)809 prefixp (lp1, lp2)
810      letter *lp1, *lp2;
811 {
812   /* 1�ԥޥå������뤴�Ȥˡ��ޤ�match������ꥢ���Ƥ��顣
813      �Ĥޤꡢhenmatch[0] . ltrmch = EOLTTR; �Ȥ��Ƥ����� */
814 
815   register int mch_len = 0, d_len;
816 
817   for (;;)
818     {
819       if (*lp2 == EOLTTR)
820         return (mch_len);
821       if (*lp1 == EOLTTR)
822         return (-1);
823       if ((d_len = p_eq (&lp2, &lp1)) < 0)
824         return (d_len);
825       mch_len += d_len;
826     }
827 }
828 
829  /** num���ܤ��ѿ������ˤ���ʸ���ȥޥå����Ƥ���Ȳ��ꤷ�ơ�����ʸ�����֤� */
830 static letter
mchedsrc(num)831 mchedsrc (num)
832      int num;
833 {
834   struct matchpair *pairptr;
835 
836   for (pairptr = henmatch; pairptr->ltrmch != EOLTTR; pairptr++)
837     {
838       if (num == pairptr->hennum)
839         return (pairptr->ltrmch);
840     }
841   return (BUGreport (8), 0);
842 }
843 
844  /**    num���ܤ��ѿ���ʸ�� l �ȥޥå����뤫Ĵ�٤롣�����ѿ���unbound���ä�
845         ���� l ��bind���롣�ޥå�������(bind�λ���ޤ�)1�����ʤ���0���֤� */
846 static int
mchsrc(num,l)847 mchsrc (num, l)
848      int num;
849      letter l;
850 {
851   struct matchpair *pairptr;
852 
853   if (hen_ikisrc (num, l) == 0)
854     return (0);
855   for (pairptr = henmatch; pairptr->ltrmch != EOLTTR; pairptr++)
856     {
857       if (num == pairptr->hennum)
858         return (pairptr->ltrmch == l);
859     }
860 
861   pairptr->ltrmch = l;
862   pairptr->hennum = num;
863   (++pairptr)->ltrmch = EOLTTR;
864   return (1);
865 }
866 
867  /**    l1p�����ñ�̤��ä�ɾ������ʸ��l2�Ȱ��פ��뤫�ɤ������֤���ɾ������
868         ��̤���ʸ���ˤʤ�ʤ��ä��顢�������פ��ʤ���*/
869 static int
l_eq(l1p,l2)870 l_eq (l1p, l2)
871      letter *l1p, l2;
872 {
873   letter evlrsl[RSLMAX];
874 
875   switch (SHUBET (*l1p))
876     {
877     case 0:
878       return (*l1p == l2);
879     case 1:
880       return (mchsrc ((int) LWRMSK (*l1p), l2));
881     case 2:
882       mchevl (&l1p, evlrsl);
883       return (evlrsl[0] == l2 && evlrsl[1] == EOLTTR);
884     default:
885       return (BUGreport (1), 0);
886     }
887 }
888 
889  /**    prefixp��ǻ���  â�������ν���ϵա����ʤ�������ޤޤ줦��Τ�l1pp¦
890         �Τߡ�l1pp�����ñ�̤֤��ä�ɾ��������Τ�l2pp�Υޥå����ߤ롣����
891         ��l2pp�ޤ��Ϥ���Ƭ���ȥޥå�����а���Ĺ���֤���l1pp��ɾ����̤���ʸ��
892         ��λ���ޤࡣ���ξ�����ͤ�0�ˡ��դ�l1pp��ɾ����̤�Ƭ����l2pp���ޥ�
893         ���������� -1���֤����ޥå������Ԥ��������ͤ� -2��*/
894 static int
p_eq(l1pp,l2pp)895 p_eq (l1pp, l2pp)
896      register letter **l1pp, **l2pp;
897 {
898   int num;
899   letter evlrsl[RSLMAX], *rslptr;
900   register int retval = -2;
901 
902   /*  l2pp¦�ˤϼ���ޤޤʤ�Ȧ */
903   if (!is_HON (**l2pp))
904     {
905       /*  if(is_HON(**l1pp)) retval = p_eq(l2pp, l1pp); else  */
906       BUGreport (9);
907     }
908   else
909     {
910       switch (SHUBET (**l1pp))
911         {
912         case 0:         /* ʸ��Ʊ�� */
913           retval = (*(*l1pp)++ == *(*l2pp)++ ? 1 : -2);
914           break;
915         case 1:         /* �ѿ���ʸ�� */
916           num = LWRMSK (*(*l1pp)++);
917           retval = (mchsrc (num, *(*l2pp)++) ? 1 : -2);
918           break;
919         case 2:         /* ����ʸ�� */
920           mchevl (l1pp, rslptr = evlrsl);
921           for (retval = 0; *rslptr != EOLTTR; retval++)
922             {
923               if (**l2pp == EOLTTR)
924                 {
925                   retval = -1;
926                   break;
927                 }
928               else if (*rslptr++ != *(*l2pp)++)
929                 {
930                   retval = -2;
931                   break;
932                 }
933             }
934           break;
935         default:
936           BUGreport (2);
937         }
938     }
939 
940   return (retval);
941 }
942 
943  /** l1p�����ñ��ɾ������l2p������� */
944 static void
mchevl(l1pp,l2p)945 mchevl (l1pp, l2p)
946      letter **l1pp, *l2p;
947 {
948   letter *l1p, tmpevl[RSLMAX];
949 
950   l1p = *l1pp;
951 
952   switch (SHUBET (*l1p))
953     {
954     case 0:
955       *l2p++ = *l1p++;
956       break;
957     case 1:
958       *l2p++ = mchedsrc ((int) LWRMSK (*l1p++));
959       break;
960     case 2:                     /* toupper, tolower, error, �� */
961       switch (LWRMSK (*l1p++))
962         {
963         case 2:
964           mchevl (&l1p, tmpevl);
965           *l2p++ = to_upper (*tmpevl);
966           break;
967         case 3:
968           mchevl (&l1p, tmpevl);
969           *l2p++ = to_lower (*tmpevl);
970           break;
971         case 4:
972           *l2p++ = CHMSIG;
973           *l2p++ = LWRMSK (*l1p++);
974           *l2p++ = 0;
975           break;                /* EOL�ǤϤʤ� */
976         case 5:
977           *l2p++ = CHMSIG;
978           *l2p++ = LWRMSK (*l1p++);
979           *l2p++ = 1;
980           break;
981         case 6:
982           *l2p++ = CHMSIG;
983           *l2p++ = XY2INT (2, LWRMSK (*l1p++));
984           *l2p++ = 1;
985           break;
986         case 7:
987           mchevl (&l1p, tmpevl);
988           *l2p++ = to_updown (*tmpevl);
989           break;
990         case 8:
991           mchevl (&l1p, tmpevl);
992           *l2p++ = to_zenalpha (*tmpevl);
993           break;
994         case 9:
995           mchevl (&l1p, tmpevl);
996           *l2p++ = to_hira (*tmpevl);
997           break;
998         case 10:
999           mchevl (&l1p, tmpevl);
1000           *l2p++ = to_kata (*tmpevl);
1001           break;
1002         case 11:
1003           mchevl (&l1p, tmpevl);
1004           to_hankata (*tmpevl, &l2p);
1005           break;                /* �ü� */
1006         case 12:
1007           mchevl (&l1p, tmpevl);
1008           *l2p++ = to_zenhira (*tmpevl);
1009           break;
1010         case 13:
1011           mchevl (&l1p, tmpevl);
1012           *l2p++ = to_zenkata (*tmpevl);
1013           break;
1014         case 14:
1015           mchevl (&l1p, tmpevl);
1016           *l2p = *tmpevl;
1017           mchevl (&l1p, tmpevl);
1018           *l2p += *tmpevl;
1019           LWRCUT (*l2p++);
1020           break;
1021         case 15:
1022           mchevl (&l1p, tmpevl);
1023           *l2p = *tmpevl;
1024           mchevl (&l1p, tmpevl);
1025           *l2p -= *tmpevl;
1026           LWRCUT (*l2p++);
1027           break;
1028         case 16:
1029           mchevl (&l1p, tmpevl);
1030           *l2p = *tmpevl;
1031           mchevl (&l1p, tmpevl);
1032           *l2p *= *tmpevl;
1033           LWRCUT (*l2p++);
1034           break;
1035         case 17:
1036           mchevl (&l1p, tmpevl);
1037           *l2p = *tmpevl;
1038           mchevl (&l1p, tmpevl);
1039           if (!*tmpevl)
1040             *l2p = LTRHUG;
1041           else
1042             *l2p /= *tmpevl;
1043           LWRCUT (*l2p++);
1044           break;
1045         case 18:
1046           mchevl (&l1p, tmpevl);
1047           *l2p = *tmpevl;
1048           mchevl (&l1p, tmpevl);
1049           if (!*tmpevl)
1050             *l2p = LTRHUG;
1051           else
1052             *l2p %= *tmpevl;
1053           LWRCUT (*l2p++);
1054           break;
1055           /* 19��21��30�ϡ������������ȶ�ʸ����
1056              �����Ǥʤ���UNUSDC��ʸ����Ȥ����֤��� */
1057         case 19:
1058           mchevl (&l1p, tmpevl);
1059           if (lastmch () != *tmpevl)
1060             *l2p++ = UNUSDC;
1061           break;
1062         case 20:
1063           if (!modesw[LWRMSK (*l1p++)].curmode)
1064             *l2p++ = UNUSDC;
1065           break;
1066         case 21:
1067           if (modesw[LWRMSK (*l1p++)].curmode)
1068             *l2p++ = UNUSDC;
1069           break;
1070         case 22:
1071           *l2p++ = REASIG;
1072           break;
1073         case 23:
1074           *l2p++ = delchr;
1075           break;
1076         case 24:
1077           *l2p++ = CHMSIG;
1078           *l2p++ = XY2INT (1, 0);
1079           /* ����ǡ�all�פ�ɽ�� */
1080           *l2p++ = 0;
1081           break;
1082         case 25:
1083           *l2p++ = CHMSIG;
1084           *l2p++ = XY2INT (1, 0);
1085           *l2p++ = 1;
1086           break;
1087         case 26:
1088           mchevl (&l1p, tmpevl);
1089           *l2p = *tmpevl;
1090           mchevl (&l1p, tmpevl);
1091           *l2p &= *tmpevl;
1092           LWRCUT (*l2p++);
1093           break;
1094         case 27:
1095           mchevl (&l1p, tmpevl);
1096           *l2p = *tmpevl;
1097           mchevl (&l1p, tmpevl);
1098           *l2p |= *tmpevl;
1099           LWRCUT (*l2p++);
1100           break;
1101         case 28:
1102           mchevl (&l1p, tmpevl);
1103           *l2p = ~(*tmpevl);
1104           LWRCUT (*l2p++);
1105           break;
1106         case 29:
1107           *l2p++ = URBFCL;
1108           break;
1109         case 30:
1110           if (eofflg != 2 || *keybuf != EOLTTR)
1111             *l2p++ = UNUSDC;
1112           break;
1113         case 31:
1114           {
1115             letter code, basenum;
1116 
1117             mchevl (&l1p, tmpevl);
1118             code = *tmpevl;
1119             mchevl (&l1p, tmpevl);
1120             if ((basenum = *tmpevl) <= 1 || BASEMX < basenum)
1121               basenum = 10;
1122             to_digit (code, basenum, &l2p);
1123           }
1124           break;
1125         case 32:
1126           mchevl (&l1p, tmpevl);
1127           dakuadd (*tmpevl, &l2p);
1128           break;                /* �ü� */
1129         case 33:
1130           mchevl (&l1p, tmpevl);
1131           handakuadd (*tmpevl, &l2p);
1132           break;                /* �ü� */
1133         case 34:
1134           mchevl (&l1p, tmpevl);
1135           *l2p++ = ltov (*tmpevl);
1136           break;
1137         case 35:
1138           *l2p++ = ERRCOD;
1139           break;
1140           /* case 36: omitted */
1141         case 37:
1142           *l2p++ = CHMSIG;
1143           *l2p++ = LWRMSK (*l1p++);
1144           *l2p++ = *l1p++;
1145           break;
1146         case 38:
1147           *l2p++ = CHMSIG;
1148           *l2p++ = XY2INT (2, LWRMSK (*l1p++));
1149           *l2p++ = *l1p++;
1150           break;
1151         case 39:
1152           *l2p++ = CHMSIG;
1153           *l2p++ = XY2INT (3, LWRMSK (*l1p++));
1154           *l2p++ = *l1p++;
1155           break;
1156         case 40:
1157           {
1158             letter modnum;
1159 
1160             modnum = LWRMSK (*l1p++);
1161             if (modesw[modnum].curmode != *l1p++)
1162               *l2p++ = UNUSDC;
1163             break;
1164           }
1165         case 41:
1166           {
1167             letter modnum;
1168 
1169             modnum = LWRMSK (*l1p++);
1170             if (modesw[modnum].curmode == *l1p++)
1171               *l2p++ = UNUSDC;
1172             break;
1173           }
1174         case 42:
1175           {
1176             letter modnum;
1177 
1178             modnum = LWRMSK (*l1p++);
1179             if (modesw[modnum].curmode >= *l1p++)
1180               *l2p++ = UNUSDC;
1181             break;
1182           }
1183         case 43:
1184           {
1185             letter modnum;
1186 
1187             modnum = LWRMSK (*l1p++);
1188             if (modesw[modnum].curmode <= *l1p++)
1189               *l2p++ = UNUSDC;
1190             break;
1191           }
1192         case 44:
1193           mchevl (&l1p, tmpevl);
1194           *l2p++ = SENDCH;
1195           *l2p++ = *tmpevl;
1196           break;
1197         default:                /* case 0�ڤӾ嵭�ʳ� */ ;
1198           BUGreport (7);
1199         }
1200     }
1201 
1202   *l2p = EOLTTR;
1203   *l1pp = l1p;
1204 }
1205 
1206  /** num���ܤ��ѿ����Ѱ褬ʸ�� l ��ޤफ�ɤ������֤� */
1207 static int
hen_ikisrc(num,l)1208 hen_ikisrc (num, l)
1209      int num;
1210      letter l;
1211 {
1212   letter *defptr;
1213 
1214   defptr = hyo_n[hyonum].hensudef[num];
1215   if (*defptr == VARRNG)
1216     {
1217       for (defptr++; *defptr != EOLTTR;)
1218         if (*defptr++ <= l && l <= *defptr++)
1219           return (1);
1220       return (0);
1221     }
1222 
1223   for (; *defptr != EOLTTR; defptr++)
1224     {
1225       if (l == *defptr)
1226         return (1);
1227     }
1228   return (0);
1229 }
1230 
1231  /**    �Ѵ��Υᥤ��롼�����ܽ�����Ԥ������Ĥ��Ǥ˸�������äƤ��롣
1232         ���ʤߤ��������ϡ�romkan_getc�β��̴ؿ�romkan_henkan����ǡ�
1233         ���δؿ���Ƥ����ˤ�äƤ��롣
1234         ���δؿ��ϡ�romkan_next�����ʸ������٤˸ƤФ�롣�ƤӽФ��줿ľ���
1235         output�϶�ʸ����disout�ˤ����ϥ����ɰ�ʸ�������äƤ��롣
1236         ���δؿ���������ʸ��������romkan_henkan���Ϥꡢ
1237         romkan_getc�ϡ������ʸ�����Ȥ�ʬ�����֤���
1238         (error)�ǥ��顼�������������줿����0���֤������ｪλ����1���֤� */
1239 int
match()1240 match ()
1241 {
1242   int henkanflg = 0, okcode = 0, chm_exist;
1243   letter *p;
1244   letter urabufcreate[KBFSIZ], orgkeybuf[KBFSIZ], kbftail[KBFSIZ];
1245   letter *urabufjunbi, *outcutptr, *dis_end;
1246 
1247   if (*keybuf == EOLTTR)
1248     {
1249       *urabuf = EOLTTR;
1250       return (1);
1251     }
1252 
1253   ltrcpy (urabufjunbi = orgkeybuf, keybuf);
1254   outcutptr = rk_output;
1255 
1256   while ((okcode = henkan_ok ()) > 0)
1257     {
1258       henkanflg = 1;
1259 
1260       codeout_chg ();
1261       ltrcat (rk_output, codeout);
1262 
1263       ltrcpy (kbftail, keybuf + codein_len);
1264       ltrcat (ltrcpy (keybuf, remainkbf), kbftail);
1265 
1266       if (okcode == 2)
1267         {
1268           ltrcpy (urabufjunbi = urabufcreate, keybuf);
1269           totail (outcutptr);
1270         }
1271     }
1272 
1273   if (okcode == 0)
1274     {
1275       ltr1cut (ltrcpy (keybuf, orgkeybuf));
1276       ltr_to_ltrseq (disout, NISEBP);
1277       *rk_output = EOLTTR;
1278       return (0);
1279     }
1280   if (henkanflg)
1281     {
1282       ltrcpy (urabuf, urabufjunbi);
1283 
1284       set_rubout (disout, ltrlen (orgkeybuf) - 1, nisedl);
1285 
1286       dis_end = disout;
1287       totail (dis_end);
1288       ltrcpy (dis_end, rk_output);
1289 
1290       /* �⡼�ɥ�������ľ�����Τ餻�뤿�� CHMSIG�����
1291          ��flags���RK_CHMOUT��Ω�äƤʤ��ȡ����Ȥǰ�ʸ�����Ĥ�
1292          ʬ��������ǡ�CHMSIG���åȡˡ�
1293          â����rk_output����ϡ�CHMSIG��ȴ����
1294          �ޤ���CHMSIG�������ˣ��������Ϥ��ʤ�
1295          �ʣ���ʾ夢�äƤ⡢����ˤޤȤ�ơ��������֤��ˡ� */
1296       for (chm_exist = 0, p = rk_output;; p++)
1297         {
1298           while (*p == CHMSIG)
1299             {
1300               chm_exist = 1;
1301               if (ltrcpy (p, p + 1) < outcutptr)
1302                 outcutptr--;
1303             }
1304           if (*p == EOLTTR)
1305             break;
1306         }
1307       if (chm_exist)
1308         {
1309           /* CHMSIG���ĤˤޤȤ᤿��Τ�dis_end�ˤĤʤ�ľ����
1310              ����ifʸ���åȤ���С�CHMSIG�ΤȤ�ޤȤ�Ϥ��ʤ� */
1311           ltr1cat (ltrcpy (dis_end, rk_output), CHMSIG);
1312         }
1313 
1314       bitup_ltrcat (disout, keybuf);
1315       lastoutlen = ltrlen (outcutptr);
1316       lastkbflen = ltrlen (keybuf);
1317     }
1318   return (1);
1319 }
1320 
1321  /**    LTREOF�����ä��Ȥ��ˡ������Ф��褦�˻��ꤵ��Ƥ��뤫Ĵ�٤ơ�
1322         codeout���η�̤�ʸ����ʻ��꤬�ʤ��ä����������ˤ˥ݥ���Ȥ��롣
1323         Ķ�ޤ����館�ǡ��ü쥳�������ϰ���̵�뤹�롣*/
1324 static void
add_at_eof()1325 add_at_eof ()
1326 {
1327   register struct dat *datptr;
1328   register int i;
1329   int hyoseq;
1330   letter evlrsl[RSLMAX], *p;
1331 
1332   for (hyoseq = 0; (hyonum = usehyo[hyoseq]) != -1; hyoseq++)
1333     {
1334       for (i = 0, datptr = hyo_n[hyonum].data; NULL != (p = datptr[i].code[0]); i++)
1335         {
1336           henmatch[0].ltrmch = EOLTTR;
1337           while (*p != EOLTTR)
1338             {
1339               switch (SHUBET (*p))
1340                 {
1341                 case 0: /* ʸ�� */
1342                 case 1: /* �ѿ� */
1343                   /* ����餬������ϡ�NULL�Ȥ�
1344                      �ޥå������ʤ��� */
1345                   goto Pass;
1346                 case 2: /* �� */
1347                   mchevl (&p, evlrsl);
1348                   if (*evlrsl != EOLTTR)
1349                     goto Pass;
1350                   /* ���ϥ��������ˡ�ɾ�������
1351                      ��ʸ����ˤʤ��Τ���¾�ˤϤʤ�
1352                      ���Ȥ����� */
1353                 }
1354             }
1355 
1356           ltrevlcpy (codeout = p = evalbuf[0][0], datptr[i].code[1]);
1357           while (*p != EOLTTR)
1358             {
1359               if (isSPCL (*p))
1360                 ltrcpy (p, p + 1);
1361               else
1362                 p++;
1363             }
1364           codeout_chg ();
1365           return;
1366 
1367         Pass:;
1368         }
1369     }
1370   codeout = nil;
1371 }
1372 
1373  /**    ���ޥå����ߤ롣���ͤϡ��ޥå����Ƴ��ꤷ�����1�ʥ⡼�ɥ�������
1374         �����äƤ������2�ˡ��ޥå�������̤����λ�-1���ޥå����ʤ��ä���0��
1375         �¹���ϡ��ѿ� l �ˡ�����ޤǤ˰��פ���Ĺ���κǹ⵭Ͽ������Ƥ��ꡢ
1376         ���Ĺ�����פ����Τ����Ĥ��뤴�Ȥˡ�����������롣l���ͤϡ��ޥå�
1377         ���Ƥ��Ƥ�0�ˤʤ뤳�Ȥ⤢�롣p_eq() �ڤ� prefixp() �����ʸ���ȡ�*/
1378 static int
henkan_ok()1379 henkan_ok ()
1380 {
1381   register struct dat *datptr;
1382   register int i, k;
1383   int l, j, hyoseq;
1384   char urabuf_clrf;             /* �⡼�ɥ������ʤɤǡ�urabuf���ꥢ����ɬ�פ�
1385                                    ���������Ϥ��줬Ω�������η�̡�henkan_ok()
1386                                    ��1���֤��٤��Ȥ����2���֤���������ơ�
1387                                    match()��urabuf�ʤɤ�Ĵ�����롣 */
1388   register letter *p;
1389 
1390   if (*keybuf == EOLTTR)
1391     return (-1);
1392 
1393   for (l = -1, hyoseq = 0; (hyonum = usehyo[hyoseq]) != -1; hyoseq++)
1394     {
1395       for (i = 0, datptr = hyo_n[hyonum].data; NULL != (p = datptr[i].code[0]); i++)
1396         {
1397           henmatch[0].ltrmch = EOLTTR;
1398           switch (k = prefixp (keybuf, p))
1399             {
1400             case -2:
1401               break;
1402             case -1:
1403               if (eofflg != 0)
1404                 break;
1405               /* eofflg��Ω�äƤ����顢̤����β�ǽ����
1406                  �ΤƤ롣 */
1407 
1408               return (-1);
1409             default:
1410               if (k > l)
1411                 {
1412                   ebf_sw = !ebf_sw;
1413                   for (j = 1; j <= 2; j++)
1414                     {
1415                       ltrevlcpy (evalbuf[ebf_sw][j - 1], datptr[i].code[j]);
1416                     }
1417 
1418                   l = k;
1419                 }
1420             }
1421         }
1422     }
1423 
1424   if (l >= 0)
1425     {
1426       codein_len = l;
1427       codeout = evalbuf[ebf_sw][0];
1428       remainkbf = evalbuf[ebf_sw][1];
1429 
1430       for (urabuf_clrf = 0, p = codeout; *p != EOLTTR;)
1431         {
1432           switch (*p)
1433             {
1434             case CHMSIG:
1435               p++;
1436               /* codeout��1�Х����ܤ˴ؿ��Υ����å��ȥ⡼���ֹ桢
1437                  2�Х����ܤ˥⡼�ɤο����֤����äƤ� */
1438               switch (SHUBET (*p))
1439                 {
1440                 case 0:
1441                   chgmod ((int) *p, (modetyp) * (p + 1));
1442                   break;
1443                 case 1:
1444                   allchgmod ((modetyp) * (p + 1));
1445                   break;
1446                 case 2:
1447                   incmod ((int) LWRMSK (*p), (modetyp) * (p + 1));
1448                   break;
1449                 case 3:
1450                   decmod ((int) LWRMSK (*p), (modetyp) * (p + 1));
1451                   break;
1452                 }
1453               ltrcpy (p, p + 2);
1454               /* CHMSIG�����Ĥ���1,2�Х�����cut */
1455 
1456               urabuf_clrf = 1;
1457               break;
1458             case URBFCL:
1459               /* urabuf�Υ��ꥢ������Ū�˻��ꤹ�� */
1460               urabuf_clrf = 1;
1461               ltrcpy (p, p + 1);
1462               break;
1463             default:
1464               p++;
1465             }
1466         }
1467 
1468       if (*codeout == ERRCOD)
1469         {
1470           if (eofflg == 0)
1471             {
1472               rk_errstat = 1;
1473               return (0);
1474             }
1475 
1476           /* (error)�Ǥ��äơ�������eofflg��Ω�äƤ��顢keybuf
1477              �������ޤǡ����Τޤ޽Ф��� */
1478           codein_len = ltrlen (keybuf);
1479           codeout = ltrcpy (evalbuf[ebf_sw][0], keybuf);
1480           remainkbf = nil;
1481           rk_errstat = 2;
1482 
1483           return (1);
1484         }
1485       /* (error)��ñ�ȤǤ������ʤ��Τǡ����顼���ФϤ���ǽ�ʬ�� */
1486 
1487       if (*codeout == REASIG)
1488         {
1489           *codeout = (rk_rst () != 0 ? EOLTTR : CHMSIG);
1490           /* ��read�ǥ���ä���⡼�ɥ����������ΤϤ��ʤ� */
1491 
1492           urabuf_clrf = 1;
1493         }
1494       /* ɽ�κ�read��â�������줬�����ä����Ȥ����Τ餻��Τ�CHMSIG��
1495          ���Υ����ɤ��Τ�Τϳ��ؽФʤ���(restart)�ϡ�(error)Ʊ�͡�
1496          ñ�ȤǤ������ʤ��Τǡ����ФϤ���ǽ�ʬ�� */
1497 
1498       return (urabuf_clrf ? 2 : 1);
1499     }
1500 
1501   /* ɽ�˸���Ƥ��ʤ������ɤϤ��Τޤ��֤� */
1502 
1503   codein_len = 1;
1504   *(codeout = oneletter) = *keybuf;
1505   remainkbf = nil;
1506   return (1);
1507 }
1508 
1509  /* rk_rst��ǻȤ��ޥ��� */
1510 #define taihi(X, Y, N) {for(i = 0; i < N; i++) X[i] = Y[i];}
1511 #define recov(X, Y, N) taihi(Y, X, N)
1512 
1513  /**    ɽ��ưŪ���ɤ߹��ߤ��롣���ߤ�����ɽ������������������Ʊ��
1514         �ǥ��쥯�ȥ�ʤˡ����ߤΤȤ������ˤ���ɽ���ɤ߹��ࡣ�⤷��
1515         �ɤ߹�����˥��顼���Ф���С���Ȥ������ǡ��������褷��0���֤���*/
1516 static int
rk_rst()1517 rk_rst ()
1518 {
1519   register int i;
1520   int j;
1521 
1522   letter memoryt[SIZALL];
1523   struct dat datat[LINALL];
1524   struct hyo hyo_nt[HYOMAX];
1525   letter *hensudefhyot[VARTOT];
1526   struct modestat modeswt[MODMAX];
1527   char hyoshut[HYOMAX];
1528   char *modmeibgnt[MODMAX], modmeimem_t[MODMEI];
1529   char *dspnambgnt[DMDMAX], dspcod_t[DMDCHR];
1530   int usemaehyot[HYOMAX], usehyot[HYOMAX], useatohyot[HYOMAX];
1531   int naibu_t[NAIBMX];
1532   char *dspmodt[2][2];
1533 
1534   taihi (memoryt, memory, SIZALL);
1535   taihi (datat, data, LINALL);
1536   taihi (hyo_nt, hyo_n, HYOMAX);
1537   taihi (hensudefhyot, hensudefhyo, VARTOT);
1538   taihi (modeswt, modesw, MODMAX);
1539   taihi (hyoshut, hyoshu, HYOMAX);
1540   taihi (modmeibgnt, modmeibgn, MODMAX);
1541   taihi (modmeimem_t, modmeimem_, MODMEI);
1542   taihi (dspnambgnt, dspnambgn, DMDMAX);
1543   taihi (dspcod_t, dspcod_, DMDCHR);
1544   taihi (usemaehyot, usemaehyo, HYOMAX);
1545   taihi (usehyot, usehyo, HYOMAX);
1546   taihi (useatohyot, useatohyo, HYOMAX);
1547   taihi (naibu_t, naibu_, NAIBMX);
1548   for (i = 0; i < 2; i++)
1549     for (j = 0; j < 2; j++)
1550       dspmodt[i][j] = dspmod[i][j];
1551 
1552   if (0 == romkan_init3 (prv_modfnm, delchr, nisedl, delchr2, keyin_method, bytcnt_method, kbytcnt_method, 1, flags & ~RK_VERBOS))
1553     return (0);                 /* ���ｪλ */
1554 
1555   recov (memoryt, memory, SIZALL);
1556   recov (datat, data, LINALL);
1557   recov (hyo_nt, hyo_n, HYOMAX);
1558   recov (hensudefhyot, hensudefhyo, VARTOT);
1559   recov (modeswt, modesw, MODMAX);
1560   recov (hyoshut, hyoshu, HYOMAX);
1561   recov (modmeibgnt, modmeibgn, MODMAX);
1562   recov (modmeimem_t, modmeimem_, MODMEI);
1563   recov (dspnambgnt, dspnambgn, DMDMAX);
1564   recov (dspcod_t, dspcod_, DMDCHR);
1565   recov (usemaehyot, usemaehyo, HYOMAX);
1566   recov (usehyot, usehyo, HYOMAX);
1567   recov (useatohyot, useatohyo, HYOMAX);
1568   recov (naibu_t, naibu_, NAIBMX);
1569   for (i = 0; i < 2; i++)
1570     for (j = 0; j < 2; j++)
1571       dspmod[i][j] = dspmodt[i][j];
1572   return (1);
1573 }
1574 
1575  /** lp2����ɾ����������ʸ�����lp1�˥��ԡ� */
1576 static void
ltrevlcpy(lp1,lp2)1577 ltrevlcpy (lp1, lp2)
1578      letter *lp1, *lp2;
1579 {
1580   while (*lp2 != EOLTTR)
1581     {
1582       mchevl (&lp2, lp1);
1583       totail (lp1);
1584     }
1585   *lp1 = EOLTTR;
1586 }
1587 
1588 static void
set_rubout(lp,n,del)1589 set_rubout (lp, n, del)
1590  /** lp�� ��del��n�Ĥ�����åȤ��롣������ del �� 'delchr'��'nisedl' */
1591      letter *lp, del;
1592      int n;
1593 {
1594   for (; n; n--)
1595     *lp++ = del;
1596   *lp = EOLTTR;
1597 }
1598 
1599  /** ���줬�¹Ԥ��줿��Х���â���¹ԤϤ��Τޤ�³�� */
1600 void
BUGreport(n)1601 BUGreport (n)
1602      int n;
1603 {
1604   fprintf (stderr, "\r\nromkan-Bug%d!!\r\n", n);
1605 }
1606 
1607  /** ������(mae_in��mae_out)���ϸ����(ato_in��ato_out)��Ԥ���*/
1608 static void
maeato_henkan(in,outp,m_a_hyo)1609 maeato_henkan (in, outp, m_a_hyo)
1610      letter in;                 /* ���Ϥΰ�ʸ�� */
1611      letter *outp;              /* ���ϤϤ��������� */
1612      int *m_a_hyo;              /* �ɤ����������ɽ��������Ƥ��뤫�ξ��� */
1613 {
1614   struct dat *datptr;
1615   int i, hyoseq;
1616   letter *curdat;
1617 
1618   if (isSPCL (in))
1619     {
1620       /* LTREOF��CHMSIG���褦��Τǡ��ü쥳���ɤϤ��Τޤ��֤��褦��
1621          �ٹ����Ƥ����ʤ��Ȥ����ʤ��� */
1622       ltr_to_ltrseq (outp, in);
1623       return;
1624     }
1625 
1626   for (hyoseq = 0; (hyonum = m_a_hyo[hyoseq]) != -1; hyoseq++)
1627     {
1628       for (i = 0, datptr = hyo_n[hyonum].data; NULL != (curdat = datptr[i].code[0]); i++)
1629         {
1630           henmatch[0].ltrmch = EOLTTR;
1631           if (!l_eq (curdat, in))
1632             continue;
1633 
1634           ltrevlcpy (outp, datptr[i].code[1]);
1635           return;
1636         }
1637     }
1638   ltr_to_ltrseq (outp, in);
1639 }
1640 
1641  /** ����� */
1642 static void
codeout_chg()1643 codeout_chg ()
1644 {
1645   letter *saishu_outp;
1646 
1647   *(saishu_outp = saishu_out) = EOLTTR;
1648 
1649   for (; *codeout != EOLTTR; codeout++)
1650     {
1651       maeato_henkan (*codeout, saishu_outp, useatohyo);
1652       totail (saishu_outp);
1653     }
1654 
1655   codeout = saishu_out;
1656 }
1657 
1658  /** ��ʸ���ץå��塦�Хå� */
1659 /* *INDENT-OFF* */
1660 letter
romkan_ungetc(l)1661 romkan_ungetc (l)
1662      letter l;
1663 /* *INDENT-ON* */
1664 {
1665   return (ungetc_buf = l);
1666 }
1667 
1668  /** romkan_next���Ф���ʸ���ץå��塦�Хå� */
1669 /* *INDENT-OFF* */
1670 letter
romkan_unnext(l)1671 romkan_unnext (l)
1672      letter l;
1673 /* *INDENT-ON* */
1674 {
1675   return (unnext_buf = l);
1676 }
1677 
1678  /**    delete�Ȥ��ƻȤ�����饯��������ʵ�delete��ˡ������¹Ը��
1679         romkan_clear��¹Ԥ��Ƥ����ʤ��Ⱥ���Τ�Ȥˤʤ�ޤ���*/
1680 /*      ���ѻߡ�
1681 void
1682 romkan_setdel(delchr_, nisedl_)
1683 letter  delchr_, nisedl_;
1684 {
1685         delchr = delchr_;
1686         nisedl = nisedl_;
1687 }
1688 */
1689