int nextc(char quote)
{
register char c, d;
if ((d = readc()) == ESCAPE) {
if ((c = readc()) == NL) {
chkpr(NL);
d = nextc(quote);
} else if (quote && c != quote && !escchar(c))
peekc = c | MARK;
else
d = c | QUOTE;
}
return d;
}
unsigned int nextwc()
{
unsigned int c, d;
retry:
if ((d = readwc()) == ESCAPE) {
if ((c = readwc()) == NL) {
chkpr();
goto retry;
}
peekc = c | MARK;
}
return (d);
}
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;
}
void copy(IOPTR ioparg)
{
CHAR c, *ends;
register CHAR *cline, *clinep;
int fd;
register IOPTR iop;
if (iop = ioparg) {
copy(iop->iolst);
ends = mactrim(iop->ioname);
if (nosubst)
iop->iofile &= ~IODOC;
fd = tmpfil();
iop->ioname = cpystak(tmpout);
iop->iolst = iotemp;
iotemp = iop;
cline = locstak();
for (;;) {
clinep = cline;
chkpr(NL);
while ((c = (nosubst ? readc() : nextc(*ends)),!eolchar(c))) {
*clinep++ = c;
}
*clinep = 0;
if (eof || eq(cline, ends))
break;
*clinep++ = NL;
write(fd, cline, clinep - cline);
}
close(fd);
}
}
int
word(void)
{
register unsigned int c, d, cc;
struct argnod *arg = (struct argnod *)locstak();
register unsigned char *argp = arg->argval;
unsigned char *oldargp;
int alpha = 1;
unsigned char *pc;
wdnum = 0;
wdset = 0;
while (1)
{
while (c = nextwc(), space(c)) /* skipc() */
;
if (c == COMCHAR)
{
while ((c = readwc()) != NL && c != EOF);
peekc = c;
}
else
{
break; /* out of comment - white space loop */
}
}
if (!eofmeta(c))
{
do
{
if (c == LITERAL)
{
oldargp = argp;
while ((c = readwc()) && c != LITERAL){
/*
* quote each character within
* single quotes
*/
pc = readw(c);
if (argp >= brkend)
growstak(argp);
*argp++='\\';
/* Pick up rest of multibyte character */
if (c == NL)
chkpr();
while (c = *pc++) {
if (argp >= brkend)
growstak(argp);
*argp++ = (unsigned char)c;
}
}
if (argp == oldargp) { /* null argument - '' */
/*
* Word will be represented by quoted null
* in macro.c if necessary
*/
if (argp >= brkend)
growstak(argp);
*argp++ = '"';
if (argp >= brkend)
growstak(argp);
*argp++ = '"';
}
}
else
{
if (c == 0) {
if (argp >= brkend)
growstak(argp);
*argp++ = 0;
} else {
pc = readw(c);
while (*pc) {
if (argp >= brkend)
growstak(argp);
*argp++ = *pc++;
}
}
if (c == '\\') {
if ((cc = readwc()) == 0) {
if (argp >= brkend)
growstak(argp);
*argp++ = 0;
} else {
pc = readw(cc);
while (*pc) {
if (argp >= brkend)
growstak(argp);
*argp++ = *pc++;
}
}
}
if (c == '=')
wdset |= alpha;
if (!alphanum(c))
alpha = 0;
if (qotchar(c))
{
d = c;
for (;;)
{
if ((c = nextwc()) == 0) {
if (argp >= brkend)
growstak(argp);
*argp++ = 0;
} else {
pc = readw(c);
while (*pc) {
if (argp >= brkend)
growstak(argp);
*argp++ = *pc++;
}
}
if (c == 0 || c == d)
break;
if (c == NL)
chkpr();
/*
* don't interpret quoted
* characters
*/
if (c == '\\') {
if ((cc = readwc()) == 0) {
if (argp >= brkend)
growstak(argp);
*argp++ = 0;
} else {
pc = readw(cc);
while (*pc) {
if (argp >= brkend)
growstak(argp);
*argp++ = *pc++;
}
}
}
}
}
}
} while ((c = nextwc(), !eofmeta(c)));
argp = endstak(argp);
if (!letter(arg->argval[0]))
wdset = 0;
peekn = c | MARK;
if (arg->argval[1] == 0 &&
(d = arg->argval[0], digit(d)) &&
(c == '>' || c == '<'))
{
word();
wdnum = d - '0';
}else{ /* check for reserved words */
if (reserv == FALSE ||
(wdval = syslook(arg->argval,
reserved, no_reserved)) == 0) {
wdval = 0;
}
/* set arg for reserved words too */
wdarg = arg;
}
}else if (dipchar(c)){
if ((d = nextwc()) == c)
{
wdval = c | SYMREP;
if (c == '<')
{
if ((d = nextwc()) == '-')
wdnum |= IOSTRIP;
else
peekn = d | MARK;
}
}
else
{
peekn = d | MARK;
wdval = c;
}
}
else
{
if ((wdval = c) == EOF)
wdval = EOFSYM;
if (iopend && eolchar(c))
{
struct ionod *tmp_iopend;
tmp_iopend = iopend;
iopend = 0;
copy(tmp_iopend);
}
}
reserv = FALSE;
return (wdval);
}
void
copy(struct ionod *ioparg)
{
unsigned char *cline;
unsigned char *clinep;
struct ionod *iop;
unsigned int c;
unsigned char *ends;
unsigned char *start;
int fd;
int i;
int stripflg;
unsigned char *pc;
if (iop = ioparg)
{
struct tempblk tb;
copy(iop->iolst);
ends = mactrim(iop->ioname);
stripflg = iop->iofile & IOSTRIP;
if (nosubst)
iop->iofile &= ~IODOC;
fd = tmpfil(&tb);
if (fndef)
iop->ioname = (char *) make(tmpout);
else
iop->ioname = (char *) cpystak(tmpout);
iop->iolst = iotemp;
iotemp = iop;
cline = clinep = start = locstak();
if (stripflg)
{
iop->iofile &= ~IOSTRIP;
while (*ends == '\t')
ends++;
}
for (;;)
{
chkpr();
if (nosubst)
{
c = readwc();
if (stripflg)
while (c == '\t')
c = readwc();
while (!eolchar(c))
{
pc = readw(c);
while (*pc) {
if (clinep >= brkend)
growstak(clinep);
*clinep++ = *pc++;
}
c = readwc();
}
}else{
c = nextwc();
if (stripflg)
while (c == '\t')
c = nextwc();
while (!eolchar(c))
{
pc = readw(c);
while (*pc) {
if (clinep >= brkend)
growstak(clinep);
*clinep++ = *pc++;
}
if (c == '\\')
{
pc = readw(readwc());
/* *pc might be NULL */
if (*pc) {
while (*pc) {
if (clinep >= brkend)
growstak(clinep);
*clinep++ = *pc++;
}
} else {
if (clinep >= brkend)
growstak(clinep);
*clinep++ = *pc;
}
}
c = nextwc();
}
}
if (clinep >= brkend)
growstak(clinep);
*clinep = 0;
if (eof || eq(cline, ends))
{
if ((i = cline - start) > 0)
write(fd, start, i);
break;
}else{
if (clinep >= brkend)
growstak(clinep);
*clinep++ = NL;
}
if ((i = clinep - start) < CPYSIZ)
cline = clinep;
else
{
write(fd, start, i);
cline = clinep = start;
}
}
poptemp(); /*
* pushed in tmpfil -- bug fix for problem
* deleting in-line scripts
*/
}
}
int word(void)
{
register char c, d;
register char *argp = locstak() + BYTESPERWORD;
int alpha = 1;
wdnum = 0;
wdset = 0;
while (1)
{
while (c = nextc(0), space(c)) /* skipc() */
;
if (c == COMCHAR)
{
while ((c = readc()) != NL && c != EOF);
peekc = c;
}
else
{
break; /* out of comment - white space loop */
}
}
if (!eofmeta(c)) {
do {
if (c == LITERAL) {
*argp++ = (DQUOTE);
while ((c = readc()) && c != LITERAL) {
*argp++ = (c | QUOTE);
chkpr(c);
}
*argp++ = (DQUOTE);
} else {
*argp++ = (c);
if (c == '=')
wdset |= alpha;
if (!alphanum(c))
alpha = 0;
if (qotchar(c)) {
d = c;
while ((*argp++ = (c = nextc(d))) && c != d)
chkpr(c);
}
}
} while ((c = nextc(0), !eofmeta(c)));
argp = endstak(argp);
if (!letter(((ARGPTR) argp)->argval[0]))
wdset = 0;
peekc = c | MARK;
if (((ARGPTR) argp)->argval[1] == 0
&& (d = ((ARGPTR) argp)->argval[0], digit(d))
&& (c == '>' || c == '<')) {
word();
wdnum = d - '0';
} else { /*check for reserved words */
if (reserv == FALSE
|| (wdval = syslook(((ARGPTR) argp)->argval, reserved)) == 0) {
wdarg = (ARGPTR) argp;
wdval = 0;
}
}
} else if (dipchar(c)) {
if ((d = nextc(0)) == c)
wdval = c | SYMREP;
else {
peekc = d | MARK;
wdval = c;
}
} else {
if ((wdval = c) == EOF)
wdval = EOFSYM;
if (iopend && eolchar(c)) {
copy(iopend);
iopend = 0;
}
}
reserv = FALSE;
return wdval;
}
static int skipnl(void)
{
while (reserv++, word() == NL)
chkpr(NL);
return wdval;
}
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;
}
