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 (<rbufptr, 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