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);
}
}
char *
cpystak(char *x)
{
char *tmp = getstak(length(x));
movstr(x, tmp);
return tmp;
}
TREPTR makefork(int flgs, TREPTR i)
{
register FORKPTR t;
t = (FORKPTR) getstak(FORKTYPE);
t->forktyp = flgs | TFORK;
t->forktre = i;
t->forkio = 0;
return (TREPTR) (t);
}
static TREPTR makelist(int type, TREPTR i, TREPTR r)
{
register LSTPTR t;
if (i == 0 || r == 0)
synbad();
else {
t = (LSTPTR) getstak(LSTTYPE);
t->lsttyp = type;
t->lstlef = i;
t->lstrit = r;
}
return (TREPTR) (t);
}
static IOPTR inout(IOPTR lastio)
{
register int iof;
register IOPTR iop;
register CHAR c;
iof = wdnum;
switch (wdval) {
case DOCSYM:
iof |= IODOC;
break;
case APPSYM:
case '>':
if (wdnum == 0)
iof |= 1;
iof |= IOPUT;
if (wdval == APPSYM) {
iof |= IOAPP;
break;
}
case '<':
if ((c = nextc(0)) == '&')
iof |= IOMOV;
else if (c == '>')
iof |= IORDW;
else
peekc = c | MARK;
break;
default:
return (lastio);
}
chkword();
iop = (IOPTR) getstak(IOTYPE);
iop->ioname = wdarg->argval;
iop->iofile = iof;
if (iof & IODOC) {
iop->iolst = iopend;
iopend = iop;
}
word();
iop->ionxt = inout(lastio);
return (iop);
}
char *
endstak ()
{
pushstak(0);
return getstak(staktop-stakbot);
}
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;
}
