1 /*
2  *  $Id: rk_read.c,v 1.6 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, 2002
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_read.c
35                                                 88. 6.11  �� ��
36 
37         rk_main.c �����ʡ��Ѵ��б�ɽ���ɤ߹��ߤ�ô����
38 ***********************************************************************/
39 /*  Version 3.0  */
40 #ifdef HAVE_CONFIG_H
41 #  include <config.h>
42 #endif
43 
44 #if STDC_HEADERS
45 #  include <string.h>
46 #elif HAVE_STRINGS_H
47 #  include <strings.h>
48 #endif /* STDC_HEADERS */
49 #include <sys/stat.h>
50 #include <sys/types.h>
51 #include "rk_header.h"
52 #include "rk_extvars.h"
53 
54 letter onescan (), *rangekettei ();
55 char *ename ();
56 
57 extern letter *ltrgrow (), *ltrend (), letterpick (), *ltr1cut ();
58 extern char *chrcat (), *strend ();
59 
60 static int termsscan (), evalandcpy (), eval1cpy (), partscan (), evlis (), atermscan (), serfun (), hensrc_tourk (), blankpass (), modsrcL (), chkL_get_int ();
61 static void ERRLIN (), ERHOPN (), readhyo (), ltr1tostr (), ERRHYO (), vchk (), rangeset (), de_bcksla (), listscan (), singleqscan (), doubleqscan ();
62 extern void BUGreport (), choosehyo (), readmode ();
63 extern int ltrcmp (), ltrstrcmp (), readfnm (), fixednamep ();
64 
65 #define IHENSU (1 << 24)        /* ����ɽ���ξ�̣��Х��Ȥǡ��ѿ���ɽ�� */
66 #define IKANSU (2 << 24)        /*           ��              �ؿ���ɽ�� */
67 #define IMODNM (3 << 24)        /*           ��              �⡼��̾��ɽ�� */
68 
69 #define ENDOF_NestFileArea ((FILE *)~0)
70          /** include�ե�����Υǥ�������ץ���Ǽ���ꥢ�Υ���ɥޡ���*/
71 
72 
73  /**    ����ɤ߹��ߡ�������ɤ߹��ޤʤ�������EOF�ˤĤ������ä���0���֤���
74         â��include���θ���Ƥ��롣�б�ɽ�ˤ϶���ʸ���ʳ��Υ���ȥ���ʸ����
75         ���ǤϺ�����ʤ���ΤȤ��������äƤ���������å����롣*/
76 int
readln(buf)77 readln (buf)
78      uns_chr *buf;
79 {
80   register uns_chr *p;
81   register int c;
82 
83   if (NULL == *base)
84     {
85       *buf = '\0';
86       return (0);
87     }
88 
89   p = buf;
90   while (1)
91     {
92       while (EOF == (c = getc (*base)))
93         {
94           fclose (*base);
95           if (NULL == *--base)
96             {
97               c = EOF;
98               break;
99             }
100         }
101       if (c == EOF || c == '\n')
102         break;
103 
104       if (is_cntrl (c) && !isspace (c))
105         {
106           sprintf (hcurread, "\\%03o", c);
107           ERRLIN (21);
108         }
109       *p++ = c;
110     }
111   *p = '\0';
112   return (p != buf || c != EOF);
113 }
114 
115 letter *memptr, *ltrbufptr, *hensumei, *hen_iki, *term, **henptr;
116 letter *dummy;
117 struct dat *datptr;
118 struct hensuset
119 {
120   unsigned regdflg:1;           /* ����Ͽ���ѿ���ɽ�� */
121   unsigned curlinflg:1;         /* ���߹Ԥ˴��Ф��ѿ���ɽ�� */
122   unsigned constflg:1;          /* ����Ȥ���������줿���Ȥ�ɽ�� */
123   letter *name;
124   letter *range;
125 }
126  *hentourkptr, *henorg;
127 
128  /** Ϳ����줿�ե����뤬�ǥ��쥯�ȥ�ʤ���0���֤� */
129 int
isdir(fnm)130 isdir (fnm)
131      char *fnm;
132 {
133   struct stat statbuf;
134 /*
135         return(stat(fnm, &statbuf) == 0 && (statbuf.st_mode & S_IFDIR));
136 */
137   return (stat (fnm, &statbuf) == 0 && ((statbuf.st_mode & S_IFMT) == S_IFDIR));
138 }
139 
140  /**    name��Ϳ����줿̾���Ѵ��б�ɽ�����ץ��롣����̾�ȸ��ʤ���ʤ�
141         ̾����fixednamep()���ȡˤ��Ф��Ƥϡ��������ѥ����롣���ξ�硢
142         �����ץ�����������顢�ѥ�̾�� *dirnamptr��������֤롣����¾�ξ���
143         *dirnamptr�˶�ʸ�������롣*errcod�ˤϼ��Υ��顼�����ɤ����롣
144         Ϳ����줿�ե����뤬�ǥ��쥯�ȥ�λ�1�ʥ������ѥ���õ��������3�ˡ�
145         �ե���������ץ�Ǥ��ʤ���2��Ʊ4�ˡ�*/
146 FILE *
trytoopen(name,dirnamptr,errptr)147 trytoopen (name, dirnamptr, errptr)
148      char *name, **dirnamptr;
149      int *errptr;
150 {
151   char **src, taio_fnm[REALFN];
152   FILE *opened;
153 
154   *dirnamptr = nulstr;
155   *errptr = 0;
156 
157   if (fixednamep (name))
158     {
159       if (isdir (name))
160         {
161           *errptr = 1;
162           return (NULL);
163         }
164       if (NULL == (opened = fopen (name, "r")))
165         {
166           *errptr = 2;
167           return (NULL);
168         }
169       if (flags & RK_VERBOS)
170         {
171           fprintf (stderr, "romkan: using Taio-hyo %s ...\r\n", name);
172         }
173       return (opened);
174     }
175   else
176     {
177       for (src = pathmeiorg; *src != NULL; src++)
178         {
179           strcpy (taio_fnm, (*dirnamptr = *src));
180           strcat (taio_fnm, name);
181 
182           if (isdir (taio_fnm))
183             {
184               *errptr = 3;
185               return (NULL);
186             }
187           if (NULL == (opened = fopen (taio_fnm, "r")))
188             continue;
189 
190           /* Now Taio-hyo found */
191           if (flags & RK_VERBOS)
192             fprintf (stderr, "romkan: using Taio-hyo %s ...\r\n", taio_fnm);
193           return (opened);
194         }
195       if (flags & RK_VERBOS)
196         {                       /* Taio-hyo not found */
197           char *p, *q;
198 
199           fprintf (stderr, "no %s in", name);
200           for (src = pathmeiorg; *src != NULL; src++)
201             {
202               fputc (' ', stderr);
203               q = *src;
204               if (*q == KUGIRI && *(q + 1) == '\0')
205                 q++;
206               else
207                 q = strend (q);
208               for (p = *src; p < q; p++)
209                 fputc (*p, stderr);
210             }
211           fprintf (stderr, ".\n");
212         }
213       *dirnamptr = nulstr;
214       *errptr = 4;
215       return (NULL);
216     }
217 }
218 
219  /** ɽ�������ɤ߹��� */
220 void
readdata(memory,data,hensudefhyo,modf)221 readdata (memory, data, hensudefhyo, modf)
222      letter *memory;            /* �б�ɽ������ɽ����������������Ƭ���Ϥ��Ϥ���� */
223      struct dat *data;          /* �б�ɽ�ιԤ��ȤΥǡ������������������� */
224      letter **hensudefhyo;      /* �ѿ�����Υǡ������������������� */
225      char *modf;                /* �⡼�����ɽ��̾���Ϥ��Υѥ�̾�����äƤ��� */
226 {
227   int i, j;
228   char *hyomeibgn[HYOMAX];
229   /* ɽ��̾�ؤΥݥ�������������� */
230   char hyomeimem_[HYOMEI];
231   /* ɽ��̾�μºݤ�ʸ�������������� */
232   char *pathmeibgn[PTHMAX];
233   /* �������ѥ�̾�ؤΥݥ�������������� */
234   char pathmeimem_[PTHMEI];
235   /* �������ѥ�̾�μºݤ�ʸ�������������� */
236   char modfnm[REALFN];
237   /* �⡼��ɽ�Υե�����̾�����إ��Ԥ� �Τ��ˤϤ��Υѥ�̾������ */
238 
239   memptr = memory;
240   datptr = data;
241   henptr = hensudefhyo;
242   *(pathmeiptr = pathmeiorg = pathmeibgn) = NULL;
243   *(pathmeimem = pathmeimem_) = '\0';
244   *(hyomeiptr = hyomeiorg = hyomeibgn) = NULL;
245   *(hyomeimem = hyomeimem_) = '\0';
246   *(modmeiptr = modmeibgn) = NULL;
247   *(modmeimem = modmeimem_) = '\0';
248   *(dspnamptr = dspnambgn) = NULL;
249   *(dspcod = dspcod_) = '\0';
250   *(naibu = naibu_) = '\0';
251 
252   strcpy (modfnm, modf);
253   /* modfnm��Ϳ�����ե�����̾���ѥ�̾����Ϳ����줿�顢�ǥե���Ȥ�
254      �⡼��ɽ̾"mode"��Ĥʤ���KUGIRI��ǥ��쥯�ȥ�ζ��ڤ�ʸ�� */
255 
256   if (*modfnm == '\0' || *(strend (modfnm)) == KUGIRI)
257     {
258       strcat (modfnm, "mode");
259     }
260   else if (isdir (modfnm))
261     {
262       chrcat (modfnm, KUGIRI);
263       strcat (modfnm, "mode");
264     }
265 
266   curdir = nulstr;
267   readmode (curfnm = modfnm);
268 
269   for (i = 0; hyomeiorg[i] != NULL; i++)
270     {
271       int err;
272 
273       for (j = 0; j < FILNST; j++)
274         nestfile[j] = NULL;
275       nestfile[FILNST - 1] = ENDOF_NestFileArea;
276       base = nestfile + 1;
277 
278       *base = trytoopen (curfnm = hyomeiorg[i], &curdir, &err);
279       if (err)
280         {
281           switch (err)
282             {
283             case 1:
284             case 3:
285               ERHOPN (1);
286             case 2:
287             case 4:
288               ERHOPN (0);
289             }
290         }
291       readhyo (i);
292     }
293 
294   hyo_n[i].data = NULL;
295   choosehyo ();
296 }
297 
298  /** �ե�����̾����ѥ�̾���������ʬ����Ƭ���֤���*/
299 char *
ename(s)300 ename (s)
301      char *s;
302 {
303   char *p;
304 
305   p = strrchr (s, KUGIRI);
306   return (p == NULL ? s : p + 1);
307 }
308 
309  /**    �ե�����̾�Υ����å�����Ƭ�ʥѥ�̾�Ͻ����ˤ�'1'��'3'�Ǥʤ��Ȥ����ʤ���
310         �����ʤ�Τʤ�1��3�������ܡ������ɽ�ζ��̤�ɽ���ˤ��֤��������Ǥʤ���
311         0���֤���*/
312 int
filnamchk(s)313 filnamchk (s)
314      char *s;
315 {
316   char c;
317 
318   c = *(ename (s)) - '0';
319   return ((1 <= c && c <= 3) ? c : 0);
320 }
321 
322  /**    linbuf�����äƤ���unsigned char�����letter����ˤ���ltrbuf������롣
323         ����ɥޡ�����EOLTTR�ˤʤ롣flg����0�λ��ϡ���Ƭ�ζ���ʸ�������Ф���*/
324 void
ustrtoltr(linbuf,ltrbuf,flg)325 ustrtoltr (linbuf, ltrbuf, flg)
326      uns_chr *linbuf;
327      int flg;
328      register letter *ltrbuf;
329 {
330   register letter l;
331 
332   if (flg)
333     {
334       while (l = letterpick (&linbuf), is_eolsp (l))
335         {
336           if (l == EOLTTR)
337             {
338               *ltrbuf = EOLTTR;
339               return;
340             }
341         }
342       *ltrbuf++ = l;
343     }
344   while ((*ltrbuf++ = letterpick (&linbuf)) != EOLTTR);
345 }
346 
347  /**    letter�����ʸ����˥���С��ȡ���ĤΥݥ�����Ʊ�����ϤǤ��äƤ�
348         ư����ݾڤ��뤳�ȡ�*/
349 void
ltrtostr(ltrbuf,linbuf)350 ltrtostr (ltrbuf, linbuf)
351      char *linbuf;
352      letter *ltrbuf;
353 {
354   letter l;
355 
356   while ((l = *ltrbuf++) != EOLTTR)
357     ltr1tostr (l, &linbuf);
358   *linbuf = '\0';
359 }
360 
361  /** letter��ʸ����˥���С��� */
362 static void
ltr1tostr(l,sptr)363 ltr1tostr (l, sptr)
364      char **sptr;
365      letter l;
366 {
367   int i;
368 
369   for (i = 0; i < 3 && 0 == (l & (0xff000000)); i++)
370     l <<= 8;
371   for (; i < 4; i++)
372     {
373       *(*sptr)++ = (char) (l >> 24);
374       l <<= 8;
375     }
376 }
377 
378  /** �ѿ��Ρָ��߹Դ��Хե饰�פ����ƥ��ꥢ */
379 void
hen_useflgclr(hensu)380 hen_useflgclr (hensu)
381      struct hensuset *hensu;
382 {
383   for (; hensu->name != NULL; hensu++)
384     hensu->curlinflg = 0;       /* ���߹Ԥ�̤�� */
385 }
386 
387  /** �б�ɽ����ɤ߹��� */
388 static void
readhyo(n)389 readhyo (n)
390      int n;
391 {
392   uns_chr linbuf[LINSIZ];
393   letter ltrbuf[LINSIZ], *lp;
394   letter termbuf[SIZALL];       /* ���顼���θ���ơ�ɽ�Υ�����ʬ��äƤ��� */
395   letter dummybuf[TRMSIZ], hensumei_[VARLEN], hen_iki_[SIZALL];
396   struct hensuset hensu[VARMAX];
397   int m, hyosw, rsltyp[3];
398 
399   hcurread = (char *) linbuf;   /* ���顼������ */
400   ltrbufbgn = ltrbuf;
401 
402   *(hensumei = hensumei_) = EOLTTR;
403   *(hen_iki = hen_iki_) = EOLTTR;
404   (henorg = hentourkptr = hensu)->name = NULL;
405   dummy = dummybuf;
406 
407   hyo_n[n].hensudef = henptr;
408   hyo_n[n].data = datptr;
409 
410   hyosw = hyoshu[n];
411   while (readln (linbuf))
412     {
413       hen_useflgclr (henorg);
414       ustrtoltr (linbuf, ltrbuf, 1);
415       ltrbufptr = ltrbuf;
416 
417       for (m = 0; termsscan (&ltrbufptr, term = termbuf, 1); m++)
418         {
419           /* m�ϡ������ܤι��ܤ��Ƥ��뤫��ɽ�� */
420           if (*term == ';')
421             break;              /* ���� */
422           if (m == 3)
423             ERRLIN (15);
424           if (m != 0 && rsltyp[0] == 4)
425             ERRLIN (12);
426 
427           datptr->code[m] = memptr;
428           if ((rsltyp[m] = evalandcpy (&term, m)) == 4)
429             {
430               if (m)
431                 ERRLIN (14);
432               /* ����Ϻǽ�ι��ܤˤ������ʤ���
433                  funstr[]��appear�ե饰�Ǥ�����å����Ƥ��뤬
434                  ����Τ���˰�������ˤ�����å�������Ƥ����� */
435             }
436           else
437             {
438               /* ����λ��ˤ�����ɽ���ؤΥݥ����Ͽʤ�ʤ� */
439               totail (memptr);
440               memptr++;
441             }
442         }
443 
444       if (m != 0 && rsltyp[0] != 4)
445         {
446           for ( /* m=? */ ; m < 3; m++)
447             {
448               datptr->code[m] = nil;
449               rsltyp[m] = -1;   /* doesn't exist */
450             }
451           datptr++;
452 
453           /* rsltyp: 0=ʸ���� 1=ʸ����Ϣ 2=�ǡ���Ϣ 3=��ǽ�� 4=����� -1=¸�ߤ��� */
454           switch (hyosw)
455             {
456               /* ����������ϡ�ɽ�����Ƥ����¤����롣������� */
457             case 1:
458               if (!(rsltyp[0] == 0 && rsltyp[1] == 0 && rsltyp[2] == -1))
459                 ERRLIN (17);
460               break;
461             case 2:
462               if (rsltyp[1] == 3 && rsltyp[2] != -1)
463                 ERRLIN (19);
464               break;
465             case 3:
466               if (!(rsltyp[0] == 0 && (rsltyp[1] == 0 || rsltyp[1] == 1) && rsltyp[2] == -1))
467                 ERRLIN (18);
468               break;
469             default:
470               BUGreport (10);
471             }
472 
473         }
474     }
475 
476   (datptr++)->code[0] = NULL;
477 
478   /* �ѿ���Ͽ�����ǤޤȤ�Ƥ��� */
479   for (lp = hen_iki_; lp < hen_iki;)
480     *memptr++ = *lp++;
481   for (hentourkptr = henorg; hentourkptr->name != NULL; hentourkptr++)
482     {
483       if (hentourkptr->regdflg == 0)
484         ERRHYO (0);
485       *henptr++ = memptr - (lp - hentourkptr->range);
486     }
487   *henptr++ = NULL;
488 
489   /* ������ fclose(*base); �����ס�readln��Ǥ���Ǥ��� */
490 }
491 
492  /**    �Ѵ��б�ɽ�ι��ܰ�Ĥ���ᤷ�ơ����������Υǡ������ꥢ�˥��ԡ����롣
493         �֤��ͤϡ���ᤷ�����ܤ�ʸ����ʤ�0������ʳ���ʸ����Ϣ�ʤ�1������ʳ�
494         �ǥǡ���Ϣ�ʤ�2����ǽ��ʤ�3�������ʤ�4������ʳ��ϥ��顼��*/
495 static int
evalandcpy(socp,m)496 evalandcpy (socp, m)
497      register letter **socp;    /* ���ܤؤΥݥ����ʤؤΥݥ����� */
498      int m;                     /* �б�ɽ�β����ܤι��ܤ��Ƥ��뤫��ɽ�������ϥ���������
499                                    ���Ƥ���Ȥ���0�����ϥ��������ʤ�1���Хåե��Ĥ����ʤ�2 */
500 {
501 #define TYPMAX  5
502 
503   char exist[TYPMAX], total;
504   /* exist�ϡ����줾�쥿����0��4�ι�νи��Υե饰��eval1cpy()���ȡˡ�
505      total�����ΤȤ��Ƥνи��ե饰���ɤ���⡢1=̤�� 2=���� ����¾��
506      ���ϲ�2�ӥå�0 */
507   int type;
508 
509 #define TIME_0(flag) ((flag) == 1)
510 #define TIME_1(flag) ((flag) == 2)
511 #define TIME_n(flag) (((flag) & 3) == 0)
512 
513   total = 1;
514   for (type = 0; type < TYPMAX; type++)
515     exist[type] = 1;
516 
517   while (!is_eolsp (**socp))
518     {
519       if (!(0 <= (type = eval1cpy (socp, m, 0)) && type < TYPMAX))
520         BUGreport (3);
521       exist[type] <<= 1;
522       total <<= 1;
523     }
524 
525   if (TIME_0 (total))
526     BUGreport (13);             /* ���ܤ����ʤ�evalandcpy�ϼ¹Ԥ��ʤ�Ȧ */
527   if (!TIME_0 (exist[3]) || !TIME_0 (exist[4]))
528     {
529       if (TIME_n (total))
530         ERRLIN (9);
531       return (type);            /* 3����4��type���ͤ��ݻ����Ƥ���Ȧ */
532     }
533   if (TIME_1 (total) && TIME_1 (exist[0]))
534     return (0);
535   return (!TIME_0 (exist[2]) ? 2 : 1);
536 }
537 
538  /**    �б�ɽ�ι��ܤ���ι��Ĥ��ᤷ�����������Υǡ������ꥢ�˥��ԡ�����
539         ����Υ����ס�ʸ����=0 ʸ�����=1 �ü�ؿ���=2 ��ǽ��=3 �����=4�ˤ�
540         �֤���flg����0�ʤ顢�Ƶ�Ū�˸ƤФ줿���Ȥ��̣�������ξ�硢
541         ���߹Ԥ�̤�Ф��ѿ����Ф����饨�顼���ޤ���m����0�ΤȤ������ϥ�������
542         �ʳ��ν���Ƥ�����ˤ⡢���߹Ԥ�̤�Ф��ѿ����Ф����饨�顼��*/
543 static int
eval1cpy(socp,m,flg)544 eval1cpy (socp, m, flg)
545      letter **socp;             /* flg�ʳ��ΰ����ΰ�̣��evalandcpy��Ʊ�� */
546      int m, flg;
547 {
548   letter t1buf[TRMSIZ], *t1bufp;
549 
550   t1bufp = t1buf;
551 
552   *memptr = EOLTTR;
553   switch (partscan (socp, t1bufp))
554     {
555     case 1:                     /* ñʸ�� */
556       memptr = ltrgrow (memptr, t1bufp);
557       *memptr = EOLTTR;
558       return (0);
559     case 2:                     /* ����ʸ�� */
560       t1bufp++;
561       *memptr++ = onescan (&t1bufp, dummy);
562       *memptr = EOLTTR;
563       return (0);
564     case 3:                     /* ����ʸ���� */
565       t1bufp++;
566       while (*t1bufp != '"')
567         {
568           *memptr++ = onescan (&t1bufp, dummy);
569         }
570       *memptr = EOLTTR;
571       return (1);
572     case 0:                     /* �ꥹ�� */
573       return (evlis (m, &t1bufp, flg));
574       /* evlis��� *memptr = EOLTTR; ���Ƥ��롣 */
575     default:
576       BUGreport (4);
577       return (-1);
578      /*NOTREACHED*/}
579  /*NOTREACHED*/}
580 
581 #define bitchk(x, n) ((x) & (1 << (n)))
582 
583 #define get_ltr(lp) (*(lp)++)
584 #define unget_ltr(l, lp) (*--(lp) = (l))
585 
586  /** global�ʥݥ�������ؤ���Ƥ���letter�����ʸ����äƤ��롣*/
587 /* *INDENT-OFF* */
588 letter
get1ltr()589 get1ltr ()
590 /* *INDENT-ON* */
591 {
592   return (get_ltr (lptr));
593 }
594 
595 /* *INDENT-OFF* */
596 letter
unget1ltr(l)597 unget1ltr (l)
598      letter l;
599 /* *INDENT-ON* */
600 
601 {
602   return (unget_ltr (l, lptr));
603 }
604 
605 int
int_get1ltr()606 int_get1ltr ()
607 {
608   return ((int) (get1ltr ()));
609 }
610 
611 int
int_unget1ltr(c)612 int_unget1ltr (c)
613      letter c;
614 {
615   return ((int) (unget1ltr ((letter) c)));
616 }
617 
618  /** �������Ȥ��ξ�ʤ����ʤ��ؿ��η���cast���Ǥ��ʤ��Ρ�
619     ��(int ()) get1ltr�פȽ������� */
620 
621  /**    include�ե�����̾��letter���string�˼��Ф���Ȥ�letter��ν����
622         �ޤ�³���롣flg & 01����0�ʤ顢'/'�Ǥ⽪λ��*/
623 /* *INDENT-OFF* */
624 letter
getfrom_dblq(socp,destp,flg)625 getfrom_dblq (socp, destp, flg)
626      letter **socp;
627      char **destp;
628      int flg;
629 /* *INDENT-ON* */
630 {
631   letter l;
632 
633   while (**socp != EOLTTR && !(flg & 01 && **socp == KUGIRI))
634     {
635       if (**socp == '\\')
636         *(*destp)++ = '\\';
637       l = onescan (socp, dummy);
638       ltr1tostr (l, destp);
639     }
640   *(*destp)++ = '\0';
641   return (**socp);
642 }
643 
644 int
getfrom_lptr(sptr,flg)645 getfrom_lptr (sptr, flg)
646      char **sptr;
647      int flg;
648 {
649   return ((int) getfrom_dblq (&lptr, sptr, flg));
650 }
651 
652  /**    �ꥹ�Ȥ��ᤷ������ɽ���ˤ��롣���ͤϡ����Υꥹ�ȤΥ����פ�ɽ������
653         ʸ���ѿ�������ʸ���ؿ���:0 ʸ����ؿ���:1 �ü�ؿ���:2
654         ��ǽ��:3 �����:4 */
655 static int
evlis(m,socp,flg)656 evlis (m, socp, flg)
657      letter **socp;             /* �����ΰ�̣��eval1cpy���� */
658      int m, flg;
659 {
660   int fnnum, hennum, i;
661   letter t1buf[TRMSIZ];
662 
663   (*socp)++;                    /* '('�����å� */
664   atermscan (socp, t1buf, 3);
665 
666   fnnum = serfun (t1buf);
667   if (fnnum != -1 && !bitchk (func[fnnum].appear, m))
668     ERRLIN (14);
669   /* m���ͤˤ�äơ�����ƤϤ����ʤ���ؤνи����ɤ������Ƥ��롣 */
670 
671   switch (fnnum)
672     {                           /* default�ν�ʳ��� func[fnnum].argnum��ȤäƤʤ� */
673     case -1:                    /* �ѿ� */
674       vchk (t1buf);
675       atermscan (socp, dummy, 2);       /* �����ERR */
676       hennum = hensrc_tourk (t1buf, ((m == 0 && !flg) ? 0 : 1));
677       *memptr++ = (henorg[hennum].constflg ? *(henorg[hennum].range) : hennum | IHENSU);
678       break;
679 
680     case 0:                     /* fn No.0 defvar */
681       atermscan (socp, t1buf, 3);
682       if (*t1buf == '(')
683         {
684           letter *soc2, t1buf2[TRMSIZ], t1buf3[TRMSIZ];
685           letter *common_hen;
686 
687           atermscan (socp, t1buf3, 3);
688 
689           soc2 = t1buf + 1;     /* skip '(' */
690 
691           atermscan (&soc2, t1buf2, 3);
692           vchk (t1buf2);
693           if (-1 != serfun (t1buf2))
694             ERRLIN (11);
695           hennum = hensrc_tourk (t1buf2, 2);
696           common_hen = rangekettei (hennum, t1buf3);
697 
698           while (atermscan (&soc2, t1buf2, 0))
699             {
700               vchk (t1buf2);
701               if (-1 != serfun (t1buf2))
702                 ERRLIN (11);
703               hennum = hensrc_tourk (t1buf2, 2);
704               rangeset (hennum, common_hen);
705             }
706         }
707       else
708         {
709           vchk (t1buf);
710           if (-1 != serfun (t1buf))
711             ERRLIN (11);
712           hennum = hensrc_tourk (t1buf, 2);
713           /* defvar��defconst���ѿ�̾�ν�ʣ�����뤿�� */
714           atermscan (socp, t1buf, 3);
715           rangekettei (hennum, t1buf);
716         }
717       atermscan (socp, dummy, 2);
718       break;
719     case 36:                    /* fn No.36 defconst */
720       atermscan (socp, t1buf, 3);
721       vchk (t1buf);
722       if (-1 != serfun (t1buf))
723         ERRLIN (11);
724 
725       hennum = hensrc_tourk (t1buf, 6);
726       /* defvar��defconst���ѿ�̾��ʣ�����뤿�� */
727 
728       rangeset (hennum, hen_iki);
729 
730       blankpass (socp, 1);
731       if (*(*socp)++ != '\'')
732         ERRLIN (8);
733       *hen_iki++ = onescan (socp, dummy);
734       (*socp)++;                /*��'�פ��Ĥ��Ƥ��뤳�Ȥθ����ϺѤ�Ǥ��� */
735       *hen_iki++ = EOLTTR;      /* needed? */
736       *hen_iki = EOLTTR;
737 
738       atermscan (socp, dummy, 2);
739       break;
740 
741     case 1:                     /* fn No.1 include */
742       {
743         char fnmtmparea[REALFN], *s, *dirnamptr;
744         int dummyc = 0, err;
745 
746         blankpass (socp, 1);
747         if (3 != partscan (socp, t1buf))
748           ERRLIN (22);
749         atermscan (socp, dummy, 2);
750         /* ;ʬ�ˤ����ERR */
751 
752         ltr1cut (lptr = t1buf + 1);
753         *(s = fnmtmparea) = '\0';
754         err = readfnm (int_get1ltr, int_unget1ltr, getfrom_lptr, &s, &dummyc);
755 
756         if (err)
757           {
758             hcurread = s;
759             switch (err)
760               {
761               case 1:
762               case 3:
763                 ERRLIN (25);
764               case 2:
765                 ERRLIN (26);
766               case 4:
767                 ERRLIN (27);
768               }
769           }
770         de_bcksla (fnmtmparea, fnmtmparea);
771 
772         if (*++base == ENDOF_NestFileArea)
773           {
774             base--;
775             ERRLIN (23);
776           }
777         *base = trytoopen (fnmtmparea, &dirnamptr, &err);
778         if (err)
779           {
780             switch (err)
781               {
782               case 1:
783               case 3:
784               case 2:
785               case 4:
786                 base--;
787                 ERRLIN (24);
788               }
789           }
790       }
791       break;
792 
793       /* �⡼��̾��Ĥ�����˼���� */
794     case 4:                     /* fn No.4��6 off,on,switch */
795     case 5:
796     case 6:
797     case 20:                    /* fn No.20,21 if,unless */
798     case 21:
799       *memptr++ = fnnum | IKANSU;
800       atermscan (socp, t1buf, 3);
801       *memptr++ = modsrcL (t1buf) | IMODNM;
802       atermscan (socp, t1buf, 2);
803       break;
804 
805       /* �⡼��̾��ʸ�� ��Ĥ��Ĥ�����˼���� */
806     case 37:                    /* fn No.37��43 setmode�ʤ� */
807     case 38:
808     case 39:
809     case 40:
810     case 41:
811     case 42:
812     case 43:
813       {
814         int err, n;
815         modetyp stat;
816 
817         *memptr++ = fnnum | IKANSU;
818         atermscan (socp, t1buf, 3);
819         *memptr++ = (n = modsrcL (t1buf)) | IMODNM;
820         atermscan (socp, t1buf, 3);
821         err = chkL_get_int (t1buf, &stat, modesw[n].moderng);
822         if (err != 0)
823           ERRLIN (29);
824         *memptr++ = stat;
825         atermscan (socp, t1buf, 2);
826         break;
827       }
828 
829       /* ���̡ʰ�������ʤ���Τ�ޤ�� */
830     default:                    /* toupper,tolower�� */
831       *memptr++ = fnnum | IKANSU;
832       *memptr = EOLTTR;
833       for (i = 0; i < func[fnnum].argnum; i++)
834         {
835           blankpass (socp, 1);
836           if (eval1cpy (socp, m, 1) != 0)
837             ERRLIN (13);
838         }
839       atermscan (socp, dummy, 2);       /* ;ʬ�ˤ����ERR */
840       break;
841     }
842   *memptr = EOLTTR;
843   return (fnnum == -1 ? 0 : func[fnnum].fntype);
844 }
845 
846  /** ʸ������Ρ�\�פ�ȴ�� */
847 static void
de_bcksla(s,r)848 de_bcksla (s, r)
849      char *s, *r;
850 {
851   for (; *s; *r++ = *s++)
852     if (*s == '\\')
853       s++;
854   *r = '\0';
855 }
856 
857  /**    defvar�����������shiki������ˤ��ᤷ�ơ������ѿ����Ѱ����ꤹ�롣
858         �ѿ���κǸ�˥���ɥޡ�������������롣���ͤϡ��Ѱ���Ǽ����
859         ��ؤΥݥ�����*/
860 letter *
rangekettei(num,shiki)861 rangekettei (num, shiki)
862      letter *shiki;
863      int num;                   /* �Ѱ����ꤷ�ĤĤ����ѿ��������ֹ� */
864 {
865   letter hyoukabuf[TRMSIZ];
866 
867   rangeset (num, hen_iki);
868   *hen_iki = EOLTTR;
869 
870   if (*shiki++ != '(')
871     ERRLIN (8);
872   atermscan (&shiki, hyoukabuf, 1);
873 
874   if (!ltrstrcmp (hyoukabuf, "all"))
875     {
876       *hen_iki++ = VARRNG;
877       *hen_iki++ = 0;
878       *hen_iki++ = LTRHUG;      /* �Ѱ����ʸ�� */
879       *hen_iki++ = EOLTTR;
880       *hen_iki = EOLTTR;
881       atermscan (&shiki, dummy, 2);     /* ;ʬ�ˤ����ERR */
882     }
883   else if (!ltrstrcmp (hyoukabuf, "between"))
884     {
885       int i;
886 
887       *hen_iki++ = VARRNG;
888       while (blankpass (&shiki, 1), *shiki != ')')
889         {
890           for (i = 1; i <= 2; i++)
891             {
892               switch (*shiki)
893                 {
894                 case '\'':
895                   shiki++;
896                   *hen_iki++ = onescan (&shiki, dummy);
897                   shiki++;
898                   break;
899                 case ')':
900                 case '"':
901                 case '(':
902                   ERRLIN (8);
903                 default:
904                   *hen_iki++ = *shiki++;
905                 }
906               if (i < 2)
907                 {
908                   if (!is_eolsp (*shiki))
909                     ERRLIN (8);
910                   blankpass (&shiki, 1);
911                 }
912             }
913         }
914       *hen_iki++ = EOLTTR;
915       *hen_iki = EOLTTR;
916     }
917   else if (!ltrstrcmp (hyoukabuf, "list"))
918     {
919       while (blankpass (&shiki, 1), *shiki != ')')
920         {
921           switch (*shiki)
922             {
923             case '"':
924             case '(':
925               ERRLIN (8);
926             case '\'':
927               shiki++;
928               *hen_iki++ = onescan (&shiki, dummy);
929               shiki++;          /* �����ˡ�'�פ��Ĥ��Ƥ��뤫
930                                    �ɤ����θ����Ϥ⤦�Ѥ�Ǥ��롣 */
931               break;
932             default:
933               *hen_iki++ = *shiki++;
934             }
935           if (!is_eolsp (*shiki))
936             ERRLIN (8);
937         }
938       *hen_iki++ = EOLTTR;
939       *hen_iki = EOLTTR;
940     }
941   else
942     {
943       ERRLIN (8);               /* ����Ϥ���¾�ι�ʸ�����ͽ��Ǥ��ä� */
944     }
945 
946   return (henorg[num].range);
947 }
948 
949  /**    num���ܤ��ѿ����Ѱ��ؤ��٤��ݥ����λؤ������ꤷ�������ѿ���
950         ����Ͽ���֤ˤ��롣*/
951 static void
rangeset(num,range)952 rangeset (num, range)
953      letter *range;             /* �Ѱ��������Υݥ��� */
954      int num;
955 {
956   henorg[num].range = range;
957   henorg[num].regdflg = 1;
958 }
959 
960  /**    name�ǻ��ꤵ�줿̾���ѿ���õ�����ʤ������Ͽ���ѿ�̾�κǸ��
961         ����ɥޡ�������������롣
962         flg & 01����0�λ�������̾���ѿ������߹Ԥ�̤�Фʤ饨�顼��const�Ȥ���
963         ����Ͽ�λ�������ˡ��ޤ� flg & 02����0�λ�������̾���ѿ���������ʤ�
964         ���顼��defvar�ν�ʣ�����å��ѡˡ�flg & 04����0�ʤ�const�Ȥ�����Ͽ��*/
965 static int
hensrc_tourk(name,flg)966 hensrc_tourk (name, flg)
967      letter *name;
968      int flg;
969 {
970   int i;
971 
972   for (i = 0; henorg[i].name != NULL; i++)
973     {
974       if (ltrcmp (henorg[i].name, name))
975         continue;
976       /* found */
977       if (flg & 04)
978         ERRLIN (28);
979       if (flg & 02 && henorg[i].regdflg != 0)
980         ERRLIN (10);
981       if (flg & 01 && henorg[i].curlinflg == 0 && henorg[i].constflg == 0)
982         ERRLIN (5);
983       henorg[i].curlinflg = 1;
984       return (i);
985     }
986   if (henorg + i != hentourkptr)
987     BUGreport (5);
988 
989   /* �������褿�Ȥ������Ȥϡ���Ф��ѿ��Ȥ������ȡ�������flg & 01��
990      ��0�ʤ饨�顼�� */
991   if (flg & 01)
992     ERRLIN (5);
993   hentourkptr->name = hensumei;
994   hentourkptr->curlinflg = 1;
995   hentourkptr->regdflg = 0;     /* ��Ф�����range��def��̤����Ȧ */
996   hentourkptr->constflg = ((flg & 04) != 0);
997   (++hentourkptr)->name = NULL;
998   hensumei = ltrgrow (hensumei, name);
999   *++hensumei = EOLTTR;
1000 
1001   return (i);
1002 }
1003 
1004  /** �Ȥ߹��ߴؿ�����ǽ̾���Ф��ƤϤ����ֹ�������Ǥʤ���Τʤ�-1���֤� */
1005 static int
serfun(lp)1006 serfun (lp)
1007      register letter *lp;       /* �ؿ�����ǽ̾�⤷�����ѿ�̾ */
1008 {
1009   register int i;
1010 
1011   for (i = 0; func[i].fnname != NULL; i++)
1012     {
1013       if (!ltrstrcmp (lp, func[i].fnname))
1014         return (i);
1015     }
1016   return (-1);
1017 }
1018 
1019  /** �ѿ���̾���Υ����å� ���������ȥ��顼 */
1020 static void
vchk(lp)1021 vchk (lp)
1022      letter *lp;
1023 {
1024   if (is_digit (*lp))
1025     ERRLIN (3);
1026   for (; *lp != EOLTTR; lp++)
1027     {
1028       /*    if(is_lower(*lp)) *lp = to_upper(*lp);  */
1029       if (!is_alnum (*lp) && *lp != '_')
1030         ERRLIN (3);
1031     }
1032 }
1033 
1034  /**    ����ܤ���Ф������Ф������������1���֤���flg����0�λ��ϡ�')'��
1035         ���Ĥ���ȥ��顼��';'�Ϥ�������ǰ���ܰ�����*/
1036 static int
termsscan(socp,dest,flg)1037 termsscan (socp, dest, flg)
1038      register letter **socp, *dest;
1039          /* socp�λؤ��Ƥ���ݥ������ؤ��Ƥ���꤫����Ф���dest������롣
1040             ���θ塢socp���ؤ��Ƥ���ݥ�����ʤ�롣���Υե������ **scan()
1041             �Ȥ����ؿ������Ƥ����ʤäƤ롣 */
1042      int flg;
1043 {
1044   letter *bgn;
1045 
1046   bgn = dest;
1047 
1048   if (blankpass (socp, 0) == 0)
1049     {
1050       if (flg && **socp == ';')
1051         {
1052           *dest++ = *(*socp)++;
1053         }
1054       else
1055         while (!is_eolsp (**socp))
1056           {
1057             if (**socp == ')')
1058               {
1059                 if (flg)
1060                   ERRLIN (0);
1061                 break;
1062               }
1063             else
1064               {
1065                 partscan (socp, dest);
1066                 totail (dest);
1067               }
1068           }
1069     }
1070 
1071   *dest = EOLTTR;
1072   return (bgn != dest);
1073 }
1074 
1075  /**    �ꥹ�Ȱ�Ĥ���ñ���ΰ�ޤȤޤ����Ф�������������1���֤���
1076         flg��1�ΤȤ���')'�����Ĥ���ȥ��顼��
1077         flg��2�ΤȤ������Ф������������饨�顼��
1078         flg��3�ΤȤ������Ф��˼��Ԥ����饨�顼��*/
1079 static int
atermscan(socp,dest,flg)1080 atermscan (socp, dest, flg)
1081      register letter **socp, *dest;
1082      int flg;
1083 {
1084   letter *bgn;
1085   int found;
1086 
1087   bgn = dest;
1088 
1089   if (blankpass (socp, 0) == 0)
1090     {
1091       if (**socp == '(')
1092         {
1093           listscan (socp, dest);
1094           totail (dest);
1095         }
1096       else
1097         {
1098           while (!is_eolsp (**socp) && **socp != '(')
1099             {
1100               if (**socp == ')')
1101                 {
1102                   if (flg == 1)
1103                     ERRLIN (0);
1104                   break;
1105                 }
1106               else
1107                 {
1108                   partscan (socp, dest);
1109                   totail (dest);
1110                 }
1111             }
1112         }
1113     }
1114 
1115   *dest = EOLTTR;
1116 
1117   found = (bgn != dest);
1118   if ((!found && flg == 3) || (found && flg == 2))
1119     ERRLIN (7);
1120   return (found);
1121 }
1122 
1123  /**    ���Ĥ���Ф������Ф�����Τ��ꥹ�Ȥʤ����ͤ�0��ñʸ���ʤ�1��
1124         ����ʸ���ʤ�2������ʸ����ʤ�3��*/
1125 static int
partscan(socp,dest)1126 partscan (socp, dest)
1127      register letter **socp, *dest;
1128 {
1129   switch (**socp)
1130     {
1131     case '(':
1132       listscan (socp, dest);
1133       return (0);
1134     case '\'':
1135       singleqscan (socp, dest);
1136       return (2);
1137     case '"':
1138       doubleqscan (socp, dest);
1139       return (3);
1140     default:
1141       *dest++ = *(*socp)++;
1142       *dest = EOLTTR;
1143       return (1);
1144     }
1145 }
1146 
1147  /** �����륯������ɽ����Ĥ���Ф���*/
1148 static void
singleqscan(socp,dest)1149 singleqscan (socp, dest)
1150      letter **socp, *dest;
1151 {
1152   *dest++ = *(*socp)++;
1153   onescan (socp, dest);
1154   totail (dest);
1155   if ((*dest++ = *(*socp)++) != '\'')
1156     ERRLIN (1);
1157 
1158   *dest = EOLTTR;
1159 }
1160 
1161  /** ���֥륯������ɽ����Ĥ���Ф���*/
1162 static void
doubleqscan(socp,dest)1163 doubleqscan (socp, dest)
1164      letter **socp, *dest;
1165 {
1166   *dest++ = *(*socp)++;
1167   while (**socp != '"')
1168     {
1169       if (**socp == EOLTTR)
1170         ERRLIN (1);
1171       onescan (socp, dest);
1172       totail (dest);
1173     }
1174   *dest++ = *(*socp)++;
1175 
1176   *dest = EOLTTR;
1177 }
1178 
1179  /**    8��10��16�ʥ������ѥ���饯����ºݤΥ����ɤ�ľ�������ϤΥ����å���
1180         ��������ʸ���ȿ����ʳ������Ϥ��Ф��Ƥ�ñ��0���֤���*/
1181 int
ltov(l)1182 ltov (l)
1183      letter l;
1184 {
1185   if (is_upper (l))
1186     return (l - 'A' + 10);
1187   if (is_lower (l))
1188     return (l - 'a' + 10);
1189   if (is_digit (l))
1190     return (l - '0');
1191   else
1192     return (0);
1193 }
1194 
1195  /** ltov�ε� */
1196 /* *INDENT-OFF* */
1197 letter
vtol(l)1198 vtol (l)
1199      letter l;
1200 /* *INDENT-ON* */
1201 {
1202   if (BASEMX <= l)
1203     return ('*');
1204   return (l + (l < 10 ? '0' : 'A' - 10));
1205 }
1206 
1207  /**    �����롦���֥륯�����Ȥ���Ǥΰ�ʸ�����Ф���
1208         ��^�פˤ�륳��ȥ��륳����ɽ������\�פˤ��8��10��16��ɽ���ˤ�
1209         �б�����\��ɽ���ϡ���\��o����d����x�Ͽ������¤ӡ�;�ϡפǤ��롣*/
1210 /* *INDENT-OFF* */
1211 letter
onescan(socp,dest)1212 onescan (socp, dest)
1213      letter **socp, *dest;
1214 /* *INDENT-ON* */
1215 {
1216   letter l, realcode;
1217   int digflg;
1218 
1219   switch (realcode = *dest++ = *(*socp)++)
1220     {
1221     case '^':
1222       if (!(' ' <= (l = *(*socp)++) && l < '\177'))
1223         ERRLIN (2);
1224       realcode = ((*dest++ = l) == '?' ? '\177' : l & 0x1f);
1225       break;
1226     case '\\':
1227       digflg = 0;
1228       switch (**socp)
1229         {
1230         case 'n':
1231           *dest++ = *(*socp)++;
1232           realcode = '\n';
1233           break;
1234         case 't':
1235           *dest++ = *(*socp)++;
1236           realcode = '\t';
1237           break;
1238         case 'b':
1239           *dest++ = *(*socp)++;
1240           realcode = '\b';
1241           break;
1242         case 'r':
1243           *dest++ = *(*socp)++;
1244           realcode = '\r';
1245           break;
1246         case 'f':
1247           *dest++ = *(*socp)++;
1248           realcode = '\f';
1249           break;
1250         case 'e':
1251         case 'E':
1252           *dest++ = *(*socp)++;
1253           realcode = ESCCHR;
1254           break;
1255         case 'o':
1256           *dest++ = *(*socp)++;
1257           for (realcode = 0; is_octal (**socp);)
1258             {
1259               digflg = 1;
1260               realcode <<= 3;
1261               realcode += ltov (*dest++ = *(*socp)++);
1262             }
1263           if (!digflg)
1264             ERRLIN (2);
1265           if (**socp == ';')
1266             *dest++ = *(*socp)++;
1267           break;
1268         case 'x':
1269           *dest++ = *(*socp)++;
1270           for (realcode = 0; is_xdigit (**socp);)
1271             {
1272               digflg = 1;
1273               realcode <<= 4;
1274               realcode += ltov (*dest++ = *(*socp)++);
1275             }
1276           if (!digflg)
1277             ERRLIN (2);
1278           if (**socp == ';')
1279             *dest++ = *(*socp)++;
1280           break;
1281         case 'd':
1282           *dest++ = *(*socp)++;
1283           for (realcode = 0; is_digit (**socp);)
1284             {
1285               digflg = 1;
1286               realcode *= 10;
1287               realcode += ltov (*dest++ = *(*socp)++);
1288             }
1289           if (!digflg)
1290             ERRLIN (2);
1291           if (**socp == ';')
1292             *dest++ = *(*socp)++;
1293           break;
1294         default:
1295           if (is_octal (**socp))
1296             {
1297               for (realcode = 0; is_octal (**socp);)
1298                 {
1299                   realcode <<= 3;
1300                   realcode += ltov (*dest++ = *(*socp)++);
1301                 }
1302               if (**socp == ';')
1303                 *dest++ = *(*socp)++;
1304             }
1305           else
1306             {
1307               realcode = *dest++ = *(*socp)++;
1308             }
1309         }
1310       break;
1311     default:;
1312     }
1313 
1314   *dest = EOLTTR;
1315   return (realcode);
1316 }
1317 
1318  /**    letter�������Ƭ�ˤ����������åפ��롣
1319         ������ã�����顢flg��0�ΤȤ���1���֤��������Ǥʤ��ȥ��顼��*/
1320 static int
blankpass(pptr,flg)1321 blankpass (pptr, flg)
1322      register letter **pptr;
1323          /* letter����Υݥ����ؤΥݥ��������줬�ؤ��Ƥ����Τ�ʤ�� */
1324      int flg;
1325 {
1326   while (is_eolsp (**pptr))
1327     {
1328       if (EOLTTR == **pptr)
1329         {
1330           if (flg)
1331             ERRLIN (4);
1332           return (1);
1333         }
1334       (*pptr)++;
1335     }
1336   return (0);
1337 }
1338 
1339  /** �ꥹ�Ȱ�ļ��Ф� */
1340 static void
listscan(socp,dest)1341 listscan (socp, dest)
1342      register letter **socp, *dest;
1343 {
1344   int eofreach;
1345 
1346   *dest++ = *(*socp)++;         /* = '(' */
1347   *dest++ = ' ';
1348 
1349   while (eofreach = blankpass (socp, 0), **socp != ')')
1350     {
1351       if (eofreach)
1352         {
1353           if (!readln ((uns_chr *) hcurread))
1354             ERRLIN (20);
1355           ustrtoltr ((uns_chr *) hcurread, (*socp = ltrbufbgn), 1);
1356           /* list����ǹԤ��ڤ�Ƥ����硢����ɲ��ɤ߹��ߤ�
1357              ���롣uns_chr�ѤΥХåե��⡢letter�ѤΤ�Τ⡢
1358              ������ʪ����Ƭ��������Ѥ��Ƥ���Τ���ա��ޤ���
1359              ���顼����������硢 ���顼�ΰ��֤ˤ�����餺��
1360              ���߹ԤȤ���ɽ�������Τϡ��Ǹ���ɤޤ줿�ԤΤ� */
1361         }
1362       else
1363         {
1364           termsscan (socp, dest, 0);
1365           totail (dest);
1366           *dest++ = ' ';
1367         }
1368     }
1369   *dest++ = *(*socp)++;         /* = ')' */
1370   *dest = EOLTTR;
1371 }
1372 
1373  /** lp�ǻ��ꤵ�줿�⡼��̾��õ�������Ĥ���ʤ��ȥ��顼 */
1374 static int
modsrcL(lp)1375 modsrcL (lp)
1376      letter *lp;
1377 {
1378   int n;
1379 
1380   for (n = 0; modmeibgn[n] != NULL; n++)
1381     if (!ltrstrcmp (lp, modmeibgn[n]))
1382       return (n);
1383 
1384   ERRLIN (16);
1385    /*NOTREACHED*/ return (-1);
1386 }
1387 
1388  /** chk_get_int��rk_modread.c�ˤ�letter�� */
1389 static int
chkL_get_int(lp,ip,range)1390 chkL_get_int (lp, ip, range)
1391      letter *lp;
1392      modetyp *ip;
1393      modetyp range;
1394 {
1395   int sgn = 1;
1396   modetyp out;
1397 
1398   if (*lp == '-')
1399     {
1400       lp++;
1401       sgn = -1;
1402     }
1403   for (out = 0; *lp != EOLTTR; lp++)
1404     {
1405       if (!is_digit (*lp))
1406         return (-1);
1407       out *= 10;
1408       out += ltov (*lp);
1409     }
1410   if (range != 0)
1411     out %= range;
1412   if (sgn == -1 && out != 0)
1413     out = range - out;
1414   *ip = out;
1415   return (0);
1416 }
1417 
1418  /**    ������ϡ�ɽ�ɤ߹��ߤǥ���ä����˷ٹ���롼����n�ϥ��顼�����ɡ�
1419         �ޤ����������ơ�romkan_init�Υ��顼�����ɤȤ��ơ�longjmp��ͳ��
1420         1���֤���*/
1421 
1422 void
ERMOPN(n)1423 ERMOPN (n)                      /* �⡼�����ɽ�������ץ�Ǥ��ʤ� */
1424      unsigned int n;
1425 {
1426   static char *ermes[] = {
1427     /*  0 */ "Can't open Mode-hyo",
1428     "Unprintable error"
1429   };
1430 
1431   if (n >= numberof (ermes))
1432     n = 1;
1433 
1434   fprintf (stderr, "\r\nMode-hyo %s ---\r\n", curfnm);
1435   fprintf (stderr, "%d: %s.\r\n", n, ermes[n]);
1436   longjmp (env0, 1);
1437 }
1438 
1439 static void
ERHOPN(n)1440 ERHOPN (n)                      /* �Ѵ��б�ɽ�������ץ�Ǥ��ʤ� */
1441      unsigned int n;
1442 {
1443   static char *ermes[] = {
1444     /*  0 */ "Can't open Taio-hyo",
1445     "Is a directory",
1446     "Unprintable error"
1447   };
1448 
1449   if (n >= numberof (ermes))
1450     n = 2;
1451 
1452   fprintf (stderr, "\r\nTaio-hyo %s%s ---\r\n", curdir, curfnm);
1453   fprintf (stderr, "%d: %s.\r\n", n, ermes[n]);
1454   longjmp (env0, 1);
1455 }
1456 
1457 void
ERRMOD(n)1458 ERRMOD (n)                      /* �⡼�����ɽ�Υ��顼 */
1459      unsigned int n;
1460 {
1461   static char *ermes[] = {
1462     /*  0 */ "Table incomplete",
1463     "')' mismatch",
1464     "Unprintable error",
1465     "Illegal filename",
1466     "Illegal modename",
1467     /*  5 */ "Undefined mode",
1468     "Illegal content(s) of list",
1469     "Illegal ^,\\o,\\x or \\d expression",
1470     "Illegal defmode",
1471     "Unrecognized keyword",
1472     /* 10 */ "Incomplete string",
1473     "Search path specified after filename",
1474     "Argument must be a string",
1475     "Can't get home directory",
1476     "Illegal @-keyword",
1477     /* 15 */ "User doesn't exist",
1478     "Illegal character",
1479     "Defmode or set-path placed wrong"
1480   };
1481 
1482   if (n >= numberof (ermes))
1483     n = 2;
1484 
1485   fprintf (stderr, "\r\nMode-hyo %s%s ---\r\n%s\r\n", curdir, curfnm, mcurread);
1486   fprintf (stderr, "%d: %s.\r\n", n, ermes[n]);
1487   fclose (modefile);
1488   longjmp (env0, 1);
1489 }
1490 
1491 static void
ERRLIN(n)1492 ERRLIN (n)                      /* �Ѵ��б�ɽ�Υ��顼 */
1493      unsigned int n;
1494 {
1495   static char *ermes[] = {
1496     /*  0 */ "')' mismatch",
1497     "Incomplete single-quote or double-quote expression",
1498     "Illegal ^,\\o,\\x or \\d expression",
1499     "Illegal variable name",
1500     "Incomplete line",
1501     /*  5 */ "Evaluation of unbound variable",
1502     "Unprintable error",
1503     "Too many or too few contents of list",
1504     "Illegal defvar/defconst",
1505     "Faculity or declaration joined other item(s)",
1506     /* 10 */ "Duplicate defvar/defconst",
1507     "Variable/constant name conflicts with Function name",
1508     "A line contains both declaration and other output item(s)",
1509     "Argument isn't a letter",
1510     "Function, faculity or declaration in illegal place",
1511     /* 15 */ "More than 3 items",
1512     "Undefined mode",
1513     "Against the restriction of pre-transform table",
1514     "Against the restriction of after-transform table",
1515     "Item comes after faculity",
1516     /* 20 */ "Incomplete list",
1517     "Illegal character",
1518     "Illegal include",
1519     "Too many levels of 'include' nest",
1520     "Can't open include file",
1521     /* 25 */ "Can't get home directory",
1522     "Illegal @-keyword",
1523     "User doesn't exist",
1524     "Constant must be defined before used",
1525     "Illegal mode status"
1526   };
1527 
1528   if (n >= numberof (ermes))
1529     n = 6;
1530 
1531   fprintf (stderr, "\r\nTaio-hyo %s%s ---\r\n%s\r\n", curdir, curfnm, hcurread);
1532   fprintf (stderr, "%d: %s.\r\n", n, ermes[n]);
1533 
1534   while (NULL != *base)
1535     fclose (*base--);
1536 
1537   longjmp (env0, 1);
1538 }
1539 
1540 static void
ERRHYO(n)1541 ERRHYO (n)                      /* ERRLIN��Ʊ�͡��б�ɽ�Υ��顼��������Ԥ����θ��Ǥʤ�
1542                                    ���Τ��ʤ��Ȥ狼��ʤ���ꡣ���νꡢ��̤����ѿ��νи��פΤߡ� */
1543      unsigned int n;
1544 {
1545   static char *ermes[] = {
1546     /*  0 */ "Undefined variable was found",
1547     "Unprintable error"
1548   };
1549 
1550   if (n >= numberof (ermes))
1551     n = 1;
1552 
1553   fprintf (stderr, "\r\nTaio-hyo %s%s ---\r\n", curdir, curfnm);
1554   fprintf (stderr, "%d: %s.\r\n", n, ermes[n]);
1555 
1556   while (NULL != *base)
1557     fclose (*base--);
1558 
1559   longjmp (env0, 1);
1560 }
1561