static REGPTR syncase(register int esym)
{
skipnl();
if (wdval == esym) {
return (0);
} else {
register REGPTR r = (REGPTR) getstak(REGTYPE);
r->regptr = 0;
for (;;) {
wdarg->argnxt = r->regptr;
r->regptr = wdarg;
if (wdval || (word() != ')' && wdval != '|')) {
synbad();
}
if (wdval == '|') {
word();
} else {
break;
}
}
r->regcom = cmd(0, NLFLG | MTFLG);
if (wdval == ECSYM) {
r->regnxt = syncase(esym);
} else {
chksym(esym);
r->regnxt = 0;
}
return (r);
}
}
TREPTR cmd(register int sym, int flg)
{
register TREPTR i, e;
i = list(flg);
if (wdval == NL) {
if (flg & NLFLG) {
wdval = ';';
chkpr(NL);
}
} else if (i == 0 && (flg & MTFLG) == 0) {
synbad();
}
switch (wdval) {
case '&':
if (i)
i = makefork(FINT | FPRS | FAMP, i);
else
synbad();
case ';':
if (e = cmd(sym, flg | MTFLG))
i = makelist(TLST, i, e);
break;
case EOFSYM:
if (sym == NL)
break;
default:
if (sym)
chksym(sym);
}
return i;
}
static void chk_get(struct rnc_source *sp,int sym) {
(void)chksym(sp,sym); getsym(sp);
}
static int arx(char *fn) {
if((arxfd=open(arxfn=fn,O_RDONLY))==-1) {
(*er_printf)("error (%s): %s\n",arxfn,strerror(errno));
return 0;
} else {
errors=0;
len_b=read(arxfd,buf,BUFSIZE); i_b=u_bom(buf,len_b);
prevline=-1; line=1; col=0; rnc=0;
cc=' '; getsym();
chk_get(SYM_GRMS); chk_get(SYM_LCUR);
do {
if(i_2==len_2) t2s=(int(*)[2])m_stretch(t2s,len_2=i_2*2,i_2,sizeof(int[2]));
if(chksym(SYM_IDNT)) t2s[i_2][0]=add_s(value);
getsym();
chk_get(SYM_ASGN);
if(chksym(SYM_LTRL)) {
if(path2abs) {
int len=strlen(arxfn)+strlen(value)+1;
if(len>len_v) {value=(char*)m_stretch(value,len,len_v,sizeof(char)); len_v=len;}
s_abspath(value,arxfn);
}
t2s[i_2][1]=add_s(value);
}
getsym();
++i_2;
} while(sym==SYM_IDNT);
chk_get(SYM_RCUR);
for(;;) {
if(i_r==len_r) rules=(int(*)[3])m_stretch(rules,len_r=i_r*2,i_r,sizeof(int[3]));
switch(sym) {
case SYM_MTCH: rules[i_r][0]=MATCH; goto REGEXP;
case SYM_NMTC: rules[i_r][0]=NOMAT; goto REGEXP;
REGEXP: getsym();
if(chksym(SYM_RGXP)) {
if(!rx_check(value)) error(ARX_ER_REX);
rules[i_r][1]=add_s(value);
}
getsym();
if(chksym(SYM_IDNT)) rules[i_r][2]=typ2str();
goto NEXT;
case SYM_VALD: rules[i_r][0]=VALID; goto RNG;
case SYM_NVAL: rules[i_r][0]=INVAL; goto RNG;
RNG: getsym();
if(chksym(SYM_RENG)) {
char *rncfn=(char*)m_alloc(strlen(arxfn)+strlen("#rnc[]")+12,sizeof(char));
sprintf(rncfn,"%s#rnc[%i]",arxfn,rnc++);
if(!(rules[i_r][1]=rnl_s(rncfn,value,strlen(value)))) error(ARX_ER_RNG);
m_free(rncfn);
}
getsym();
if(chksym(SYM_IDNT)) rules[i_r][2]=typ2str();
goto NEXT;
default: goto LAST;
}
NEXT: ++i_r; getsym();
}
LAST: chk_get(SYM_EOF);
close(arxfd);
return !errors;
}
}
static void chk_get(int x) {
(void)chksym(x); getsym();
}
static TREPTR item(BOOL flag)
{
register TREPTR t;
register IOPTR io;
if (flag)
io = inout((IOPTR) 0);
else
io = 0;
switch (wdval) {
case CASYM:
{
t = (TREPTR) getstak(SWTYPE);
chkword();
((SWPTR) t)->swarg = wdarg->argval;
skipnl();
chksym(INSYM | BRSYM);
((SWPTR) t)->swlst = syncase(wdval == INSYM ? ESSYM : KTSYM);
((SWPTR) t)->swtyp = TSW;
break;
}
case IFSYM:
{
register int w;
t = (TREPTR) getstak(IFTYPE);
((IFPTR) t)->iftyp = TIF;
((IFPTR) t)->iftre = cmd(THSYM, NLFLG);
((IFPTR) t)->thtre = cmd(ELSYM | FISYM | EFSYM, NLFLG);
((IFPTR) t)->eltre = ((w = wdval) == ELSYM ?
cmd(FISYM, NLFLG) :
(w == EFSYM ? (wdval = IFSYM, item(0)) : 0));
if (w == EFSYM)
return (t);
break;
}
case FORSYM:
{
t = (TREPTR) getstak(FORTYPE);
((FORPTR) t)->fortyp = TFOR;
((FORPTR) t)->forlst = 0;
chkword();
((FORPTR) t)->fornam = wdarg->argval;
if (skipnl() == INSYM) {
chkword();
((FORPTR) t)->forlst = (COMPTR) item(0);
if (wdval != NL && wdval != ';')
synbad();
chkpr(wdval);
skipnl();
}
chksym(DOSYM | BRSYM);
((FORPTR) t)->fortre =
cmd(wdval == DOSYM ? ODSYM : KTSYM, NLFLG);
break;
}
case WHSYM:
case UNSYM:
{
t = (TREPTR) getstak(WHTYPE);
((WHPTR) t)->whtyp = (wdval == WHSYM ? TWH : TUN);
((WHPTR) t)->whtre = cmd(DOSYM, NLFLG);
((WHPTR) t)->dotre = cmd(ODSYM, NLFLG);
break;
}
case BRSYM:
t = cmd(KTSYM, NLFLG);
break;
case '(':
{
register PARPTR p;
p = (PARPTR) getstak(PARTYPE);
p->partre = cmd(')', NLFLG);
p->partyp = TPAR;
t = makefork(0, /*FIXME*/(void *)p);
break;
}
default:
if (io == 0)
return (0);
case 0:
{
register ARGPTR argp;
register ARGPTR *argtail;
register ARGPTR *argset = 0;
int keywd = 1;
t = (TREPTR) getstak(COMTYPE);
((COMPTR) t)->comio = io; /*initial io chain */
argtail = &(((COMPTR) t)->comarg);
while (wdval == 0) {
argp = wdarg;
if (wdset && keywd) {
argp->argnxt = (ARGPTR) argset;
argset = (ARGPTR *) argp;
} else {
*argtail = argp;
argtail = &(argp->argnxt);
keywd = flags & keyflg;
}
word();
if (flag)
((COMPTR) t)->comio = inout(((COMPTR) t)->comio);
}
((COMPTR) t)->comtyp = TCOM;
((COMPTR) t)->comset = (ARGPTR) argset;
*argtail = 0;
return (t);
}
}
reserv++;
word();
if (io = inout(io)) {
t = makefork(0, t);
t->treio = io;
}
return t;
}
