#include "defs.h"
-PROC STRING *copyargs();
-LOCAL DOLPTR dolh;
+extern char **copyargs();
+static struct dolnod *dolh;
-CHAR flagadr[10];
+char flagadr[10];
-CHAR flagchar[] = {
+char flagchar[] = {
'x', 'n', 'v', 't', 's', 'i', 'e', 'r', 'k', 'u', 0
-};
-INT flagval[] = {
+}
+int flagval[] = {
execpr, noexec, readpr, oneflg, stdflg, intflg, errflg, rshflg, keyflg, setflg, 0
-};
+}
/* ======== option handling ======== */
-INT options(argc,argv)
- STRING *argv;
- INT argc;
+int options(argc,argv)
+ char **argv;
+ int argc;
{
- REG STRING cp;
- REG STRING *argp=argv;
- REG STRING flagc;
- STRING flagp;
+ register char *cp;
+ register char **argp=argv;
+ register char *flagc;
+ char *flagp;
- IF argc>1 ANDF *argp[1]=='-'
- THEN cp=argp[1];
+ if (argc>1 && *argp[1]=='-') {
+ cp=argp[1];
flags &= ~(execpr|readpr);
- WHILE *++cp
- DO flagc=flagchar;
-
- WHILE *flagc ANDF *flagc != *cp DO flagc++ OD
- IF *cp == *flagc
- THEN flags |= flagval[flagc-flagchar];
- ELIF *cp=='c' ANDF argc>2 ANDF comdiv==0
- THEN comdiv=argp[2];
+ while (*++cp) {
+ flagc=flagchar;
+
+ while (*flagc && *flagc != *cp) { flagc++; }
+ if (*cp == *flagc) {
+ flags |= flagval[flagc-flagchar];
+ }
+ else if (*cp=='c' && argc>2 && comdiv==0) {
+ comdiv=argp[2];
argp[1]=argp[0]; argp++; argc--;
- ELSE failed(argv[1],badopt);
- FI
- OD
+ }
+ else {
+ failed(argv[1],badopt);
+ }
+ }
argp[1]=argp[0]; argc--;
- FI
+ }
/* set up $- */
flagc=flagchar;
flagp=flagadr;
- WHILE *flagc
- DO IF flags&flagval[flagc-flagchar]
- THEN *flagp++ = *flagc;
- FI
+ while (*flagc) {
+ if (flags&flagval[flagc-flagchar]) {
+ *flagp++ = *flagc;
+ }
flagc++;
- OD
+ }
*flagp++=0;
return(argc);
}
-VOID setargs(argi)
- STRING argi[];
+void setargs(argi)
+ char *argi[];
{
/* count args */
- REG STRING *argp=argi;
- REG INT argn=0;
+ register char **argp=argi;
+ register int argn=0;
- WHILE Rcheat(*argp++)!=ENDARGS DO argn++ OD
+ while (Rcheat(*argp++)!=ENDARGS) { argn++; }
/* free old ones unless on for loop chain */
freeargs(dolh);
}
freeargs(blk)
- DOLPTR blk;
+ struct dolnod *blk;
{
- REG STRING *argp;
- REG DOLPTR argr=0;
- REG DOLPTR argblk;
-
- IF argblk=blk
- THEN argr = argblk->dolnxt;
- IF (--argblk->doluse)==0
- THEN FOR argp=argblk->dolarg; Rcheat(*argp)!=ENDARGS; argp++
- DO free(*argp) OD
+ register char **argp;
+ register struct dolnod *argr=0;
+ register struct dolnod *argblk;
+
+ if (argblk=blk) {
+ argr = argblk->dolnxt;
+ if ((--argblk->doluse)==0) {
+ for (argp=argblk->dolarg; Rcheat(*argp)!=ENDARGS; argp++) { free(*argp); }
free(argblk);
- FI
- FI
+ }
+ }
return(argr);
}
-LOCAL STRING * copyargs(from, n)
- STRING from[];
+static char*CHECKME * copyargs(from, n)
+ char *from[];
{
- REG STRING * np=alloc(sizeof(STRING*)*n+3*BYTESPERWORD);
- REG STRING * fp=from;
- REG STRING * pp=np;
+ register char ** np=alloc(sizeof(char*CHECKME*)*n+3*BYTESPERWORD);
+ register char ** fp=from;
+ register char ** pp=np;
np->doluse=1; /* use count */
np=np->dolarg;
dolv=np;
- WHILE n--
- DO *np++ = make(*fp++) OD
+ while (n--) { *np++ = make(*fp++); }
*np++ = ENDARGS;
return(pp);
}
clearup()
{
/* force `for' $* lists to go away */
- WHILE argfor=freeargs(argfor) DONE
+ while (argfor=freeargs(argfor));
/* clean up io files */
- WHILE pop() DONE
+ while (pop());
}
-DOLPTR useargs()
+struct dolnod *useargs()
{
- IF dolh
- THEN dolh->doluse++;
+ if (dolh) {
+ dolh->doluse++;
dolh->dolnxt=argfor;
return(argfor=dolh);
- ELSE return(0);
- FI
+ }
+ else {
+ return(0);
+ }
}
#define BUSY 01
#define busy(x) (Rcheat((x)->word)&BUSY)
-POS brkincr=BRKINCR;
-BLKPTR blokp; /*current search pointer*/
-BLKPTR bloktop=BLK(end); /*top of arena (last blok)*/
+unsigned brkincr=BRKINCR;
+struct blk *blokp; /*current search pointer*/
+struct blk *bloktop=(struct blk *)(end); /*top of arena (last blok)*/
-ADDRESS alloc(nbytes)
- POS nbytes;
+void *alloc(nbytes)
+ unsigned nbytes;
{
- REG POS rbytes = round(nbytes+BYTESPERWORD,BYTESPERWORD);
-
- LOOP INT c=0;
- REG BLKPTR p = blokp;
- REG BLKPTR q;
- REP IF !busy(p)
- THEN WHILE !busy(q = p->word) DO p->word = q->word OD
- IF ADR(q)-ADR(p) >= rbytes
- THEN blokp = BLK(ADR(p)+rbytes);
- IF q > blokp
- THEN blokp->word = p->word;
- FI
- p->word=BLK(Rcheat(blokp)|BUSY);
- return(ADR(p+1));
- FI
- FI
- q = p; p = BLK(Rcheat(p->word)&~BUSY);
- PER p>q ORF (c++)==0 DONE
+ register unsigned rbytes = round(nbytes+BYTESPERWORD,BYTESPERWORD);
+
+ for(;;) {
+ int c=0;
+ register struct blk *p = blokp;
+ register struct blk *q;
+ do {
+ if (!busy(p)) {
+ while (!busy(q = p->word)) { p->word = q->word; }
+ if ((void *)(q)-(void *)(p) >= rbytes) {
+ blokp = (struct blk *)((void *)(p)+rbytes);
+ if (q > blokp) {
+ blokp->word = p->word;
+ }
+ p->word=(struct blk *)(Rcheat(blokp)|BUSY);
+ return((void *)(p+1));
+ }
+ }
+ q = p; p = (struct blk *)(Rcheat(p->word)&~BUSY);
+ } while (p>q || (c++)==0);
addblok(rbytes);
- POOL
+ }
}
-VOID addblok(reqd)
- POS reqd;
+void addblok(reqd)
+ unsigned reqd;
{
- IF stakbas!=staktop
- THEN REG STKPTR rndstak;
- REG BLKPTR blokstak;
+ if (stakbas!=staktop) {
+ register char *rndstak;
+ register struct blk *blokstak;
pushstak(0);
rndstak=round(staktop,BYTESPERWORD);
- blokstak=BLK(stakbas)-1;
+ blokstak=(struct blk *)(stakbas)-1;
blokstak->word=stakbsy; stakbsy=blokstak;
- bloktop->word=BLK(Rcheat(rndstak)|BUSY);
- bloktop=BLK(rndstak);
- FI
+ bloktop->word=(struct blk *)(Rcheat(rndstak)|BUSY);
+ bloktop=(struct blk *)(rndstak);
+ }
reqd += brkincr; reqd &= ~(brkincr-1);
blokp=bloktop;
- bloktop=bloktop->word=BLK(Rcheat(bloktop)+reqd);
- bloktop->word=BLK(ADR(end)+1);
- BEGIN
- REG STKPTR stakadr=STK(bloktop+2);
+ bloktop=bloktop->word=(struct blk *)(Rcheat(bloktop)+reqd);
+ bloktop->word=(struct blk *)((void *)(end)+1);
+ {
+
+ register char *stakadr=(char *)(bloktop+2);
staktop=movstr(stakbot,stakadr);
stakbas=stakbot=stakadr;
- END
+ }
}
-VOID free(ap)
- BLKPTR ap;
+void free(ap)
+ struct blk *ap;
{
- REG BLKPTR p;
+ register struct blk *p;
- IF (p=ap) ANDF p<bloktop
- THEN Lcheat((--p)->word) &= ~BUSY;
- FI
+ if ((p=ap) && p<bloktop) {
+ Lcheat((--p)->word) &= ~BUSY;
+ }
}
#ifdef DEBUG
chkbptr(ptr)
- BLKPTR ptr;
+ struct blk *ptr;
{
- INT exf=0;
- REG BLKPTR p = end;
- REG BLKPTR q;
- INT us=0, un=0;
+ int exf=0;
+ register struct blk *p = end;
+ register struct blk *q;
+ int us=0, un=0;
- LOOP
+ for(;;) {
+
q = Rcheat(p->word)&~BUSY;
- IF p==ptr THEN exf++ FI
- IF q<end ORF q>bloktop THEN abort(3) FI
- IF p==bloktop THEN break FI
- IF busy(p)
- THEN us += q-p;
- ELSE un += q-p;
- FI
- IF p>=q THEN abort(4) FI
+ if (p==ptr) { exf++; }
+ if (q<end || q>bloktop) { abort(3); }
+ if (p==bloktop) { break; }
+ if (busy(p)) {
+ us += q-p;
+ }
+ else {
+ un += q-p;
+ }
+ if (p>=q) { abort(4); }
p=q;
- POOL
- IF exf==0 THEN abort(1) FI
- prn(un); prc(SP); prn(us); prc(NL);
+ }
+ if (exf==0) { abort(1); }
+ prn(un); prc(' '); prn(us); prc('\n');
}
#endif
#include "defs.h"
#include "sym.h"
-PROC IOPTR inout();
-PROC VOID chkword();
-PROC VOID chksym();
-PROC TREPTR term();
-PROC TREPTR makelist();
-PROC TREPTR list();
-PROC REGPTR syncase();
-PROC TREPTR item();
-PROC VOID skipnl();
-PROC VOID prsym();
-PROC VOID synbad();
+extern struct ionod *inout();
+extern void chkword();
+extern void chksym();
+extern struct trenod *term();
+extern struct trenod *makelist();
+extern struct trenod *list();
+extern struct regnod *syncase();
+extern struct trenod *item();
+extern void skipnl();
+extern void prsym();
+extern void synbad();
/* ======== command line decoding ========*/
-TREPTR makefork(flgs, i)
- INT flgs;
- TREPTR i;
+struct trenod*CHECKME makefork(flgs, i)
+ int flgs;
+ struct trenod *i;
{
- REG TREPTR t;
+ register struct trenod *t;
- t=getstak(FORKTYPE);
+ t=getstak(sizeof(struct forknod));
t->forktyp=flgs|TFORK; t->forktre=i; t->forkio=0;
return(t);
}
-LOCAL TREPTR makelist(type,i,r)
- INT type;
- TREPTR i, r;
+static struct trenod*CHECKME makelist(type,i,r)
+ int type;
+ struct trenod*CHECKME i, r;
{
- REG TREPTR t;
+ register struct trenod *t;
- IF i==0 ORF r==0
- THEN synbad();
- ELSE t = getstak(LSTTYPE);
+ if (i==0 || r==0) {
+ synbad();
+ }
+ else {
+ t = getstak(sizeof(struct lstnod));
t->lsttyp = type;
t->lstlef = i; t->lstrit = r;
- FI
+ }
return(t);
}
* list [ ; cmd ]
*/
-TREPTR cmd(sym,flg)
- REG INT sym;
- INT flg;
+struct trenod*CHECKME cmd(sym,flg)
+ register int sym;
+ int flg;
{
- REG TREPTR i, e;
+ register struct trenod*CHECKME i, e;
i = list(flg);
- IF wdval==NL
- THEN IF flg&NLFLG
- THEN wdval=';'; chkpr(NL);
- FI
- ELIF i==0 ANDF (flg&MTFLG)==0
- THEN synbad();
- FI
+ if (wdval=='\n') {
+ if (flg&NLFLG) {
+ wdval=';'; chkpr('\n');
+ }
+ }
+ else if (i==0 && (flg&MTFLG)==0) {
+ synbad();
+ }
- SWITCH wdval IN
+ switch (wdval) {
+
case '&':
- IF i
- THEN i = makefork(FINT|FPRS|FAMP, i);
- ELSE synbad();
- FI
+ if (i) {
+ i = makefork(FINT|FPRS|FAMP, i);
+ }
+ else {
+ synbad();
+ }
case ';':
- IF e=cmd(sym,flg|MTFLG)
- THEN i=makelist(TLST, i, e);
- FI
+ if (e=cmd(sym,flg|MTFLG)) {
+ i=makelist(TLST, i, e);
+ }
break;
case EOFSYM:
- IF sym==NL
- THEN break;
- FI
+ if (sym=='\n') {
+ break;
+ }
default:
- IF sym
- THEN chksym(sym);
- FI
+ if (sym) {
+ chksym(sym);
+ }
- ENDSW
+ }
return(i);
}
* list || term
*/
-LOCAL TREPTR list(flg)
+static struct trenod *list(flg)
{
- REG TREPTR r;
- REG INT b;
+ register struct trenod *r;
+ register int b;
r = term(flg);
- WHILE r ANDF ((b=(wdval==ANDFSYM)) ORF wdval==ORFSYM)
- DO r = makelist((b ? TAND : TORF), r, term(NLFLG));
- OD
+ while (r && ((b=(wdval==ANDFSYM)) || wdval==ORFSYM)) {
+ r = makelist((b ? TAND : TORF), r, term(NLFLG));
+ }
return(r);
}
* item |^ term
*/
-LOCAL TREPTR term(flg)
+static struct trenod *term(flg)
{
- REG TREPTR t;
+ register struct trenod *t;
reserv++;
- IF flg&NLFLG
- THEN skipnl();
- ELSE word();
- FI
-
- IF (t=item(TRUE)) ANDF (wdval=='^' ORF wdval=='|')
- THEN return(makelist(TFIL, makefork(FPOU,t), makefork(FPIN|FPCL,term(NLFLG))));
- ELSE return(t);
- FI
+ if (flg&NLFLG) {
+ skipnl();
+ }
+ else {
+ word();
+ }
+
+ if ((t=item(-1)) && (wdval=='^' || wdval=='|')) {
+ return(makelist(TFIL, makefork(FPOU,t), makefork(FPIN|FPCL,term(NLFLG))));
+ }
+ else {
+ return(t);
+ }
}
-LOCAL REGPTR syncase(esym)
- REG INT esym;
+static struct regnod *syncase(esym)
+ register int esym;
{
skipnl();
- IF wdval==esym
- THEN return(0);
- ELSE REG REGPTR r=getstak(REGTYPE);
+ if (wdval==esym) {
+ return(0);
+ }
+ else {
+ register struct regnod *r=getstak(sizeof(struct regnod));
r->regptr=0;
- LOOP wdarg->argnxt=r->regptr;
+ for(;;) {
+ wdarg->argnxt=r->regptr;
r->regptr=wdarg;
- IF wdval ORF ( word()!=')' ANDF wdval!='|' )
- THEN synbad();
- FI
- IF wdval=='|'
- THEN word();
- ELSE break;
- FI
- POOL
+ if (wdval || ( word()!=')' && wdval!='|' )) {
+ synbad();
+ }
+ if (wdval=='|') {
+ word();
+ }
+ else {
+ break;
+ }
+ }
r->regcom=cmd(0,NLFLG|MTFLG);
- IF wdval==ECSYM
- THEN r->regnxt=syncase(esym);
- ELSE chksym(esym);
+ if (wdval==ECSYM) {
+ r->regnxt=syncase(esym);
+ }
+ else {
+ chksym(esym);
r->regnxt=0;
- FI
+ }
return(r);
- FI
+ }
}
/*
* begin ... end
*/
-LOCAL TREPTR item(flag)
- BOOL flag;
+static struct trenod *item(flag)
+ bool flag;
{
- REG TREPTR t;
- REG IOPTR io;
+ register struct trenod *t;
+ register struct ionod *io;
- IF flag
- THEN io=inout((IOPTR)0);
- ELSE io=0;
- FI
+ if (flag) {
+ io=inout((struct ionod*CHECKME)0);
+ }
+ else {
+ io=0;
+ }
- SWITCH wdval IN
+ switch (wdval) {
+
case CASYM:
- BEGIN
- t=getstak(SWTYPE);
+ {
+
+ t=getstak(sizeof(struct swnod));
chkword();
t->swarg=wdarg->argval;
skipnl(); chksym(INSYM|BRSYM);
t->swlst=syncase(wdval==INSYM?ESSYM:KTSYM);
t->swtyp=TSW;
break;
- END
+ }
case IFSYM:
- BEGIN
- REG INT w;
- t=getstak(IFTYPE);
+ {
+
+ register int w;
+ t=getstak(sizeof(struct ifnod));
t->iftyp=TIF;
t->iftre=cmd(THSYM,NLFLG);
t->thtre=cmd(ELSYM|FISYM|EFSYM,NLFLG);
t->eltre=((w=wdval)==ELSYM ? cmd(FISYM,NLFLG) : (w==EFSYM ? (wdval=IFSYM, item(0)) : 0));
- IF w==EFSYM THEN return(t) FI
+ if (w==EFSYM) { return(t); }
break;
- END
+ }
case FORSYM:
- BEGIN
- t=getstak(FORTYPE);
+ {
+
+ t=getstak(sizeof(struct fornod));
t->fortyp=TFOR;
t->forlst=0;
chkword();
t->fornam=wdarg->argval;
- IF skipnl()==INSYM
- THEN chkword();
+ if (skipnl()==INSYM) {
+ chkword();
t->forlst=item(0);
- IF wdval!=NL ANDF wdval!=';'
- THEN synbad();
- FI
+ if (wdval!='\n' && wdval!=';') {
+ synbad();
+ }
chkpr(wdval); skipnl();
- FI
+ }
chksym(DOSYM|BRSYM);
t->fortre=cmd(wdval==DOSYM?ODSYM:KTSYM,NLFLG);
break;
- END
+ }
case WHSYM:
case UNSYM:
- BEGIN
- t=getstak(WHTYPE);
+ {
+
+ t=getstak(sizeof(struct whnod));
t->whtyp=(wdval==WHSYM ? TWH : TUN);
t->whtre = cmd(DOSYM,NLFLG);
t->dotre = cmd(ODSYM,NLFLG);
break;
- END
+ }
case BRSYM:
t=cmd(KTSYM,NLFLG);
break;
case '(':
- BEGIN
- REG PARPTR p;
- p=getstak(PARTYPE);
+ {
+
+ register struct parnod *p;
+ p=getstak(sizeof(struct parnod));
p->partre=cmd(')',NLFLG);
p->partyp=TPAR;
t=makefork(0,p);
break;
- END
+ }
default:
- IF io==0
- THEN return(0);
- FI
+ if (io==0) {
+ return(0);
+ }
case 0:
- BEGIN
- REG ARGPTR argp;
- REG ARGPTR *argtail;
- REG ARGPTR *argset=0;
- INT keywd=1;
- t=getstak(COMTYPE);
+ {
+
+ register struct argnod *argp;
+ register struct argnod **argtail;
+ register struct argnod **argset=0;
+ int keywd=1;
+ t=getstak(sizeof(struct comnod));
t->comio=io; /*initial io chain*/
argtail = &(t->comarg);
- WHILE wdval==0
- DO argp = wdarg;
- IF wdset ANDF keywd
- THEN argp->argnxt=argset; argset=argp;
- ELSE *argtail=argp; argtail = &(argp->argnxt); keywd=flags&keyflg;
- FI
+ while (wdval==0) {
+ argp = wdarg;
+ if (wdset && keywd) {
+ argp->argnxt=argset; argset=argp;
+ }
+ else {
+ *argtail=argp; argtail = &(argp->argnxt); keywd=flags&keyflg;
+ }
word();
- IF flag
- THEN t->comio=inout(t->comio);
- FI
- OD
+ if (flag) {
+ t->comio=inout(t->comio);
+ }
+ }
t->comtyp=TCOM; t->comset=argset; *argtail=0;
return(t);
- END
+ }
- ENDSW
+ }
reserv++; word();
- IF io=inout(io)
- THEN t=makefork(0,t); t->treio=io;
- FI
+ if (io=inout(io)) {
+ t=makefork(0,t); t->treio=io;
+ }
return(t);
}
-LOCAL VOID skipnl()
+static void skipnl()
{
- WHILE (reserv++, word()==NL) DO chkpr(NL) OD
+ while ((reserv++, word()=='\n')) { chkpr('\n'); }
return(wdval);
}
-LOCAL IOPTR inout(lastio)
- IOPTR lastio;
+static struct ionod *inout(lastio)
+ struct ionod *lastio;
{
- REG INT iof;
- REG IOPTR iop;
- REG CHAR c;
+ register int iof;
+ register struct ionod *iop;
+ register char c;
iof=wdnum;
- SWITCH wdval IN
+ switch (wdval) {
+
case DOCSYM:
iof |= IODOC; break;
case APPSYM:
case '>':
- IF wdnum==0 THEN iof |= 1 FI
+ if (wdnum==0) { iof |= 1; }
iof |= IOPUT;
- IF wdval==APPSYM
- THEN iof |= IOAPP; break;
- FI
+ if (wdval==APPSYM) {
+ iof |= IOAPP; break;
+ }
case '<':
- IF (c=nextc(0))=='&'
- THEN iof |= IOMOV;
- ELIF c=='>'
- THEN iof |= IORDW;
- ELSE peekc=c|MARK;
- FI
+ if ((c=nextc(0))=='&') {
+ iof |= IOMOV;
+ }
+ else if (c=='>') {
+ iof |= IORDW;
+ }
+ else {
+ peekc=c|MARK;
+ }
break;
default:
return(lastio);
- ENDSW
+ }
chkword();
- iop=getstak(IOTYPE); iop->ioname=wdarg->argval; iop->iofile=iof;
- IF iof&IODOC
- THEN iop->iolst=iopend; iopend=iop;
- FI
+ iop=getstak(sizeof(struct ionod)); iop->ioname=wdarg->argval; iop->iofile=iof;
+ if (iof&IODOC) {
+ iop->iolst=iopend; iopend=iop;
+ }
word(); iop->ionxt=inout(lastio);
return(iop);
}
-LOCAL VOID chkword()
+static void chkword()
{
- IF word()
- THEN synbad();
- FI
+ if (word()) {
+ synbad();
+ }
}
-LOCAL VOID chksym(sym)
+static void chksym(sym)
{
- REG INT x = sym&wdval;
- IF ((x&SYMFLG) ? x : sym) != wdval
- THEN synbad();
- FI
+ register int x = sym&wdval;
+ if (((x&SYMFLG) ? x : sym) != wdval) {
+ synbad();
+ }
}
-LOCAL VOID prsym(sym)
+static void prsym(sym)
{
- IF sym&SYMFLG
- THEN REG SYSPTR sp=reserved;
- WHILE sp->sysval
- ANDF sp->sysval!=sym
- DO sp++ OD
+ if (sym&SYMFLG) {
+ register struct sysnod *sp=reserved;
+ while (sp->sysval
+ && sp->sysval!=sym) { sp++; }
prs(sp->sysnam);
- ELIF sym==EOFSYM
- THEN prs(endoffile);
- ELSE IF sym&SYMREP THEN prc(sym) FI
- IF sym==NL
- THEN prs("newline");
- ELSE prc(sym);
- FI
- FI
+ }
+ else if (sym==EOFSYM) {
+ prs(endoffile);
+ }
+ else {
+ if (sym&SYMREP) { prc(sym); }
+ if (sym=='\n') {
+ prs("newline");
+ }
+ else {
+ prc(sym);
+ }
+ }
}
-LOCAL VOID synbad()
+static void synbad()
{
prp(); prs(synmsg);
- IF (flags&ttyflg)==0
- THEN prs(atline); prn(standin->flin);
- FI
+ if ((flags&ttyflg)==0) {
+ prs(atline); prn(standin->flin);
+ }
prs(colon);
- prc(LQ);
- IF wdval
- THEN prsym(wdval);
- ELSE prs(wdarg->argval);
- FI
- prc(RQ); prs(unexpected);
+ prc('`');
+ if (wdval) {
+ prsym(wdval);
+ }
+ else {
+ prs(wdarg->argval);
+ }
+ prc('\''); prs(unexpected);
newline();
exitsh(SYNBAD);
}
/* x y z { | } ~ del */
0, 0, 0, 0, _BAR, 0, 0, 0
-};
+}
char _ctype2[] {
/* x y z { | } ~ del */
_LPC, _LPC, _LPC, _CBR, 0, _CKT, 0, 0
-};
+}
char _ctype1[];
/* nb these args are not call by value !!!! */
-#define space(c) (((c)"E)==0 ANDF _ctype1[c]&(T_SPC))
-#define eofmeta(c) (((c)"E)==0 ANDF _ctype1[c]&(_META|T_EOF))
-#define qotchar(c) (((c)"E)==0 ANDF _ctype1[c]&(T_QOT))
-#define eolchar(c) (((c)"E)==0 ANDF _ctype1[c]&(T_EOR|T_EOF))
-#define dipchar(c) (((c)"E)==0 ANDF _ctype1[c]&(T_DIP))
-#define subchar(c) (((c)"E)==0 ANDF _ctype1[c]&(T_SUB|T_QOT))
-#define escchar(c) (((c)"E)==0 ANDF _ctype1[c]&(T_ESC))
+#define space(c) (((c)&0200)==0 && _ctype1[c]&(T_SPC))
+#define eofmeta(c) (((c)&0200)==0 && _ctype1[c]&(_META|T_EOF))
+#define qotchar(c) (((c)&0200)==0 && _ctype1[c]&(T_QOT))
+#define eolchar(c) (((c)&0200)==0 && _ctype1[c]&(T_EOR|T_EOF))
+#define dipchar(c) (((c)&0200)==0 && _ctype1[c]&(T_DIP))
+#define subchar(c) (((c)&0200)==0 && _ctype1[c]&(T_SUB|T_QOT))
+#define escchar(c) (((c)&0200)==0 && _ctype1[c]&(T_ESC))
char _ctype2[];
-#define digit(c) (((c)"E)==0 ANDF _ctype2[c]&(T_DIG))
-#define fngchar(c) (((c)"E)==0 ANDF _ctype2[c]&(T_FNG))
-#define dolchar(c) (((c)"E)==0 ANDF _ctype2[c]&(T_AST|T_BRC|T_DIG|T_IDC|T_SHN))
-#define defchar(c) (((c)"E)==0 ANDF _ctype2[c]&(T_DEF))
-#define setchar(c) (((c)"E)==0 ANDF _ctype2[c]&(T_SET))
-#define digchar(c) (((c)"E)==0 ANDF _ctype2[c]&(T_AST|T_DIG))
-#define letter(c) (((c)"E)==0 ANDF _ctype2[c]&(T_IDC))
-#define alphanum(c) (((c)"E)==0 ANDF _ctype2[c]&(_IDCH))
-#define astchar(c) (((c)"E)==0 ANDF _ctype2[c]&(T_AST))
+#define digit(c) (((c)&0200)==0 && _ctype2[c]&(T_DIG))
+#define fngchar(c) (((c)&0200)==0 && _ctype2[c]&(T_FNG))
+#define dolchar(c) (((c)&0200)==0 && _ctype2[c]&(T_AST|T_BRC|T_DIG|T_IDC|T_SHN))
+#define defchar(c) (((c)&0200)==0 && _ctype2[c]&(T_DEF))
+#define setchar(c) (((c)&0200)==0 && _ctype2[c]&(T_SET))
+#define digchar(c) (((c)&0200)==0 && _ctype2[c]&(T_AST|T_DIG))
+#define letter(c) (((c)&0200)==0 && _ctype2[c]&(T_IDC))
+#define alphanum(c) (((c)&0200)==0 && _ctype2[c]&(_IDCH))
+#define astchar(c) (((c)&0200)==0 && _ctype2[c]&(T_AST))
/* result type declarations */
#define alloc malloc
-ADDRESS alloc();
-VOID addblok();
-STRING make();
-STRING movstr();
-TREPTR cmd();
-TREPTR makefork();
-NAMPTR lookup();
-VOID setname();
-VOID setargs();
-DOLPTR useargs();
-REAL expr();
-STRING catpath();
-STRING getpath();
-STRING *scan();
-STRING mactrim();
-STRING macro();
-STRING execs();
-VOID await();
-VOID post();
-STRING copyto();
-VOID exname();
-STRING staknam();
-VOID printnam();
-VOID printflg();
-VOID prs();
-VOID prc();
-VOID setupenv();
-STRING *setenv();
+void *alloc();
+void addblok();
+char *make();
+char *movstr();
+struct trenod *cmd();
+struct trenod *makefork();
+struct namnod *lookup();
+void setname();
+void setargs();
+struct dolnod *useargs();
+float expr();
+char *catpath();
+char *getpath();
+char **scan();
+char *mactrim();
+char *macro();
+char *execs();
+void await();
+void post();
+char *copyto();
+void exname();
+char *staknam();
+void printnam();
+void printflg();
+void prs();
+void prc();
+void setupenv();
+char **setenv();
#define attrib(n,f) (n->namflg |= f)
-#define round(a,b) (((int)((ADR(a)+b)-1))&~((b)-1))
+#define round(a,b) (((int)(((void *)(a)+b)-1))&~((b)-1))
#define closepipe(x) (close(x[INPIPE]), close(x[OTPIPE]))
#define eq(a,b) (cf(a,b)==0)
#define max(a,b) ((a)>(b)?(a):(b))
#define assert(x) ;
/* temp files and io */
-UFD output;
-INT ioset;
-IOPTR iotemp; /* files to be deleted sometime */
-IOPTR iopend; /* documents waiting to be read at NL */
+int output;
+int ioset;
+struct ionod *iotemp; /* files to be deleted sometime */
+struct ionod *iopend; /* documents waiting to be read at '\n' */
/* substitution */
-INT dolc;
-STRING *dolv;
-DOLPTR argfor;
-ARGPTR gchain;
+int dolc;
+char **dolv;
+struct dolnod *argfor;
+struct argnod *gchain;
/* stak stuff */
#include "stak.h"
/* string constants */
-MSG atline;
-MSG readmsg;
-MSG colon;
-MSG minus;
-MSG nullstr;
-MSG sptbnl;
-MSG unexpected;
-MSG endoffile;
-MSG synmsg;
+char atline[];
+char readmsg[];
+char colon[];
+char minus[];
+char nullstr[];
+char sptbnl[];
+char unexpected[];
+char endoffile[];
+char synmsg[];
/* name tree and words */
-SYSTAB reserved;
-INT wdval;
-INT wdnum;
-ARGPTR wdarg;
-INT wdset;
-BOOL reserv;
+struct sysnod reserved[];
+int wdval;
+int wdnum;
+struct argnod *wdarg;
+int wdset;
+bool reserv;
/* prompting */
-MSG stdprompt;
-MSG supprompt;
-MSG profile;
+char stdprompt[];
+char supprompt[];
+char profile[];
/* built in names */
-NAMNOD fngnod;
-NAMNOD ifsnod;
-NAMNOD homenod;
-NAMNOD mailnod;
-NAMNOD pathnod;
-NAMNOD ps1nod;
-NAMNOD ps2nod;
+struct namnod fngnod;
+struct namnod ifsnod;
+struct namnod homenod;
+struct namnod mailnod;
+struct namnod pathnod;
+struct namnod ps1nod;
+struct namnod ps2nod;
/* special names */
-MSG flagadr;
-STRING cmdadr;
-STRING exitadr;
-STRING dolladr;
-STRING pcsadr;
-STRING pidadr;
+char flagadr[];
+char *cmdadr;
+char *exitadr;
+char *dolladr;
+char *pcsadr;
+char *pidadr;
-MSG defpath;
+char defpath[];
/* names always present */
-MSG mailname;
-MSG homename;
-MSG pathname;
-MSG fngname;
-MSG ifsname;
-MSG ps1name;
-MSG ps2name;
+char mailname[];
+char homename[];
+char pathname[];
+char fngname[];
+char ifsname[];
+char ps1name[];
+char ps2name[];
/* transput */
-CHAR tmpout[];
-STRING tmpnam;
-INT serial;
+char tmpout[];
+char *tmpnam;
+int serial;
#define TMPNAM 7
-FILE standin;
+struct fileblk *standin;
#define input (standin->fdes)
#define eof (standin->feof)
-INT peekc;
-STRING comdiv;
-MSG devnull;
+int peekc;
+char *comdiv;
+char devnull[];
/* flags */
#define noexec 01
#define readpr 010000
#define keyflg 020000
#define batchflg 040000
-INT flags;
+int flags;
/* error exits from various parts of shell */
#include <setjmp.h>
/* fault handling */
#include "brkincr.h"
-POS brkincr;
+unsigned brkincr;
#define MINTRAP 0
#define MAXTRAP 32
#define SIGSET 4
#define SIGMOD 8
-VOID fault();
-BOOL trapnote;
-STRING trapcom[];
-BOOL trapflg[];
-BOOL trapjmp[];
+void fault();
+bool trapnote;
+char *trapcom[];
+bool trapflg[];
+bool trapjmp[];
/* name tree and words */
-STRING *environ;
-CHAR numbuf[];
-MSG export;
-MSG readonly;
+char **environ;
+char numbuf[];
+char export[];
+char readonly[];
/* execflgs */
-INT exitval;
-BOOL execbrk;
-INT loopcnt;
-INT breakcnt;
+int exitval;
+bool execbrk;
+int loopcnt;
+int breakcnt;
/* messages */
-MSG mailmsg;
-MSG coredump;
-MSG badopt;
-MSG badparam;
-MSG badsub;
-MSG nospace;
-MSG notfound;
-MSG badtrap;
-MSG baddir;
-MSG badshift;
-MSG illegal;
-MSG restricted;
-MSG execpmsg;
-MSG notid;
-MSG wtfailed;
-MSG badcreate;
-MSG piperr;
-MSG badopen;
-MSG badnum;
-MSG arglist;
-MSG txtbsy;
-MSG toobig;
-MSG badexec;
-MSG notfound;
-MSG badfile;
+char mailmsg[];
+char coredump[];
+char badopt[];
+char badparam[];
+char badsub[];
+char nospace[];
+char notfound[];
+char badtrap[];
+char baddir[];
+char badshift[];
+char illegal[];
+char restricted[];
+char execpmsg[];
+char notid[];
+char wtfailed[];
+char badcreate[];
+char piperr[];
+char badopen[];
+char badnum[];
+char arglist[];
+char txtbsy[];
+char toobig[];
+char badexec[];
+char notfound[];
+char badfile[];
address end[];
* `trapnote' is set to SIGSET when fault is seen and
* no trap has been set.
*/
- IF trapnote&SIGSET
- THEN exitsh(SIGFAIL);
- FI
+ if (trapnote&SIGSET) {
+ exitsh(SIGFAIL);
+ }
}
failed(s1,s2)
- STRING s1, s2;
+ char*CHECKME s1, s2;
{
prp(); prs(s1);
- IF s2
- THEN prs(colon); prs(s2);
- FI
+ if (s2) {
+ prs(colon); prs(s2);
+ }
newline(); exitsh(ERROR);
}
error(s)
- STRING s;
+ char *s;
{
failed(s,NIL);
}
exitsh(xno)
- INT xno;
+ int xno;
{
/* Arrive here from `FATAL' errors
* a) exit command,
* Action is to return to command level or exit.
*/
exitval=xno;
- IF (flags & (forked|errflg|ttyflg)) != ttyflg
- THEN done();
- ELSE clearup();
+ if ((flags & (forked|errflg|ttyflg)) != ttyflg) {
+ done();
+ }
+ else {
+ clearup();
longjmp(errshell,1);
- FI
+ }
}
done()
{
- REG STRING t;
- IF t=trapcom[0]
- THEN trapcom[0]=0; /*should free but not long */
+ register char *t;
+ if (t=trapcom[0]) {
+ trapcom[0]=0; /*should free but not long */
execexp(t,0);
- FI
+ }
rmtemp(0);
exit(exitval);
}
rmtemp(base)
- IOPTR base;
+ struct ionod *base;
{
- WHILE iotemp>base
- DO unlink(iotemp->ioname);
+ while (iotemp>base) {
+ unlink(iotemp->ioname);
iotemp=iotemp->iolst;
- OD
+ }
}
*
*/
-PROC VOID addg();
+extern void addg();
-INT expand(as,rflg)
- STRING as;
+int expand(as,rflg)
+ char *as;
{
- INT count;
+ int count;
DIR *dirf;
- BOOL dir=0;
- STRING rescan = 0;
- REG STRING s, cs;
- ARGPTR schain = gchain;
+ bool dir=0;
+ char *rescan = 0;
+ register char*CHECKME s, cs;
+ struct argnod *schain = gchain;
struct direct *dp;
- STATBUF statb;
+ struct stat statb;
- IF trapnote&SIGSET THEN return(0); FI
+ if (trapnote&SIGSET) { return(0); }
s=cs=as;
/* check for meta chars */
- BEGIN
- REG BOOL slash; slash=0;
- WHILE !fngchar(*cs)
- DO IF *cs++==0
- THEN IF rflg ANDF slash THEN break; ELSE return(0) FI
- ELIF *cs=='/'
- THEN slash++;
- FI
- OD
- END
-
- LOOP IF cs==s
- THEN s=nullstr;
+ {
+
+ register bool slash; slash=0;
+ while (!fngchar(*cs)) {
+ if (*cs++==0) {
+ if (rflg && slash) { break; }NEWLINEelse { return(0); }
+ }
+ else if (*cs=='/') {
+ slash++;
+ }
+ }
+ }
+
+ for(;;) {
+ if (cs==s) {
+ s=nullstr;
break;
- ELIF *--cs == '/'
- THEN *cs=0;
- IF s==cs THEN s="/" FI
+ }
+ else if (*--cs == '/') {
+ *cs=0;
+ if (s==cs) { s="/"; }
break;
- FI
- POOL
- IF stat(s,&statb)>=0
- ANDF (statb.st_mode&S_IFMT)==S_IFDIR
- ANDF (dirf=opendir(s)) != NULL
- THEN dir++;
- FI
+ }
+ }
+ if (stat(s,&statb)>=0
+ && (statb.st_mode&S_IFMT)==S_IFDIR
+ && (dirf=opendir(s)) != NULL) {
+ dir++;
+ }
count=0;
- IF *cs==0 THEN *cs++=0200 FI
- IF dir
- THEN /* check for rescan */
- REG STRING rs; rs=cs;
-
- REP IF *rs=='/' THEN rescan=rs; *rs=0; gchain=0 FI
- PER *rs++ DONE
-
- IF setjmp(INTbuf) == 0 THEN trapjmp[INTR] = 1; FI
- WHILE (trapnote&SIGSET) == 0 ANDF (dp = readdir(dirf)) != NULL
- DO IF (*dp->d_name=='.' ANDF *cs!='.')
- THEN continue;
- FI
- IF gmatch(dp->d_name, cs)
- THEN addg(s,dp->d_name,rescan); count++;
- FI
- OD
+ if (*cs==0) { *cs++=0200; }
+ if (dir) {
+ /* check for rescan */
+ register char *rs; rs=cs;
+
+ do {
+ if (*rs=='/') { rescan=rs; *rs=0; gchain=0; }
+ } while (*rs++);
+
+ if (setjmp(INTbuf) == 0) { trapjmp[INTR] = 1; }
+ while ((trapnote&SIGSET) == 0 && (dp = readdir(dirf)) != NULL) {
+ if ((*dp->d_name=='.' && *cs!='.')) {
+ continue;
+ }
+ if (gmatch(dp->d_name, cs)) {
+ addg(s,dp->d_name,rescan); count++;
+ }
+ }
closedir(dirf); trapjmp[INTR] = 0;
- IF rescan
- THEN REG ARGPTR rchain;
+ if (rescan) {
+ register struct argnod *rchain;
rchain=gchain; gchain=schain;
- IF count
- THEN count=0;
- WHILE rchain
- DO count += expand(rchain->argval,1);
+ if (count) {
+ count=0;
+ while (rchain) {
+ count += expand(rchain->argval,1);
rchain=rchain->argnxt;
- OD
- FI
+ }
+ }
*rescan='/';
- FI
- FI
+ }
+ }
- BEGIN
- REG CHAR c;
+ {
+
+ register char c;
s=as;
- WHILE c = *s
- DO *s++=(c&STRIP?c:'/') OD
- END
+ while (c = *s) { *s++=(c&0177?c:'/'); }
+ }
return(count);
}
gmatch(s, p)
- REG STRING s, p;
+ register char*CHECKME s, p;
{
- REG INT scc;
- CHAR c;
+ register int scc;
+ char c;
- IF scc = *s++
- THEN IF (scc &= STRIP)==0
- THEN scc=0200;
- FI
- FI
- SWITCH c = *p++ IN
+ if (scc = *s++) {
+ if ((scc &= 0177)==0) {
+ scc=0200;
+ }
+ }
+ switch (c = *p++) {
+
case '[':
- {BOOL ok; INT lc;
+ {bool ok; int lc;
ok=0; lc=077777;
- WHILE c = *p++
- DO IF c==']'
- THEN return(ok?gmatch(s,p):0);
- ELIF c==MINUS
- THEN IF lc<=scc ANDF scc<=(*p++) THEN ok++ FI
- ELSE IF scc==(lc=(c&STRIP)) THEN ok++ FI
- FI
- OD
+ while (c = *p++) {
+ if (c==']') {
+ return(ok?gmatch(s,p):0);
+ }
+ else if (c=='-') {
+ if (lc<=scc && scc<=(*p++)) { ok++; }
+ }
+ else {
+ if (scc==(lc=(c&0177))) { ok++; }
+ }
+ }
return(0);
}
default:
- IF (c&STRIP)!=scc THEN return(0) FI
+ if ((c&0177)!=scc) { return(0); }
case '?':
return(scc?gmatch(s,p):0);
case '*':
- IF *p==0 THEN return(1) FI
+ if (*p==0) { return(1); }
--s;
- WHILE *s
- DO IF gmatch(s++,p) THEN return(1) FI OD
+ while (*s) {
+ if (gmatch(s++,p)) { return(1); }NEWLINE}
return(0);
case 0:
return(scc==0);
- ENDSW
+ }
}
-LOCAL VOID addg(as1,as2,as3)
- STRING as1, as2, as3;
+static void addg(as1,as2,as3)
+ char*CHECKME as1, as2, as3;
{
- REG STRING s1, s2;
- REG INT c;
+ register char*CHECKME s1, s2;
+ register int c;
s2 = locstak()+BYTESPERWORD;
s1=as1;
- WHILE c = *s1++
- DO IF (c &= STRIP)==0
- THEN *s2++='/';
+ while (c = *s1++) {
+ if ((c &= 0177)==0) {
+ *s2++='/';
break;
- FI
+ }
*s2++=c;
- OD
+ }
s1=as2;
- WHILE *s2 = *s1++ DO s2++ OD
- IF s1=as3
- THEN *s2++='/';
- WHILE *s2++ = *++s1 DONE
- FI
+ while (*s2 = *s1++) { s2++; }
+ if (s1=as3) {
+ *s2++='/';
+ while (*s2++ = *++s1);
+ }
makearg(endstak(s2));
}
makearg(args)
- REG STRING args;
+ register char *args;
{
args->argnxt=gchain;
gchain=args;
#include "defs.h"
-STRING trapcom[MAXTRAP];
-BOOL trapflg[MAXTRAP];
-BOOL trapjmp[MAXTRAP];
+char *trapcom[MAXTRAP];
+bool trapflg[MAXTRAP];
+bool trapjmp[MAXTRAP];
/* ======== fault handling routines ======== */
-VOID fault(sig)
- REG INT sig;
+void fault(sig)
+ register int sig;
{
- REG INT flag;
-
- IF sig==MEMF
- THEN IF setbrk(brkincr) == -1
- THEN error(nospace);
- FI
- ELIF sig==ALARM
- THEN IF flags&waiting
- THEN done();
- FI
- ELSE flag = (trapcom[sig] ? TRAPSET : SIGSET);
+ register int flag;
+
+ if (sig==MEMF) {
+ if (setbrk(brkincr) == -1) {
+ error(nospace);
+ }
+ }
+ else if (sig==ALARM) {
+ if (flags&waiting) {
+ done();
+ }
+ }
+ else {
+ flag = (trapcom[sig] ? TRAPSET : SIGSET);
trapnote |= flag;
trapflg[sig] |= flag;
- FI
- IF trapjmp[sig] ANDF sig==INTR
- THEN
+ }
+ if (trapjmp[sig] && sig==INTR) {
+
trapjmp[sig] = 0;
longjmp(INTbuf, 1);
- FI
+ }
}
stdsigs()
ignsig(n)
{
- REG INT s, i;
+ register int s, i;
- IF (s=signal(i=n,1)&01)==0
- THEN trapflg[i] |= SIGMOD;
- FI
+ if ((s=signal(i=n,1)&01)==0) {
+ trapflg[i] |= SIGMOD;
+ }
return(s);
}
getsig(n)
{
- REG INT i;
+ register int i;
- IF trapflg[i=n]&SIGMOD ORF ignsig(i)==0
- THEN signal(i,fault);
- FI
+ if (trapflg[i=n]&SIGMOD || ignsig(i)==0) {
+ signal(i,fault);
+ }
}
oldsigs()
{
- REG INT i;
- REG STRING t;
+ register int i;
+ register char *t;
i=MAXTRAP;
- WHILE i--
- DO t=trapcom[i];
- IF t==0 ORF *t
- THEN clrsig(i);
- FI
+ while (i--) {
+ t=trapcom[i];
+ if (t==0 || *t) {
+ clrsig(i);
+ }
trapflg[i]=0;
- OD
+ }
trapnote=0;
}
clrsig(i)
- INT i;
+ int i;
{
free(trapcom[i]); trapcom[i]=0;
- IF trapflg[i]&SIGMOD
- THEN signal(i,fault);
+ if (trapflg[i]&SIGMOD) {
+ signal(i,fault);
trapflg[i] &= ~SIGMOD;
- FI
+ }
}
chktrap()
{
/* check for traps */
- REG INT i=MAXTRAP;
- REG STRING t;
+ register int i=MAXTRAP;
+ register char *t;
trapnote &= ~TRAPSET;
- WHILE --i
- DO IF trapflg[i]&TRAPSET
- THEN trapflg[i] &= ~TRAPSET;
- IF t=trapcom[i]
- THEN INT savxit=exitval;
+ while (--i) {
+ if (trapflg[i]&TRAPSET) {
+ trapflg[i] &= ~TRAPSET;
+ if (t=trapcom[i]) {
+ int savxit=exitval;
execexp(t,0);
exitval=savxit; exitset();
- FI
- FI
- OD
+ }
+ }
+ }
}
/* ======== input output and file copying ======== */
initf(fd)
- UFD fd;
+ int fd;
{
- REG FILE f=standin;
+ register struct fileblk *f=standin;
f->fdes=fd; f->fsiz=((flags&(oneflg|ttyflg))==0 ? BUFSIZ : 1);
f->fnxt=f->fend=f->fbuf; f->feval=0; f->flin=1;
- f->feof=FALSE;
+ f->feof=0;
}
estabf(s)
- REG STRING s;
+ register char *s;
{
- REG FILE f;
+ register struct fileblk *f;
(f=standin)->fdes = -1;
f->fend=length(s)+(f->fnxt=s);
}
push(af)
- FILE af;
+ struct fileblk *af;
{
- REG FILE f;
+ register struct fileblk *f;
(f=af)->fstak=standin;
f->feof=0; f->feval=0;
pop()
{
- REG FILE f;
+ register struct fileblk *f;
- IF (f=standin)->fstak
- THEN IF f->fdes>=0 THEN close(f->fdes) FI
+ if ((f=standin)->fstak) {
+ if (f->fdes>=0) { close(f->fdes); }
standin=f->fstak;
- return(TRUE);
- ELSE return(FALSE);
- FI
+ return(-1);
+ }
+ else {
+ return(0);
+ }
}
chkpipe(pv)
- INT *pv;
+ int *pv;
{
- IF pipe(pv)<0 ORF pv[INPIPE]<0 ORF pv[OTPIPE]<0
- THEN error(piperr);
- FI
+ if (pipe(pv)<0 || pv[INPIPE]<0 || pv[OTPIPE]<0) {
+ error(piperr);
+ }
}
chkopen(idf)
- STRING idf;
+ char *idf;
{
- REG INT rc;
-
- IF (rc=open(idf,0))<0
- THEN failed(idf,badopen);
- ELSE return(rc);
- FI
+ register int rc;
+
+ if ((rc=open(idf,0))<0) {
+ failed(idf,badopen);
+ }
+ else {
+ return(rc);
+ }
}
rename(f1,f2)
- REG INT f1, f2;
+ register int f1, f2;
{
- IF f1!=f2
- THEN dup2(f1, f2);
+ if (f1!=f2) {
+ dup2(f1, f2);
close(f1);
- IF f2==0 THEN ioset|=1 FI
- FI
+ if (f2==0) { ioset|=1; }
+ }
}
create(s)
- STRING s;
+ char *s;
{
- REG INT rc;
-
- IF (rc=creat(s,0666))<0
- THEN failed(s,badcreate);
- ELSE return(rc);
- FI
+ register int rc;
+
+ if ((rc=creat(s,0666))<0) {
+ failed(s,badcreate);
+ }
+ else {
+ return(rc);
+ }
}
tmpfil()
}
/* set by trim */
-BOOL nosubst;
+bool nosubst;
copy(ioparg)
- IOPTR ioparg;
+ struct ionod *ioparg;
{
- CHAR c, *ends;
- REG CHAR *cline, *clinep;
- INT fd;
- REG IOPTR iop;
-
- IF iop=ioparg
- THEN copy(iop->iolst);
- ends=mactrim(iop->ioname); IF nosubst THEN iop->iofile &= ~IODOC FI
+ char c, *ends;
+ register char *cline, *clinep;
+ int fd;
+ register struct ionod *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();
- LOOP clinep=cline; chkpr(NL);
- WHILE (c = (nosubst ? readc() : nextc(*ends)), !eolchar(c)) DO *clinep++ = c OD
+ for(;;) {
+ clinep=cline; chkpr('\n');
+ while ((c = (nosubst ? readc() : nextc(*ends)), !eolchar(c))) { *clinep++ = c; }
*clinep=0;
- IF eof ORF eq(cline,ends) THEN break FI
- *clinep++=NL;
+ if (eof || eq(cline,ends)) { break; }
+ *clinep++='\n';
write(fd,cline,clinep-cline);
- POOL
+ }
close(fd);
- FI
+ }
}
#include "defs.h"
#include "sym.h"
-LOCAL CHAR quote; /* used locally */
-LOCAL CHAR quoted; /* used locally */
+static char quote; /* used locally */
+static char quoted; /* used locally */
-LOCAL STRING copyto(endch)
- REG CHAR endch;
+static char *copyto(endch)
+ register char endch;
{
- REG CHAR c;
+ register char c;
- WHILE (c=getch(endch))!=endch ANDF c
- DO pushstak(c|quote) OD
+ while ((c=getch(endch))!=endch && c) { pushstak(c|quote); }
zerostak();
- IF c!=endch THEN error(badsub) FI
+ if (c!=endch) { error(badsub); }
}
-LOCAL skipto(endch)
- REG CHAR endch;
+static skipto(endch)
+ register char endch;
{
/* skip chars up to } */
- REG CHAR c;
- WHILE (c=readc()) ANDF c!=endch
- DO SWITCH c IN
+ register char c;
+ while ((c=readc()) && c!=endch) {
+ switch (c) {
+
case SQUOTE: skipto(SQUOTE); break;
case DQUOTE: skipto(DQUOTE); break;
- case DOLLAR: IF readc()==BRACE
- THEN skipto('}');
- FI
- ENDSW
- OD
- IF c!=endch THEN error(badsub) FI
+ case DOLLAR: if (readc()==BRACE) { skipto('}');
+ }
+ }
+ }
+ if (c!=endch) { error(badsub); }
}
-LOCAL getch(endch)
- CHAR endch;
+static getch(endch)
+ char endch;
{
- REG CHAR d;
+ register char d;
retry:
d=readc();
- IF !subchar(d)
- THEN return(d);
- FI
- IF d==DOLLAR
- THEN REG INT c;
- IF (c=readc(), dolchar(c))
- THEN NAMPTR n=NIL;
- INT dolg=0;
- BOOL bra;
- REG STRING argp, v;
- CHAR idb[2];
- STRING id=idb;
-
- IF bra=(c==BRACE) THEN c=readc() FI
- IF letter(c)
- THEN argp=relstak();
- WHILE alphanum(c) DO pushstak(c); c=readc() OD
+ if (!subchar(d)) {
+ return(d);
+ }
+ if (d==DOLLAR) {
+ register int c;
+ if ((c=readc(), dolchar(c))) {
+ struct namnod *n=NIL;
+ int dolg=0;
+ bool bra;
+ register char*CHECKME argp, v;
+ char idb[2];
+ char *id=idb;
+
+ if (bra=(c==BRACE)) { c=readc(); }
+ if (letter(c)) {
+ argp=relstak();
+ while (alphanum(c)) { pushstak(c); c=readc(); }
zerostak();
n=lookup(absstak(argp)); setstak(argp);
v = n->namval; id = n->namid;
- peekc = c|MARK;;
- ELIF digchar(c)
- THEN *id=c; idb[1]=0;
- IF astchar(c)
- THEN dolg=1; c='1';
- FI
+ peekc = c|MARK;
+ }
+ else if (digchar(c)) {
+ *id=c; idb[1]=0;
+ if (astchar(c)) {
+ dolg=1; c='1';
+ }
c -= '0';
v=((c==0) ? cmdadr : (c<=dolc) ? dolv[c] : (dolg=0));
- ELIF c=='$'
- THEN v=pidadr;
- ELIF c=='!'
- THEN v=pcsadr;
- ELIF c=='#'
- THEN v=dolladr;
- ELIF c=='?'
- THEN v=exitadr;
- ELIF c=='-'
- THEN v=flagadr;
- ELIF bra THEN error(badsub);
- ELSE goto retry;
- FI
+ }
+ else if (c=='$') {
+ v=pidadr;
+ }
+ else if (c=='!') {
+ v=pcsadr;
+ }
+ else if (c=='#') {
+ v=dolladr;
+ }
+ else if (c=='?') {
+ v=exitadr;
+ }
+ else if (c=='-') {
+ v=flagadr;
+ }
+ else if (bra) {
+ error(badsub);
+ }
+ else {
+ goto retry;
+ }
c = readc();
- IF !defchar(c) ANDF bra
- THEN error(badsub);
- FI
+ if (!defchar(c) && bra) {
+ error(badsub);
+ }
argp=0;
- IF bra
- THEN IF c!='}'
- THEN argp=relstak();
- IF (v==0)NEQ(setchar(c))
- THEN copyto('}');
- ELSE skipto('}');
- FI
+ if (bra) { if (c!='}') {
+ argp=relstak();
+ if ((v==0)^(setchar(c))) { copyto('}');
+ }
+ else { skipto('}');
+ }
argp=absstak(argp);
- FI
- ELSE peekc = c|MARK; c = 0;
- FI
- IF v
- THEN IF c!='+'
- THEN LOOP WHILE c = *v++
- DO pushstak(c|quote); OD
- IF dolg==0 ORF (++dolg>dolc)
- THEN break;
- ELSE v=dolv[dolg]; pushstak(SP|(*id=='*' ? quote : 0));
- FI
- POOL
- FI
- ELIF argp
- THEN IF c=='?'
- THEN failed(id,*argp?argp:badparam);
- ELIF c=='='
- THEN IF n
- THEN assign(n,argp);
- ELSE error(badsub);
- FI
- FI
- ELIF flags&setflg
- THEN failed(id,badparam);
- FI
+ }
+ }
+ else {
+ peekc = c|MARK; c = 0;
+ }
+ if (v) {
+ if (c!='+') {
+ for(;;) {
+ while (c = *v++) { pushstak(c|quote); }
+ if (dolg==0 || (++dolg>dolc)) {
+ break;
+ }
+ else {
+ v=dolv[dolg]; pushstak(' '|(*id=='*' ? quote : 0));
+ }
+ }
+ }
+ }
+ else if (argp) {
+ if (c=='?') {
+ failed(id,*argp?argp:badparam);
+ }
+ else if (c=='=') {
+ if (n) {
+ assign(n,argp);
+ }
+ else {
+ error(badsub);
+ }
+ }
+ }
+ else if (flags&setflg) {
+ failed(id,badparam);
+ }
goto retry;
- ELSE peekc=c|MARK;
- FI
- ELIF d==endch
- THEN return(d);
- ELIF d==SQUOTE
- THEN comsubst(); goto retry;
- ELIF d==DQUOTE
- THEN quoted++; quote^=QUOTE; goto retry;
- FI
+ }
+ else {
+ peekc=c|MARK;
+ }
+ }
+ else if (d==endch) {
+ return(d);
+ }
+ else if (d==SQUOTE) {
+ comsubst(); goto retry;
+ }
+ else if (d==DQUOTE) {
+ quoted++; quote^=0200; goto retry;
+ }
return(d);
}
-STRING macro(as)
- STRING as;
+char *macro(as)
+ char *as;
{
/* Strip "" and do $ substitution
* Leaves result on top of stack
*/
- REG BOOL savqu =quoted;
- REG CHAR savq = quote;
- FILEHDR fb;
+ register bool savqu =quoted;
+ register char savq = quote;
+ struct filehdr fb;
push(&fb); estabf(as);
usestak();
quote=0; quoted=0;
copyto(0);
pop();
- IF quoted ANDF (stakbot==staktop) THEN pushstak(QUOTE) FI
+ if (quoted && (stakbot==staktop)) { pushstak(0200); }
quote=savq; quoted=savqu;
return(fixstak());
}
-LOCAL comsubst()
+static comsubst()
{
/* command substn */
- FILEBLK cb;
- REG CHAR d;
- REG STKPTR savptr = fixstak();
+ struct fileblk cb;
+ register char d;
+ register char *savptr = fixstak();
usestak();
- WHILE (d=readc())!=SQUOTE ANDF d
- DO pushstak(d) OD
+ while ((d=readc())!=SQUOTE && d) { pushstak(d); }
- BEGIN
- REG STRING argc;
+ {
+
+ register char *argc;
trim(argc=fixstak());
push(&cb); estabf(argc);
- END
- BEGIN
- REG TREPTR t = makefork(FPOU,cmd(EOFSYM,MTFLG|NLFLG));
- INT pv[2];
+ }
+ {
+
+ register struct trenod*CHECKME t = makefork(FPOU,cmd(EOFSYM,MTFLG|NLFLG));
+ int pv[2];
/* this is done like this so that the pipe
* is open only when needed
initf(pv[INPIPE]);
execute(t, 0, 0, pv);
close(pv[OTPIPE]);
- END
+ }
tdystak(savptr); staktop=movstr(savptr,stakbot);
- WHILE d=readc() DO locstak(); pushstak(d|quote) OD
+ while (d=readc()) { locstak(); pushstak(d|quote); }
await(0);
- WHILE stakbot!=staktop
- DO IF (*--staktop&STRIP)!=NL
- THEN ++staktop; break;
- FI
- OD
+ while (stakbot!=staktop) {
+ if ((*--staktop&0177)!='\n') {
+ ++staktop; break;
+ }
+ }
pop();
}
#define CPYSIZ 512
subst(in,ot)
- INT in, ot;
+ int in, ot;
{
- REG CHAR c;
- FILEBLK fb;
- REG INT count=CPYSIZ;
+ register char c;
+ struct fileblk fb;
+ register int count=CPYSIZ;
push(&fb); initf(in);
/* DQUOTE used to stop it from quoting */
- WHILE c=(getch(DQUOTE)&STRIP)
- DO pushstak(c);
- IF --count == 0
- THEN flush(ot); count=CPYSIZ;
- FI
- OD
+ while (c=(getch(DQUOTE)&0177)) {
+ pushstak(c);
+ if (--count == 0) {
+ flush(ot); count=CPYSIZ;
+ }
+ }
flush(ot);
pop();
}
-LOCAL flush(ot)
+static flush(ot)
{
write(ot,stakbot,staktop-stakbot);
- IF flags&execpr THEN write(output,stakbot,staktop-stakbot) FI
+ if (flags&execpr) { write(output,stakbot,staktop-stakbot); }
staktop=stakbot;
}
#include <sgtty.h>
#include <signal.h>
-UFD output = 2;
-LOCAL BOOL beenhere = FALSE;
-CHAR tmpout[20] = "/tmp/sh-";
-FILEBLK stdfile;
-FILE standin = &stdfile;
+int output = 2;
+static bool beenhere = 0;
+char tmpout[20] = "/tmp/sh-";
+struct fileblk stdfile;
+struct fileblk *standin = &stdfile;
#ifdef stupid
#include <execargs.h>
#endif
-PROC VOID exfile();
+extern void exfile();
main(c, v)
- INT c;
- STRING v[];
+ int c;
+ char *v[];
{
- REG INT rflag=ttyflg;
+ register int rflag=ttyflg;
/* initialise storage allocation */
stdsigs();
setbrk(BRKINCR);
- addblok((POS)0);
+ addblok((unsigned)0);
/* set names from userenv */
setupenv();
/* look for restricted */
-/* IF c>0 ANDF any('r', *v) THEN rflag=0 FI */
+/* if (c>0 && any('r', *v)) { rflag=0; } */
/* look for options */
dolc=options(c,v);
- IF dolc<2 THEN flags |= stdflg FI
- IF (flags&stdflg)==0
- THEN dolc--;
- FI
+ if (dolc<2) { flags |= stdflg; }
+ if ((flags&stdflg)==0) {
+ dolc--;
+ }
dolv=v+c-dolc; dolc--;
/* return here for shell file execution */
/* default ifs */
dfault(&ifsnod, sptbnl);
- IF (beenhere++)==FALSE
- THEN /* ? profile */
- IF *cmdadr=='-'
- ANDF (input=pathopen(nullstr, profile))>=0
- THEN exfile(rflag); flags &= ~ttyflg;
- FI
- IF rflag==0 THEN flags |= rshflg FI
+ if ((beenhere++)==0) {
+ /* ? profile */
+ if (*cmdadr=='-'
+ && (input=pathopen(nullstr, profile))>=0) {
+ exfile(rflag); flags &= ~ttyflg;
+ }
+ if (rflag==0) { flags |= rshflg; }
/* open input file if specified */
- IF comdiv
- THEN estabf(comdiv); input = -1;
- ELSE input=((flags&stdflg) ? 0 : chkopen(cmdadr));
+ if (comdiv) {
+ estabf(comdiv); input = -1;
+ }
+ else {
+ input=((flags&stdflg) ? 0 : chkopen(cmdadr));
comdiv--;
- FI
+ }
#ifdef stupid
- ELSE *execargs=dolv; /* for `ps' cmd */
-#endif
- FI
+ }
+ else {
+ *execargs=dolv; /* for `ps' cmd */
+#endif;
+ }
exfile(0);
done();
}
-LOCAL VOID exfile(prof)
-BOOL prof;
+static void exfile(prof)
+bool prof;
{
- REG L_INT mailtime = 0;
- REG INT userid;
+ register long mailtime = 0;
+ register int userid;
struct stat statb;
/* move input */
- IF input>0
- THEN Ldup(input,INIO);
+ if (input>0) {
+ Ldup(input,INIO);
input=INIO;
- FI
+ }
/* move output to safe place */
- IF output==2
- THEN Ldup(dup(2),OTIO);
+ if (output==2) {
+ Ldup(dup(2),OTIO);
output=OTIO;
- FI
+ }
userid=getuid();
/* decide whether interactive */
- IF (flags&intflg) ORF ((flags&oneflg)==0 ANDF gtty(output,&statb)==0 ANDF gtty(input,&statb)==0)
- THEN dfault(&ps1nod, (userid?stdprompt:supprompt));
+ if ((flags&intflg) || ((flags&oneflg)==0 && gtty(output,&statb)==0 && gtty(input,&statb)==0)) {
+ dfault(&ps1nod, (userid?stdprompt:supprompt));
dfault(&ps2nod, readmsg);
flags |= ttyflg|prompt; ignsig(KILL);
/*
signal(SIGTSTP, SIG_IGN);
}
*/
- ELSE flags |= prof; flags &= ~prompt;
- FI
+ }
+ else {
+ flags |= prof; flags &= ~prompt;
+ }
- IF setjmp(errshell) ANDF prof
- THEN close(input); return;
- FI
+ if (setjmp(errshell) && prof) {
+ close(input); return;
+ }
/* error return here */
loopcnt=breakcnt=peekc=0; iopend=0;
- IF input>=0 THEN initf(input) FI
+ if (input>=0) { initf(input); }
/* command loop */
- LOOP tdystak(0);
+ for(;;) {
+ tdystak(0);
stakchk(); /* may reduce sbrk */
exitset();
- IF (flags&prompt) ANDF standin->fstak==0 ANDF !eof
- THEN IF mailnod.namval
- ANDF stat(mailnod.namval,&statb)>=0 ANDF statb.st_size
- ANDF (statb.st_mtime != mailtime)
- ANDF mailtime
- THEN prs(mailmsg)
- FI
+ if ((flags&prompt) && standin->fstak==0 && !eof) {
+ if (mailnod.namval
+ && stat(mailnod.namval,&statb)>=0 && statb.st_size
+ && (statb.st_mtime != mailtime)
+ && mailtime) {
+ prs(mailmsg);
+ }
mailtime=statb.st_mtime;
prs(ps1nod.namval);
- FI
+ }
trapnote=0; peekc=readc();
- IF eof
- THEN return;
- FI
- execute(cmd(NL,MTFLG),0);
+ if (eof) {
+ return;
+ }
+ execute(cmd('\n',MTFLG),0);
eof |= (flags&oneflg);
- POOL
+ }
}
chkpr(eor)
char eor;
{
- IF (flags&prompt) ANDF standin->fstak==0 ANDF eor==NL
- THEN prs(ps2nod.namval);
- FI
+ if ((flags&prompt) && standin->fstak==0 && eor=='\n') {
+ prs(ps2nod.namval);
+ }
}
settmp()
}
Ldup(fa, fb)
- REG INT fa, fb;
+ register int fa, fb;
{
dup2(fa, fb);
close(fa);
* into an Rvalue so two cheats
* are necessary, one for each context.
*/
-union { int _cheat;};
+union { int _cheat;}
#define Lcheat(a) ((a)._cheat)
#define Rcheat(a) ((int)(a))
/* address puns for storage allocation */
-UNION {
- FORKPTR _forkptr;
- COMPTR _comptr;
- PARPTR _parptr;
- IFPTR _ifptr;
- WHPTR _whptr;
- FORPTR _forptr;
- LSTPTR _lstptr;
- BLKPTR _blkptr;
- NAMPTR _namptr;
- BYTPTR _bytptr;
+typedef union {
+ struct forknod *_forkptr;
+ struct comnod *_comptr;
+ struct parnod *_parptr;
+ struct ifnod *_ifptr;
+ struct whnod *_whptr;
+ struct fornod *_forptr;
+ struct lstnod *_lstptr;
+ struct blk *_blkptr;
+ struct namnod *_namptr;
+ char *_bytptr;
} address;
/* for functions that do not return values */
/*
-struct void {INT vvvvvvvv;};
+struct void {int vvvvvvvv;}
*/
/* heap storage */
struct blk {
- BLKPTR word;
-};
+ struct blk *word;
+}
#define BUFSIZ 64
struct fileblk {
- UFD fdes;
- POS flin;
- BOOL feof;
- CHAR fsiz;
- STRING fnxt;
- STRING fend;
- STRING *feval;
- FILE fstak;
- CHAR fbuf[BUFSIZ];
-};
+ int fdes;
+ unsigned flin;
+ bool feof;
+ char fsiz;
+ char *fnxt;
+ char *fend;
+ char **feval;
+ struct fileblk *fstak;
+ char fbuf[BUFSIZ];
+}
/* for files not used with file descriptors */
struct filehdr {
- UFD fdes;
- POS flin;
- BOOL feof;
- CHAR fsiz;
- STRING fnxt;
- STRING fend;
- STRING *feval;
- FILE fstak;
- CHAR _fbuf[1];
-};
+ int fdes;
+ unsigned flin;
+ bool feof;
+ char fsiz;
+ char *fnxt;
+ char *fend;
+ char **feval;
+ struct fileblk *fstak;
+ char _fbuf[1];
+}
struct sysnod {
- STRING sysnam;
- INT sysval;
-};
+ char *sysnam;
+ int sysval;
+}
/* this node is a proforma for those that follow */
struct trenod {
- INT tretyp;
- IOPTR treio;
-};
+ int tretyp;
+ struct ionod *treio;
+}
/* dummy for access only */
struct argnod {
- ARGPTR argnxt;
- CHAR argval[1];
-};
+ struct argnod *argnxt;
+ char argval[1];
+}
struct dolnod {
- DOLPTR dolnxt;
- INT doluse;
- CHAR dolarg[1];
-};
+ struct dolnod *dolnxt;
+ int doluse;
+ char dolarg[1];
+}
struct forknod {
- INT forktyp;
- IOPTR forkio;
- TREPTR forktre;
-};
+ int forktyp;
+ struct ionod *forkio;
+ struct trenod *forktre;
+}
struct comnod {
- INT comtyp;
- IOPTR comio;
- ARGPTR comarg;
- ARGPTR comset;
-};
+ int comtyp;
+ struct ionod *comio;
+ struct argnod *comarg;
+ struct argnod *comset;
+}
struct ifnod {
- INT iftyp;
- TREPTR iftre;
- TREPTR thtre;
- TREPTR eltre;
-};
+ int iftyp;
+ struct trenod *iftre;
+ struct trenod *thtre;
+ struct trenod *eltre;
+}
struct whnod {
- INT whtyp;
- TREPTR whtre;
- TREPTR dotre;
-};
+ int whtyp;
+ struct trenod *whtre;
+ struct trenod *dotre;
+}
struct fornod {
- INT fortyp;
- TREPTR fortre;
- STRING fornam;
- COMPTR forlst;
-};
+ int fortyp;
+ struct trenod *fortre;
+ char *fornam;
+ struct comnod *forlst;
+}
struct swnod {
- INT swtyp;
- STRING swarg;
- REGPTR swlst;
-};
+ int swtyp;
+ char *swarg;
+ struct regnod *swlst;
+}
struct regnod {
- ARGPTR regptr;
- TREPTR regcom;
- REGPTR regnxt;
-};
+ struct argnod *regptr;
+ struct trenod *regcom;
+ struct regnod *regnxt;
+}
struct parnod {
- INT partyp;
- TREPTR partre;
-};
+ int partyp;
+ struct trenod *partre;
+}
struct lstnod {
- INT lsttyp;
- TREPTR lstlef;
- TREPTR lstrit;
-};
+ int lsttyp;
+ struct trenod *lstlef;
+ struct trenod *lstrit;
+}
struct ionod {
- INT iofile;
- STRING ioname;
- IOPTR ionxt;
- IOPTR iolst;
-};
+ int iofile;
+ char *ioname;
+ struct ionod *ionxt;
+ struct ionod *iolst;
+}
#include "defs.h"
#include "sym.h"
-MSG version = "\nVERSION sys137 DATE 1978 Nov 6 14:29:22\n";
+char version[] = "\nVERSION sys137 DATE 1978 Nov 6 14:29:22\n";
/* error messages */
-MSG badopt = "bad option(s)";
-MSG mailmsg = "you have mail\n";
-MSG nospace = "no space";
-MSG synmsg = "syntax error";
+char badopt[] = "bad option(s)";
+char mailmsg[] = "you have mail\n";
+char nospace[] = "no space";
+char synmsg[] = "syntax error";
-MSG badnum = "bad number";
-MSG badparam = "parameter not set";
-MSG badsub = "bad substitution";
-MSG badcreate = "cannot create";
-MSG illegal = "illegal io";
-MSG restricted = "restricted";
-MSG piperr = "cannot make pipe";
-MSG badopen = "cannot open";
-MSG coredump = " - core dumped";
-MSG arglist = "arg list too long";
-MSG txtbsy = "text busy";
-MSG toobig = "too big";
-MSG badexec = "cannot execute";
-MSG notfound = "not found";
-MSG badfile = "bad file number";
-MSG badshift = "cannot shift";
-MSG baddir = "bad directory";
-MSG badtrap = "bad trap";
-MSG wtfailed = "is read only";
-MSG notid = "is not an identifier";
+char badnum[] = "bad number";
+char badparam[] = "parameter not set";
+char badsub[] = "bad substitution";
+char badcreate[] = "cannot create";
+char illegal[] = "illegal io";
+char restricted[] = "restricted";
+char piperr[] = "cannot make pipe";
+char badopen[] = "cannot open";
+char coredump[] = " - core dumped";
+char arglist[] = "arg list too long";
+char txtbsy[] = "text busy";
+char toobig[] = "too big";
+char badexec[] = "cannot execute";
+char notfound[] = "not found";
+char badfile[] = "bad file number";
+char badshift[] = "cannot shift";
+char baddir[] = "bad directory";
+char badtrap[] = "bad trap";
+char wtfailed[] = "is read only";
+char notid[] = "is not an identifier";
/* built in names */
-MSG pathname = "PATH";
-MSG homename = "HOME";
-MSG mailname = "MAIL";
-MSG fngname = "FILEMATCH";
-MSG ifsname = "IFS";
-MSG ps1name = "PS1";
-MSG ps2name = "PS2";
+char pathname[] = "PATH";
+char homename[] = "HOME";
+char mailname[] = "MAIL";
+char fngname[] = "FILEMATCH";
+char ifsname[] = "IFS";
+char ps1name[] = "PS1";
+char ps2name[] = "PS2";
/* string constants */
-MSG nullstr = "";
-MSG sptbnl = " \t\n";
-MSG defpath = ":/bin:/usr/bin";
-MSG colon = ": ";
-MSG minus = "-";
-MSG endoffile = "end of file";
-MSG unexpected = " unexpected";
-MSG atline = " at line ";
-MSG devnull = "/dev/null";
-MSG execpmsg = "+ ";
-MSG readmsg = "> ";
-MSG stdprompt = "$ ";
-MSG supprompt = "# ";
-MSG profile = ".profile";
+char nullstr[] = "";
+char sptbnl[] = " \t\n";
+char defpath[] = ":/bin:/usr/bin";
+char colon[] = ": ";
+char minus[] = "-";
+char endoffile[] = "end of file";
+char unexpected[] = " unexpected";
+char atline[] = " at line ";
+char devnull[] = "/dev/null";
+char execpmsg[] = "+ ";
+char readmsg[] = "> ";
+char stdprompt[] = "$ ";
+char supprompt[] = "# ";
+char profile[] = ".profile";
/* tables */
-SYSTAB reserved {
+struct sysnod reserved[] {
{"in", INSYM},
{"esac", ESSYM},
{"case", CASYM},
{ "{", BRSYM},
{ "}", KTSYM},
{0, 0},
-};
+}
-STRING sysmsg[] {
+char *sysmsg[] {
0,
"Hangup",
0, /* Interrupt */
"User defined signal 1",
"User defined signal 2",
"Signal 32",
-};
-INT num_sysmsg = (sizeof sysmsg / sizeof sysmsg[0]);
+}
+int num_sysmsg = (sizeof sysmsg / sizeof sysmsg[0]);
-MSG export = "export";
-MSG readonly = "readonly";
-SYSTAB commands {
+char export[] = "export";
+char readonly[] = "readonly";
+struct sysnod commands[] {
{"cd", SYSCD},
{"read", SYSREAD},
/*
{"times", SYSTIMES},
{"umask", SYSUMASK},
{0, 0},
-};
+}
#include "defs.h"
-PROC BOOL chkid();
+extern bool chkid();
-NAMNOD ps2nod = { NIL, NIL, ps2name},
+struct namnod ps2nod = { NIL, NIL, ps2name},
fngnod = { NIL, NIL, fngname},
pathnod = { NIL, NIL, pathname},
ifsnod = { NIL, NIL, ifsname},
ps1nod = { &pathnod, &ps2nod, ps1name},
homenod = { &fngnod, &ifsnod, homename},
- mailnod = { &homenod, &ps1nod, mailname};
+ mailnod = { &homenod, &ps1nod, mailname}
-NAMPTR namep = &mailnod;
+struct namnod *namep = &mailnod;
/* ======== variable and string handling ======== */
syslook(w,syswds)
- STRING w;
- SYSTAB syswds;
+ char *w;
+ struct sysnod syswds[];
{
- REG CHAR first;
- REG STRING s;
- REG SYSPTR syscan;
+ register char first;
+ register char *s;
+ register struct sysnod *syscan;
syscan=syswds; first = *w;
- WHILE s=syscan->sysnam
- DO IF first == *s
- ANDF eq(w,s)
- THEN return(syscan->sysval);
- FI
+ while (s=syscan->sysnam) {
+ if (first == *s
+ && eq(w,s)) {
+ return(syscan->sysval);
+ }
syscan++;
- OD
+ }
return(0);
}
setlist(arg,xp)
- REG ARGPTR arg;
- INT xp;
+ register struct argnod *arg;
+ int xp;
{
- WHILE arg
- DO REG STRING s=mactrim(arg->argval);
+ while (arg) {
+ register char *s=mactrim(arg->argval);
setname(s, xp);
arg=arg->argnxt;
- IF flags&execpr
- THEN prs(s);
- IF arg THEN blank(); ELSE newline(); FI
- FI
- OD
+ if (flags&execpr) {
+ prs(s);
+ if (arg) { blank(); }NEWLINEelse { newline(); }
+ }
+ }
}
-VOID setname(argi, xp)
- STRING argi;
- INT xp;
+void setname(argi, xp)
+ char *argi;
+ int xp;
{
- REG STRING argscan=argi;
- REG NAMPTR n;
+ register char *argscan=argi;
+ register struct namnod *n;
- IF letter(*argscan)
- THEN WHILE alphanum(*argscan) DO argscan++ OD
- IF *argscan=='='
- THEN *argscan = 0;
+ if (letter(*argscan)) {
+ while (alphanum(*argscan)) { argscan++; }
+ if (*argscan=='=') {
+ *argscan = 0;
n=lookup(argi);
*argscan++ = '=';
attrib(n, xp);
- IF xp&N_ENVNAM
- THEN
+ if (xp&N_ENVNAM) {
+
/*
* Importing IFS can be very dangerous
*/
- IF !bcmp(argi, "IFS=", sizeof("IFS=") - 1)
- THEN
+ if (!bcmp(argi, "IFS=", sizeof("IFS=") - 1)) {
+
int uid;
- IF (uid = getuid())!=geteuid() ORF !uid
- THEN
+ if ((uid = getuid())!=geteuid() || !uid) {
+
return;
- FI
- FI
+ }
+ }
n->namenv = n->namval = argscan;
- ELSE assign(n, argscan);
- FI
+ }
+ else {
+ assign(n, argscan);
+ }
return;
- FI
- FI
+ }
+ }
failed(argi,notid);
}
replace(a, v)
- REG STRING *a;
- STRING v;
+ register char **a;
+ char *v;
{
free(*a); *a=make(v);
}
dfault(n,v)
- NAMPTR n;
- STRING v;
+ struct namnod *n;
+ char *v;
{
- IF n->namval==0
- THEN assign(n,v)
- FI
+ if (n->namval==0) {
+ assign(n,v);
+ }
}
assign(n,v)
- NAMPTR n;
- STRING v;
+ struct namnod *n;
+ char *v;
{
- IF n->namflg&N_RDONLY
- THEN failed(n->namid,wtfailed);
- ELSE replace(&n->namval,v);
- FI
+ if (n->namflg&N_RDONLY) {
+ failed(n->namid,wtfailed);
+ }
+ else {
+ replace(&n->namval,v);
+ }
}
-INT readvar(names)
- STRING *names;
+int readvar(names)
+ char **names;
{
- FILEBLK fb;
- REG FILE f = &fb;
- REG CHAR c;
- REG INT rc=0;
- NAMPTR n=lookup(*names++); /* done now to avoid storage mess */
- STKPTR rel=relstak();
+ struct fileblk fb;
+ register struct fileblk *f = &fb;
+ register char c;
+ register int rc=0;
+ struct namnod *n=lookup(*names++); /* done now to avoid storage mess */
+ char *rel=relstak();
push(f); initf(dup(0));
- IF lseek(0,0L,1)==-1
- THEN f->fsiz=1;
- FI
-
- LOOP c=nextc(0);
- IF (*names ANDF any(c, ifsnod.namval)) ORF eolchar(c)
- THEN zerostak();
+ if (lseek(0,0L,1)==-1) {
+ f->fsiz=1;
+ }
+
+ for(;;) {
+ c=nextc(0);
+ if ((*names && any(c, ifsnod.namval)) || eolchar(c)) {
+ zerostak();
assign(n,absstak(rel)); setstak(rel);
- IF *names
- THEN n=lookup(*names++);
- ELSE n=0;
- FI
- IF eolchar(c)
- THEN break;
- FI
- ELSE pushstak(c);
- FI
- POOL
- WHILE n
- DO assign(n, nullstr);
- IF *names THEN n=lookup(*names++); ELSE n=0; FI
- OD
-
- IF eof THEN rc=1 FI
+ if (*names) {
+ n=lookup(*names++);
+ }
+ else {
+ n=0;
+ }
+ if (eolchar(c)) {
+ break;
+ }
+ }
+ else {
+ pushstak(c);
+ }
+ }
+ while (n) {
+ assign(n, nullstr);
+ if (*names) { n=lookup(*names++); }NEWLINEelse { n=0; }
+ }
+
+ if (eof) { rc=1; }
lseek(0, (long)(f->fnxt-f->fend), 1);
pop();
return(rc);
}
assnum(p, i)
- STRING *p;
- INT i;
+ char **p;
+ int i;
{
itos(i); replace(p,numbuf);
}
-STRING make(v)
- STRING v;
+char *make(v)
+ char *v;
{
- REG STRING p;
+ register char *p;
- IF v
- THEN movstr(v,p=alloc(length(v)));
+ if (v) {
+ movstr(v,p=alloc(length(v)));
return(p);
- ELSE return(0);
- FI
+ }
+ else {
+ return(0);
+ }
}
-NAMPTR lookup(nam)
- REG STRING nam;
+struct namnod *lookup(nam)
+ register char *nam;
{
- REG NAMPTR nscan=namep;
- REG NAMPTR *prev;
- INT LR;
-
- IF !chkid(nam)
- THEN failed(nam,notid);
- FI
- WHILE nscan
- DO IF (LR=cf(nam,nscan->namid))==0
- THEN return(nscan);
- ELIF LR<0
- THEN prev = &(nscan->namlft);
- ELSE prev = &(nscan->namrgt);
- FI
+ register struct namnod *nscan=namep;
+ register struct namnod **prev;
+ int LR;
+
+ if (!chkid(nam)) {
+ failed(nam,notid);
+ }
+ while (nscan) {
+ if ((LR=cf(nam,nscan->namid))==0) {
+ return(nscan);
+ }
+ else if (LR<0) {
+ prev = &(nscan->namlft);
+ }
+ else {
+ prev = &(nscan->namrgt);
+ }
nscan = *prev;
- OD
+ }
/* add name node */
nscan=alloc(sizeof *nscan);
return(*prev = nscan);
}
-LOCAL BOOL chkid(nam)
- STRING nam;
+static bool chkid(nam)
+ char *nam;
{
- REG CHAR * cp=nam;
-
- IF !letter(*cp)
- THEN return(FALSE);
- ELSE WHILE *++cp
- DO IF !alphanum(*cp)
- THEN return(FALSE);
- FI
- OD
- FI
- return(TRUE);
+ register char * cp=nam;
+
+ if (!letter(*cp)) {
+ return(0);
+ }
+ else {
+ while (*++cp) {
+ if (!alphanum(*cp)) {
+ return(0);
+ }
+ }
+ }
+ return(-1);
}
-LOCAL VOID (*namfn)();
+static void (*namfn)();
namscan(fn)
- VOID (*fn)();
+ void (*fn)();
{
namfn=fn;
namwalk(namep);
}
-LOCAL VOID namwalk(np)
- REG NAMPTR np;
+static void namwalk(np)
+ register struct namnod *np;
{
- IF np
- THEN namwalk(np->namlft);
+ if (np) {
+ namwalk(np->namlft);
(*namfn)(np);
namwalk(np->namrgt);
- FI
+ }
}
-VOID printnam(n)
- NAMPTR n;
+void printnam(n)
+ struct namnod *n;
{
- REG STRING s;
+ register char *s;
sigchk();
- IF s=n->namval
- THEN prs(n->namid);
+ if (s=n->namval) {
+ prs(n->namid);
prc('='); prs(s);
newline();
- FI
+ }
}
-LOCAL STRING staknam(n)
- REG NAMPTR n;
+static char *staknam(n)
+ register struct namnod *n;
{
- REG STRING p;
+ register char *p;
p=movstr(n->namid,staktop);
p=movstr("=",p);
p=movstr(n->namval,p);
- return(getstak(p+1-ADR(stakbot)));
+ return(getstak(p+1-(void *)(stakbot)));
}
-VOID exname(n)
- REG NAMPTR n;
+void exname(n)
+ register struct namnod *n;
{
- IF n->namflg&N_EXPORT
- THEN free(n->namenv);
+ if (n->namflg&N_EXPORT) {
+ free(n->namenv);
n->namenv = make(n->namval);
- ELSE free(n->namval);
+ }
+ else {
+ free(n->namval);
n->namval = make(n->namenv);
- FI
+ }
}
-VOID printflg(n)
- REG NAMPTR n;
+void printflg(n)
+ register struct namnod *n;
{
- IF n->namflg&N_EXPORT
- THEN prs(export); blank();
- FI
- IF n->namflg&N_RDONLY
- THEN prs(readonly); blank();
- FI
- IF n->namflg&(N_EXPORT|N_RDONLY)
- THEN prs(n->namid); newline();
- FI
+ if (n->namflg&N_EXPORT) {
+ prs(export); blank();
+ }
+ if (n->namflg&N_RDONLY) {
+ prs(readonly); blank();
+ }
+ if (n->namflg&(N_EXPORT|N_RDONLY)) {
+ prs(n->namid); newline();
+ }
}
-VOID setupenv()
+void setupenv()
{
- REG STRING *e=environ;
+ register char **e=environ;
- WHILE *e
- DO setname(*e++, N_ENVNAM) OD
+ while (*e) { setname(*e++, N_ENVNAM); }
}
-LOCAL INT namec;
+static int namec;
-VOID countnam(n)
- NAMPTR n;
+void countnam(n)
+ struct namnod *n;
{
namec++;
}
-LOCAL STRING *argnam;
+static char **argnam;
-VOID pushnam(n)
- NAMPTR n;
+void pushnam(n)
+ struct namnod *n;
{
- IF n->namval
- THEN *argnam++ = staknam(n);
- FI
+ if (n->namval) {
+ *argnam++ = staknam(n);
+ }
}
-STRING *setenv()
+char **setenv()
{
- REG STRING *er;
+ register char **er;
namec=0;
namscan(countnam);
#define N_DEFAULT 0
struct namnod {
- NAMPTR namlft;
- NAMPTR namrgt;
- STRING namid;
- STRING namval;
- STRING namenv;
- INT namflg;
-};
+ struct namnod *namlft;
+ struct namnod *namrgt;
+ char *namid;
+ char *namval;
+ char *namenv;
+ int namflg;
+}
#include "defs.h"
-CHAR numbuf[6];
+char numbuf[6];
/* printing and io conversion */
newline()
-{ prc(NL);
+{ prc('\n');
}
blank()
-{ prc(SP);
+{ prc(' ');
}
prp()
{
- IF (flags&prompt)==0 ANDF cmdadr
- THEN prs(cmdadr); prs(colon);
- FI
+ if ((flags&prompt)==0 && cmdadr) {
+ prs(cmdadr); prs(colon);
+ }
}
-VOID prs(as)
- STRING as;
+void prs(as)
+ char *as;
{
- REG STRING s;
+ register char *s;
- IF s=as
- THEN write(output,s,length(s)-1);
- FI
+ if (s=as) {
+ write(output,s,length(s)-1);
+ }
}
-VOID prc(c)
- CHAR c;
+void prc(c)
+ char c;
{
- IF c
- THEN write(output,&c,1);
- FI
+ if (c) {
+ write(output,&c,1);
+ }
}
prt(t)
- L_INT t;
+ long t;
{
- REG INT hr, min, sec;
+ register int hr, min, sec;
t += 30; t /= 60;
sec=t%60; t /= 60;
min=t%60;
- IF hr=t/60
- THEN prn(hr); prc('h');
- FI
+ if (hr=t/60) {
+ prn(hr); prc('h');
+ }
prn(min); prc('m');
prn(sec); prc('s');
}
prn(n)
- INT n;
+ int n;
{
itos(n); prs(numbuf);
}
itos(n)
{
- REG char *abuf; REG POS a, i; INT pr, d;
- abuf=numbuf; pr=FALSE; a=n;
- FOR i=10000; i!=1; i/=10
- DO IF (pr |= (d=a/i)) THEN *abuf++=d+'0' FI
+ register char *abuf; register unsigned a, i; int pr, d;
+ abuf=numbuf; pr=0; a=n;
+ for (i=10000; i!=1; i/=10) {
+ if ((pr |= (d=a/i))) { *abuf++=d+'0'; }
a %= i;
- OD
+ }
*abuf++=a+'0';
*abuf++=0;
}
stoi(icp)
-STRING icp;
+char *icp;
{
- REG CHAR *cp = icp;
- REG INT r = 0;
- REG CHAR c;
-
- WHILE (c = *cp, digit(c)) ANDF c ANDF r>=0
- DO r = r*10 + c - '0'; cp++ OD
- IF r<0 ORF cp==icp
- THEN failed(icp,badnum);
- ELSE return(r);
- FI
+ register char *cp = icp;
+ register int r = 0;
+ register char c;
+
+ while ((c = *cp, digit(c)) && c && r>=0) { r = r*10 + c - '0'; cp++; }
+ if (r<0 || cp==icp) {
+ failed(icp,badnum);
+ }
+ else {
+ return(r);
+ }
}
#include "defs.h"
-PROC VOID gsort();
+extern void gsort();
#define ARGMK 01
-INT errno;
-STRING sysmsg[];
-INT num_sysmsg;
+int errno;
+char *sysmsg[];
+int num_sysmsg;
/* fault handling */
#define ENOMEM 12
/* service routines for `execute' */
-VOID initio(iop)
- IOPTR iop;
+void initio(iop)
+ struct ionod *iop;
{
- REG STRING ion;
- REG INT iof, fd;
+ register char *ion;
+ register int iof, fd;
- IF iop
- THEN iof=iop->iofile;
+ if (iop) {
+ iof=iop->iofile;
ion=mactrim(iop->ioname);
- IF *ion ANDF (flags&noexec)==0
- THEN IF iof&IODOC
- THEN subst(chkopen(ion),(fd=tmpfil()));
+ if (*ion && (flags&noexec)==0) {
+ if (iof&IODOC) {
+ subst(chkopen(ion),(fd=tmpfil()));
close(fd); fd=chkopen(tmpout); unlink(tmpout);
- ELIF iof&IOMOV
- THEN IF eq(minus,ion)
- THEN fd = -1;
+ }
+ else if (iof&IOMOV) {
+ if (eq(minus,ion)) {
+ fd = -1;
close(iof&IOUFD);
- ELIF (fd=stoi(ion))>=USERIO
- THEN failed(ion,badfile);
- ELSE fd=dup(fd);
- FI
- ELIF (iof&IOPUT)==0
- THEN fd=chkopen(ion);
- ELIF flags&rshflg
- THEN failed(ion,restricted);
- ELIF iof&IOAPP ANDF (fd=open(ion,1))>=0
- THEN lseek(fd, 0L, 2);
- ELSE fd=create(ion);
- FI
- IF fd>=0
- THEN rename(fd,iof&IOUFD);
- FI
- FI
+ }
+ else if ((fd=stoi(ion))>=USERIO) {
+ failed(ion,badfile);
+ }
+ else {
+ fd=dup(fd);
+ }
+ }
+ else if ((iof&IOPUT)==0) {
+ fd=chkopen(ion);
+ }
+ else if (flags&rshflg) {
+ failed(ion,restricted);
+ }
+ else if (iof&IOAPP && (fd=open(ion,1))>=0) {
+ lseek(fd, 0L, 2);
+ }
+ else {
+ fd=create(ion);
+ }
+ if (fd>=0) {
+ rename(fd,iof&IOUFD);
+ }
+ }
initio(iop->ionxt);
- FI
+ }
}
-STRING getpath(s)
- STRING s;
+char *getpath(s)
+ char *s;
{
- REG STRING path;
- IF any('/',s)
- THEN IF flags&rshflg
- THEN failed(s, restricted);
- ELSE return(nullstr);
- FI
- ELIF (path = pathnod.namval)==0
- THEN return(defpath);
- ELSE return(cpystak(path));
- FI
+ register char *path;
+ if (any('/',s)) {
+ if (flags&rshflg) {
+ failed(s, restricted);
+ }
+ else {
+ return(nullstr);
+ }
+ }
+ else if ((path = pathnod.namval)==0) {
+ return(defpath);
+ }
+ else {
+ return(cpystak(path));
+ }
}
-INT pathopen(path, name)
- REG STRING path, name;
+int pathopen(path, name)
+ register char*CHECKME path, name;
{
- REG UFD f;
+ register int f;
- REP path=catpath(path,name);
- PER (f=open(curstak(),0))<0 ANDF path DONE
+ do {
+ path=catpath(path,name);
+ } while ((f=open(curstak(),0))<0 && path);
return(f);
}
-STRING catpath(path,name)
- REG STRING path;
- STRING name;
+char*CHECKME catpath(path,name)
+ register char *path;
+ char *name;
{
/* leaves result on top of stack */
- REG STRING scanp = path,
+ register char*CHECKME scanp = path,
argp = locstak();
- WHILE *scanp ANDF *scanp!=COLON DO *argp++ = *scanp++ OD
- IF scanp!=path THEN *argp++='/' FI
- IF *scanp==COLON THEN scanp++ FI
+ while (*scanp && *scanp!=':') { *argp++ = *scanp++; }
+ if (scanp!=path) { *argp++='/'; }
+ if (*scanp==':') { scanp++; }
path=(*scanp ? scanp : 0); scanp=name;
- WHILE (*argp++ = *scanp++) DONE
+ while ((*argp++ = *scanp++));
return(path);
}
-LOCAL STRING xecmsg;
-LOCAL STRING *xecenv;
+static char *xecmsg;
+static char **xecenv;
-VOID execa(at)
- STRING at[];
+void execa(at)
+ char *at[];
{
- REG STRING path;
- REG STRING *t = at;
+ register char *path;
+ register char **t = at;
- IF (flags&noexec)==0
- THEN xecmsg=notfound; path=getpath(*t);
+ if ((flags&noexec)==0) {
+ xecmsg=notfound; path=getpath(*t);
namscan(exname);
xecenv=setenv();
- WHILE path=execs(path,t) DONE
+ while (path=execs(path,t));
failed(*t,xecmsg);
- FI
+ }
}
-LOCAL STRING execs(ap,t)
- STRING ap;
- REG STRING t[];
+static char*CHECKME execs(ap,t)
+ char *ap;
+ register char *t[];
{
- REG STRING p, prefix;
+ register char*CHECKME p, prefix;
prefix=catpath(ap,t[0]);
trim(p=curstak());
sigchk();
execve(p, &t[0] ,xecenv);
- SWITCH errno IN
+ switch (errno) {
+
case ENOEXEC:
flags=0;
comdiv=0; ioset=0;
clearup(); /* remove open files and for loop junk */
- IF input THEN close(input) FI
+ if (input) { close(input); }
close(output); output=2;
input=chkopen(p);
xecmsg=badexec;
case ENOENT:
return(prefix);
- ENDSW
+ }
}
gocsh(t, cp, xecenv)
/* for processes to be waited for */
#define MAXP 20
-LOCAL INT pwlist[MAXP];
-LOCAL INT pwc;
+static int pwlist[MAXP];
+static int pwc;
postclr()
{
- REG INT *pw = pwlist;
+ register int *pw = pwlist;
- WHILE pw <= &pwlist[pwc]
- DO *pw++ = 0 OD
+ while (pw <= &pwlist[pwc]) { *pw++ = 0; }
pwc=0;
}
-VOID post(pcsid)
- INT pcsid;
+void post(pcsid)
+ int pcsid;
{
- REG INT *pw = pwlist;
-
- IF pcsid
- THEN WHILE *pw DO pw++ OD
- IF pwc >= MAXP-1
- THEN pw--;
- ELSE pwc++;
- FI
+ register int *pw = pwlist;
+
+ if (pcsid) {
+ while (*pw) { pw++; }
+ if (pwc >= MAXP-1) {
+ pw--;
+ }
+ else {
+ pwc++;
+ }
*pw = pcsid;
- FI
+ }
}
-VOID await(i)
- INT i;
+void await(i)
+ int i;
{
- INT rc=0, wx=0;
- INT w;
- INT ipwc = pwc;
+ int rc=0, wx=0;
+ int w;
+ int ipwc = pwc;
post(i);
- WHILE pwc
- DO REG INT p;
- REG INT sig;
- INT w_hi;
-
- BEGIN
- REG INT *pw=pwlist;
- IF setjmp(INTbuf) == 0
- THEN trapjmp[INTR] = 1; p=wait(&w);
- ELSE p = -1;
- FI
+ while (pwc) {
+ register int p;
+ register int sig;
+ int w_hi;
+
+ {
+
+ register int *pw=pwlist;
+ if (setjmp(INTbuf) == 0) {
+ trapjmp[INTR] = 1; p=wait(&w);
+ }
+ else {
+ p = -1;
+ }
trapjmp[INTR] = 0;
- WHILE pw <= &pwlist[ipwc]
- DO IF *pw==p
- THEN *pw=0; pwc--;
- ELSE pw++;
- FI
- OD
- END
+ while (pw <= &pwlist[ipwc]) {
+ if (*pw==p) {
+ *pw=0; pwc--;
+ }
+ else {
+ pw++;
+ }
+ }
+ }
- IF p == -1 THEN continue FI
+ if (p == -1) { continue; }
- w_hi = (w>>8)&LOBYTE;
+ w_hi = (w>>8)&0377;
- IF sig = w&0177
- THEN IF sig == 0177 /* ptrace! return */
- THEN prs("ptrace: ");
+ if (sig = w&0177) {
+ if (sig == 0177 /* ptrace! return */) {
+ prs("ptrace: ");
sig = w_hi;
- FI
- IF sig < num_sysmsg ANDF sysmsg[sig]
- THEN IF i!=p ORF (flags&prompt)==0
- THEN prp(); prn(p); blank()
- FI
+ }
+ if (sig < num_sysmsg && sysmsg[sig]) {
+ if (i!=p || (flags&prompt)==0) {
+ prp(); prn(p); blank();
+ }
prs(sysmsg[sig]);
- IF w&0200 THEN prs(coredump) FI
- FI
+ if (w&0200) { prs(coredump); }
+ }
newline();
- FI
+ }
- IF rc==0
- THEN rc = (sig ? sig|SIGFLG : w_hi);
- FI
+ if (rc==0) {
+ rc = (sig ? sig|SIGFLG : w_hi);
+ }
wx |= w;
- OD
+ }
- IF wx ANDF flags&errflg
- THEN exitsh(rc);
- FI
+ if (wx && flags&errflg) {
+ exitsh(rc);
+ }
exitval=rc; exitset();
}
-BOOL nosubst;
+bool nosubst;
trim(at)
- STRING at;
+ char *at;
{
- REG STRING p;
- REG CHAR c;
- REG CHAR q=0;
-
- IF p=at
- THEN WHILE c = *p
- DO *p++=c&STRIP; q |= c OD
- FI
- nosubst=q"E;
+ register char *p;
+ register char c;
+ register char q=0;
+
+ if (p=at) {
+ while (c = *p) { *p++=c&0177; q |= c; }
+ }
+ nosubst=q&0200;
}
-STRING mactrim(s)
- STRING s;
+char *mactrim(s)
+ char *s;
{
- REG STRING t=macro(s);
+ register char *t=macro(s);
trim(t);
return(t);
}
-STRING *scan(argn)
- INT argn;
+char **scan(argn)
+ int argn;
{
- REG ARGPTR argp = Rcheat(gchain)&~ARGMK;
- REG STRING *comargn, *comargm;
+ register struct argnod *argp = Rcheat(gchain)&~ARGMK;
+ register char*CHECKME *comargn, *comargm;
comargn=getstak(BYTESPERWORD*argn+BYTESPERWORD); comargm = comargn += argn; *comargn = ENDARGS;
- WHILE argp
- DO *--comargn = argp->argval;
- IF argp = argp->argnxt
- THEN trim(*comargn);
- FI
- IF argp==0 ORF Rcheat(argp)&ARGMK
- THEN gsort(comargn,comargm);
+ while (argp) {
+ *--comargn = argp->argval;
+ if (argp = argp->argnxt) {
+ trim(*comargn);
+ }
+ if (argp==0 || Rcheat(argp)&ARGMK) {
+ gsort(comargn,comargm);
comargm = comargn;
- FI
+ }
/* Lcheat(argp) &= ~ARGMK; */
argp = Rcheat(argp)&~ARGMK;
- OD
+ }
return(comargn);
}
-LOCAL VOID gsort(from,to)
- STRING from[], to[];
+static void gsort(from,to)
+ char*CHECKME from[], to[];
{
- INT k, m, n;
- REG INT i, j;
-
- IF (n=to-from)<=1 THEN return FI
-
- FOR j=1; j<=n; j*=2 DONE
-
- FOR m=2*j-1; m/=2;
- DO k=n-m;
- FOR j=0; j<k; j++
- DO FOR i=j; i>=0; i-=m
- DO REG STRING *fromi; fromi = &from[i];
- IF cf(fromi[m],fromi[0])>0
- THEN break;
- ELSE STRING s; s=fromi[m]; fromi[m]=fromi[0]; fromi[0]=s;
- FI
- OD
- OD
- OD
+ int k, m, n;
+ register int i, j;
+
+ if ((n=to-from)<=1) { return; }
+
+ for (j=1; j<=n; j*=2);
+
+ for (m=2*j-1; m/=2;) {
+ k=n-m;
+ for (j=0; j<k; j++) {
+ for (i=j; i>=0; i-=m) {
+ register char **fromi; fromi = &from[i];
+ if (cf(fromi[m],fromi[0])>0) {
+ break;
+ }
+ else {
+ char *s; s=fromi[m]; fromi[m]=fromi[0]; fromi[0]=s;
+ }
+ }
+ }
+ }
}
/* Argument list generation */
-INT getarg(ac)
- COMPTR ac;
+int getarg(ac)
+ struct comnod *ac;
{
- REG ARGPTR argp;
- REG INT count=0;
- REG COMPTR c;
-
- IF c=ac
- THEN argp=c->comarg;
- WHILE argp
- DO count += split(macro(argp->argval));
+ register struct argnod *argp;
+ register int count=0;
+ register struct comnod *c;
+
+ if (c=ac) {
+ argp=c->comarg;
+ while (argp) {
+ count += split(macro(argp->argval));
argp=argp->argnxt;
- OD
- FI
+ }
+ }
return(count);
}
-LOCAL INT split(s)
- REG STRING s;
+static int split(s)
+ register char *s;
{
- REG STRING argp;
- REG INT c;
- INT count=0;
-
- LOOP sigchk(); argp=locstak()+BYTESPERWORD;
- WHILE (c = *s++, !any(c,ifsnod.namval) && c)
- DO *argp++ = c OD
- IF argp==staktop+BYTESPERWORD
- THEN IF c
- THEN continue;
- ELSE return(count);
- FI
- ELIF c==0
- THEN s--;
- FI
- IF c=expand((argp=endstak(argp))->argval,0)
- THEN count += c;
- ELSE /* assign(&fngnod, argp->argval); */
+ register char *argp;
+ register int c;
+ int count=0;
+
+ for(;;) {
+ sigchk(); argp=locstak()+BYTESPERWORD;
+ while ((c = *s++, !any(c,ifsnod.namval) && c)) { *argp++ = c; }
+ if (argp==staktop+BYTESPERWORD) {
+ if (c) {
+ continue;
+ }
+ else {
+ return(count);
+ }
+ }
+ else if (c==0) {
+ s--;
+ }
+ if (c=expand((argp=endstak(argp))->argval,0)) {
+ count += c;
+ }
+ else {
+ /* assign(&fngnod, argp->argval); */
makearg(argp); count++;
- FI
+ }
Lcheat(gchain) |= ARGMK;
- POOL
+ }
}
setbrk(incr)
{
- REG BYTPTR a=sbrk(incr);
+ register char *a=sbrk(incr);
brkend=a+incr;
return(a);
}
#include "defs.h"
-STKPTR stakbot=nullstr;
+char *stakbot=nullstr;
/* ======== storage allocation ======== */
-STKPTR getstak(asize)
- INT asize;
+char *getstak(asize)
+ int asize;
{ /* allocate requested stack */
- REG STKPTR oldstak;
- REG INT size;
+ register char *oldstak;
+ register int size;
size=round(asize,BYTESPERWORD);
oldstak=stakbot;
return(oldstak);
}
-STKPTR locstak()
+char *locstak()
{ /* set up stack for local use
* should be followed by `endstak'
*/
- IF brkend-stakbot<BRKINCR
- THEN setbrk(brkincr);
- IF brkincr < BRKMAX
- THEN brkincr += 256;
- FI
- FI
+ if (brkend-stakbot<BRKINCR) {
+ setbrk(brkincr);
+ if (brkincr < BRKMAX) {
+ brkincr += 256;
+ }
+ }
return(stakbot);
}
-STKPTR savstak()
+char *savstak()
{
assert(staktop==stakbot);
return(stakbot);
}
-STKPTR endstak(argp)
- REG STRING argp;
+char *endstak(argp)
+ register char *argp;
{ /* tidy up after `locstak' */
- REG STKPTR oldstak;
+ register char *oldstak;
*argp++=0;
oldstak=stakbot; stakbot=staktop=round(argp,BYTESPERWORD);
return(oldstak);
}
-VOID tdystak(x)
- REG STKPTR x;
+void tdystak(x)
+ register char *x;
{
/* try to bring stack back to x */
- WHILE ADR(stakbsy)>ADR(x)
- DO free(stakbsy);
+ while ((void *)(stakbsy)>(void *)(x)) {
+ free(stakbsy);
stakbsy = stakbsy->word;
- OD
- staktop=stakbot=max(ADR(x),ADR(stakbas));
+ }
+ staktop=stakbot=max((void *)(x),(void *)(stakbas));
rmtemp(x);
}
stakchk()
{
- IF (brkend-stakbas)>BRKINCR+BRKINCR
- THEN setbrk(-BRKINCR);
- FI
+ if ((brkend-stakbas)>BRKINCR+BRKINCR) {
+ setbrk(-BRKINCR);
+ }
}
-STKPTR cpystak(x)
- STKPTR x;
+char *cpystak(x)
+ char *x;
{
return(endstak(movstr(x,locstak())));
}
/* for local use only since it hands
* out a real address for the stack top
*/
-STKPTR locstak();
+char *locstak();
/* Will allocate the item being used and return its
* address (safe now).
/* For use after `locstak' to hand back
* new stack top and then allocate item
*/
-STKPTR endstak();
+char *endstak();
/* Copy a string onto the stack and
* allocate the space.
*/
-STKPTR cpystak();
+char *cpystak();
/* Allocate given ammount of stack space */
-STKPTR getstak();
+char *getstak();
/* A chain of ptrs of stack blocks that
* have become covered by heap allocation.
* `tdystak' will return them to the heap.
*/
-BLKPTR stakbsy;
+struct blk *stakbsy;
/* Base of the entire stack */
-STKPTR stakbas;
+char *stakbas;
/* Top of entire stack */
-STKPTR brkend;
+char *brkend;
/* Base of current item */
-STKPTR stakbot;
+char *stakbot;
/* Top of current item */
-STKPTR staktop;
+char *staktop;
/* Used with tdystak */
-STKPTR savstak();
+char *savstak();
/* ======== general purpose string handling ======== */
-STRING movstr(a,b)
- REG STRING a, b;
+char*CHECKME movstr(a,b)
+ register char*CHECKME a, b;
{
- WHILE *b++ = *a++ DONE
+ while (*b++ = *a++);
return(--b);
}
-INT any(c,s)
- REG CHAR c;
- STRING s;
+int any(c,s)
+ register char c;
+ char *s;
{
- REG CHAR d;
-
- WHILE d = *s++
- DO IF d==c
- THEN return(TRUE);
- FI
- OD
- return(FALSE);
+ register char d;
+
+ while (d = *s++) {
+ if (d==c) {
+ return(-1);
+ }
+ }
+ return(0);
}
-INT cf(s1, s2)
- REG STRING s1, s2;
+int cf(s1, s2)
+ register char*CHECKME s1, s2;
{
- WHILE *s1++ == *s2
- DO IF *s2++==0
- THEN return(0);
- FI
- OD
+ while (*s1++ == *s2) {
+ if (*s2++==0) {
+ return(0);
+ }
+ }
return(*--s1 - *s2);
}
-INT length(as)
- STRING as;
+int length(as)
+ char *as;
{
- REG STRING s;
+ register char *s;
- IF s=as THEN WHILE *s++ DONE FI
+ if (s=as) { while (*s++); }
return(s-as);
}
word()
{
- REG CHAR c, d;
- REG CHAR *argp=locstak()+BYTESPERWORD;
- INT alpha=1;
+ register char c, d;
+ register char *argp=locstak()+BYTESPERWORD;
+ int alpha=1;
wdnum=0; wdset=0;
- WHILE (c=nextc(0), space(c)) DONE
+ while ((c=nextc(0), space(c)));
- IF c=='#' ANDF ((flags&prompt)==0 ORF ((flags&ttyflg) ANDF
- standin->fstak!=0))
- THEN WHILE (c=readc()) ANDF c!=NL DONE
- FI
+ if (c=='#' && ((flags&prompt)==0 || ((flags&ttyflg) &&
+ standin->fstak!=0))) {
+ while ((c=readc()) && c!='\n');
+ }
- IF !eofmeta(c)
- THEN REP IF c==LITERAL
- THEN *argp++=(DQUOTE);
- WHILE (c=readc()) ANDF c!=LITERAL
- DO *argp++=(c|QUOTE); chkpr(c) OD
+ if (!eofmeta(c)) {
+ do {
+ if (c==LITERAL) {
+ *argp++=(DQUOTE);
+ while ((c=readc()) && c!=LITERAL) { *argp++=(c|0200); chkpr(c); }
*argp++=(DQUOTE);
- ELSE *argp++=(c);
- IF c=='=' THEN wdset |= alpha FI
- IF !alphanum(c) THEN alpha=0 FI
- IF qotchar(c)
- THEN d=c;
- WHILE (*argp++=(c=nextc(d))) ANDF c!=d
- DO chkpr(c) OD
- FI
- FI
- PER (c=nextc(0), !eofmeta(c)) DONE
+ }
+ 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(argp->argval[0]) THEN wdset=0 FI
+ if (!letter(argp->argval[0])) { wdset=0; }
peekc=c|MARK;
- IF argp->argval[1]==0 ANDF (d=argp->argval[0], digit(d)) ANDF (c=='>' ORF c=='<')
- THEN word(); wdnum=d-'0';
- ELSE /*check for reserved words*/
- IF reserv==FALSE ORF (wdval=syslook(argp->argval,reserved))==0
- THEN wdarg=argp; wdval=0;
- FI
- FI
-
- ELIF dipchar(c)
- THEN IF (d=nextc(0))==c
- THEN wdval = c|SYMREP;
- ELSE peekc = d|MARK; wdval = c;
- FI
- ELSE IF (wdval=c)==EOF
- THEN wdval=EOFSYM;
- FI
- IF iopend ANDF eolchar(c)
- THEN copy(iopend); iopend=0;
- FI
- FI
- reserv=FALSE;
+ if (argp->argval[1]==0 && (d=argp->argval[0], digit(d)) && (c=='>' || c=='<')) {
+ word(); wdnum=d-'0';
+ }
+ else {
+ /*check for reserved words*/
+ if (reserv==0 || (wdval=syslook(argp->argval,reserved))==0) {
+ wdarg=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)==0) {
+ wdval=EOFSYM;
+ }
+ if (iopend && eolchar(c)) {
+ copy(iopend); iopend=0;
+ }
+ }
+ reserv=0;
return(wdval);
}
nextc(quote)
- CHAR quote;
+ char quote;
{
- REG CHAR c, d;
- IF (d=readc())==ESCAPE
- THEN IF (c=readc())==NL
- THEN chkpr(NL); d=nextc(quote);
- ELIF quote ANDF c!=quote ANDF !escchar(c)
- THEN peekc=c|MARK;
- ELSE d = c|QUOTE;
- FI
- FI
+ register char c, d;
+ if ((d=readc())==ESCAPE) {
+ if ((c=readc())=='\n') {
+ chkpr('\n'); d=nextc(quote);
+ }
+ else if (quote && c!=quote && !escchar(c)) {
+ peekc=c|MARK;
+ }
+ else {
+ d = c|0200;
+ }
+ }
return(d);
}
readc()
{
- REG CHAR c;
- REG INT len;
- REG FILE f;
+ register char c;
+ register int len;
+ register struct fileblk *f;
retry:
- IF peekc
- THEN c=peekc; peekc=0;
- ELIF (f=standin, f->fnxt!=f->fend)
- THEN IF (c = *f->fnxt++)==0
- THEN IF f->feval
- THEN IF estabf(*f->feval++)
- THEN c=EOF;
- ELSE c=SP;
- FI
- ELSE goto retry; /* = c=readc(); */
- FI
- FI
- IF flags&readpr ANDF standin->fstak==0 THEN prc(c) FI
- IF c==NL THEN f->flin++ FI
- ELIF f->feof ORF f->fdes<0
- THEN c=EOF; f->feof++;
- ELIF (len=readb())<=0
- THEN close(f->fdes); f->fdes = -1; c=EOF; f->feof++;
- ELSE f->fend = (f->fnxt = f->fbuf)+len;
+ if (peekc) {
+ c=peekc; peekc=0;
+ }
+ else if ((f=standin, f->fnxt!=f->fend)) {
+ if ((c = *f->fnxt++)==0) {
+ if (f->feval) {
+ if (estabf(*f->feval++)) {
+ c=0;
+ }
+ else {
+ c=' ';
+ }
+ }
+ else {
+ goto retry; /* = c=readc(); */;
+ }
+ }
+ if (flags&readpr && standin->fstak==0) { prc(c); }
+ if (c=='\n') { f->flin++; }
+ }
+ else if (f->feof || f->fdes<0) {
+ c=0; f->feof++;
+ }
+ else if ((len=readb())<=0) {
+ close(f->fdes); f->fdes = -1; c=0; f->feof++;
+ }
+ else {
+ f->fend = (f->fnxt = f->fbuf)+len;
goto retry;
- FI
+ }
return(c);
}
-LOCAL readb()
+static readb()
{
- REG FILE f=standin;
- REG INT len;
+ register struct fileblk *f=standin;
+ register int len;
- IF setjmp(INTbuf) == 0 THEN trapjmp[INTR] = 1; FI
- REP IF trapnote&SIGSET THEN newline(); sigchk() FI
- PER (len=read(f->fdes,f->fbuf,f->fsiz))<0 ANDF trapnote DONE
+ if (setjmp(INTbuf) == 0) { trapjmp[INTR] = 1; }
+ do {
+ if (trapnote&SIGSET) { newline(); sigchk(); }
+ } while ((len=read(f->fdes,f->fbuf,f->fsiz))<0 && trapnote);
trapjmp[INTR] = 0;
return(len);
}
#include "defs.h"
#include "sym.h"
-LOCAL INT parent;
+static int parent;
-SYSTAB commands;
+struct sysnod commands[];
execute(argt, execflg, pf1, pf2)
- TREPTR argt;
- INT *pf1, *pf2;
+ struct trenod *argt;
+ int *pf1, *pf2;
{
/* `stakbot' is preserved by this routine */
- REG TREPTR t;
- STKPTR sav=savstak();
+ register struct trenod *t;
+ char *sav=savstak();
sigchk();
- IF (t=argt) ANDF execbrk==0
- THEN REG INT treeflgs;
- INT oldexit, type;
- REG STRING *com;
+ if ((t=argt) && execbrk==0) {
+ register int treeflgs;
+ int oldexit, type;
+ register char **com;
treeflgs = t->tretyp; type = treeflgs&COMMSK;
oldexit=exitval; exitval=0;
- SWITCH type IN
+ switch (type) {
+
case TCOM:
- BEGIN
- STRING a1;
- INT argn, internal;
- ARGPTR schain=gchain;
- IOPTR io=t->treio;
+ {
+
+ char *a1;
+ int argn, internal;
+ struct argnod *schain=gchain;
+ struct ionod *io=t->treio;
gchain=0;
argn = getarg(t);
com=scan(argn);
a1=com[1]; gchain=schain;
- IF argn==0 ORF (internal=syslook(com[0],commands))
- THEN setlist(t->comset, 0);
- FI
+ if (argn==0 || (internal=syslook(com[0],commands))) {
+ setlist(t->comset, 0);
+ }
- IF argn ANDF (flags&noexec)==0
- THEN /* print command if execpr */
- IF flags&execpr
- THEN argn=0; prs(execpmsg);
- WHILE com[argn]!=ENDARGS
- DO prs(com[argn++]); blank() OD
+ if (argn && (flags&noexec)==0) {
+ /* print command if execpr */
+ if (flags&execpr) {
+ argn=0; prs(execpmsg);
+ while (com[argn]!=ENDARGS) { prs(com[argn++]); blank(); }
newline();
- FI
+ }
- SWITCH internal IN
+ switch (internal) {
+
case SYSDOT:
- IF a1
- THEN REG INT f;
+ if (a1) {
+ register int f;
- IF (f=pathopen(getpath(a1), a1)) < 0
- THEN failed(a1,notfound);
- ELSE execexp(0,f);
- FI
- FI
+ if ((f=pathopen(getpath(a1), a1)) < 0) {
+ failed(a1,notfound);
+ }
+ else {
+ execexp(0,f);
+ }
+ }
break;
case SYSTIMES:
{
- L_INT t[4]; times(t);
+ long t[4]; times(t);
prt(t[2]); blank(); prt(t[3]); newline();
}
break;
execbrk = -loopcnt; break;
case SYSBREAK:
- IF (execbrk=loopcnt) ANDF a1
- THEN breakcnt=stoi(a1);
- FI
+ if ((execbrk=loopcnt) && a1) {
+ breakcnt=stoi(a1);
+ }
break;
case SYSTRAP:
- IF a1
- THEN BOOL clear;
- IF (clear=digit(*a1))==0
- THEN ++com;
- FI
- WHILE *++com
- DO INT i;
- IF (i=stoi(*com))>=MAXTRAP ORF i<MINTRAP
- THEN failed(*com,badtrap);
- ELIF clear
- THEN clrsig(i);
- ELSE replace(&trapcom[i],a1);
- IF *a1
- THEN getsig(i);
- ELSE ignsig(i);
- FI
- FI
- OD
- ELSE /* print out current traps */
- INT i;
+ if (a1) {
+ bool clear;
+ if ((clear=digit(*a1))==0) {
+ ++com;
+ }
+ while (*++com) {
+ int i;
+ if ((i=stoi(*com))>=MAXTRAP || i<MINTRAP) {
+ failed(*com,badtrap);
+ }
+ else if (clear) {
+ clrsig(i);
+ }
+ else {
+ replace(&trapcom[i],a1);
+ if (*a1) {
+ getsig(i);
+ }
+ else {
+ ignsig(i);
+ }
+ }
+ }
+ }
+ else {
+ /* print out current traps */
+ int i;
- FOR i=0; i<MAXTRAP; i++
- DO IF trapcom[i]
- THEN prn(i); prs(colon); prs(trapcom[i]); newline();
- FI
- OD
- FI
+ for (i=0; i<MAXTRAP; i++) {
+ if (trapcom[i]) {
+ prn(i); prs(colon); prs(trapcom[i]); newline();
+ }
+ }
+ }
break;
case SYSEXEC:
com++;
initio(io); ioset=0; io=0;
- IF a1==0 THEN break FI
+ if (a1==0) { break; }
case SYSLOGIN:
flags |= forked;
oldsigs(); execa(com); done();
case SYSCD:
- IF flags&rshflg
- THEN failed(com[0],restricted);
- ELIF (a1==0 ANDF (a1=homenod.namval)==0) ORF chdir(a1)<0
- THEN failed(a1,baddir);
- FI
+ if (flags&rshflg) {
+ failed(com[0],restricted);
+ }
+ else if ((a1==0 && (a1=homenod.namval)==0) || chdir(a1)<0) {
+ failed(a1,baddir);
+ }
break;
case SYSSHFT:
- IF dolc<1
- THEN error(badshift);
- ELSE dolv++; dolc--;
- FI
+ if (dolc<1) {
+ error(badshift);
+ }
+ else {
+ dolv++; dolc--;
+ }
assnum(&dolladr, dolc);
break;
*/
case SYSSET:
- IF a1
- THEN INT argc;
+ if (a1) {
+ int argc;
argc = options(argn,com);
- IF argc>1
- THEN setargs(com+argn-argc);
- FI
- ELIF t->comset==0
- THEN /*scan name chain and print*/
+ if (argc>1) {
+ setargs(com+argn-argc);
+ }
+ }
+ else if (t->comset==0) {
+ /*scan name chain and print*/
namscan(printnam);
- FI
+ }
break;
case SYSRDONLY:
exitval=N_RDONLY;
case SYSXPORT:
- IF exitval==0 THEN exitval=N_EXPORT; FI
+ if (exitval==0) { exitval=N_EXPORT; }
- IF a1
- THEN WHILE *++com
- DO attrib(lookup(*com), exitval) OD
- ELSE namscan(printflg);
- FI
+ if (a1) {
+ while (*++com) { attrib(lookup(*com), exitval); }
+ }
+ else {
+ namscan(printflg);
+ }
exitval=0;
break;
case SYSEVAL:
- IF a1
- THEN execexp(a1,&com[2]);
- FI
+ if (a1) {
+ execexp(a1,&com[2]);
+ }
break;
- case SYSUMASK:
- if (a1) {
- int c, i
- i = 0;
- while ((c = *a1++) >= '0' &&
- c <= '7')
- i = (i << 3) + c - '0';
- umask(i);
- } else {
- int i, j;
- umask(i = umask(0));
- prc('0');
- for (j = 6; j >= 0; j -= 3)
- prc(((i>>j)&07) + '0');
- newline();
- }
- break;
+ case SYSUMASK:
+ if (a1) {
+ int c, i
+ i = 0;
+ while ((c = *a1++) >= '0' &&
+ c <= '7')
+ i = (i << 3) + c - '0';
+ umask(i);
+ } else {
+ int i, j;
+ umask(i = umask(0));
+ prc('0');
+ for (j = 6; j >= 0; j -= 3)
+ prc(((i>>j)&07) + '0');
+ newline();
+ }
+ break;
default:
internal=builtin(argn,com);
- ENDSW
+ }
- IF internal
- THEN IF io THEN error(illegal) FI
+ if (internal) {
+ if (io) { error(illegal); }
chktrap();
break;
- FI
- ELIF t->treio==0
- THEN break;
- FI
- END
+ }
+ }
+ else if (t->treio==0) {
+ break;
+ }
+ }
case TFORK:
- IF execflg ANDF (treeflgs&(FAMP|FPOU))==0
- THEN parent=0;
- ELSE WHILE (parent=fork()) == -1
- DO sigchk(); alarm(10); pause() OD
- FI
-
- IF parent
- THEN /* This is the parent branch of fork; */
+ if (execflg && (treeflgs&(FAMP|FPOU))==0) {
+ parent=0;
+ }
+ else {
+ while ((parent=fork()) == -1) { sigchk(); alarm(10); pause(); }
+ }
+
+ if (parent) {
+ /* This is the parent branch of fork; */
/* it may or may not wait for the child. */
- IF treeflgs&FPRS ANDF flags&ttyflg
- THEN prn(parent); newline();
- FI
- IF treeflgs&FPCL THEN closepipe(pf1) FI
- IF (treeflgs&(FAMP|FPOU))==0
- THEN await(parent);
- ELIF (treeflgs&FAMP)==0
- THEN post(parent);
- ELSE assnum(&pcsadr, parent);
- FI
+ if (treeflgs&FPRS && flags&ttyflg) {
+ prn(parent); newline();
+ }
+ if (treeflgs&FPCL) { closepipe(pf1); }
+ if ((treeflgs&(FAMP|FPOU))==0) {
+ await(parent);
+ }
+ else if ((treeflgs&FAMP)==0) {
+ post(parent);
+ }
+ else {
+ assnum(&pcsadr, parent);
+ }
chktrap();
break;
- ELSE /* this is the forked branch (child) of execute */
+ }
+ else {
+ /* this is the forked branch (child) of execute */
flags |= forked; iotemp=0;
postclr();
settmp();
/* Reset ramaining signals to parent */
/* except for those `lost' by trap */
oldsigs();
- IF treeflgs&FINT
- THEN signal(INTR,1); signal(QUIT,1);
- FI
+ if (treeflgs&FINT) {
+ signal(INTR,1); signal(QUIT,1);
+ }
/* pipe in or out */
- IF treeflgs&FPIN
- THEN rename(pf1[INPIPE],0);
+ if (treeflgs&FPIN) {
+ rename(pf1[INPIPE],0);
close(pf1[OTPIPE]);
- FI
- IF treeflgs&FPOU
- THEN rename(pf2[OTPIPE],1);
+ }
+ if (treeflgs&FPOU) {
+ rename(pf2[OTPIPE],1);
close(pf2[INPIPE]);
- FI
+ }
/* default std input for & */
- IF treeflgs&FINT ANDF ioset==0
- THEN rename(chkopen(devnull),0);
- FI
+ if (treeflgs&FINT && ioset==0) {
+ rename(chkopen(devnull),0);
+ }
/* io redirection */
initio(t->treio);
- IF type!=TCOM
- THEN execute(t->forktre,1);
- ELIF com[0]!=ENDARGS
- THEN setlist(t->comset,N_EXPORT);
+ if (type!=TCOM) {
+ execute(t->forktre,1);
+ }
+ else if (com[0]!=ENDARGS) {
+ setlist(t->comset,N_EXPORT);
execa(com);
- FI
+ }
done();
- FI
+ }
case TPAR:
rename(dup(2),output);
done();
case TFIL:
- BEGIN
- INT pv[2]; chkpipe(pv);
- IF execute(t->lstlef, 0, pf1, pv)==0
- THEN execute(t->lstrit, execflg, pv, pf2);
- ELSE closepipe(pv);
- FI
- END
+ {
+
+ int pv[2]; chkpipe(pv);
+ if (execute(t->lstlef, 0, pf1, pv)==0) {
+ execute(t->lstrit, execflg, pv, pf2);
+ }
+ else {
+ closepipe(pv);
+ }
+ }
break;
case TLST:
break;
case TAND:
- IF execute(t->lstlef,0)==0
- THEN execute(t->lstrit,execflg);
- FI
+ if (execute(t->lstlef,0)==0) {
+ execute(t->lstrit,execflg);
+ }
break;
case TORF:
- IF execute(t->lstlef,0)!=0
- THEN execute(t->lstrit,execflg);
- FI
+ if (execute(t->lstlef,0)!=0) {
+ execute(t->lstrit,execflg);
+ }
break;
case TFOR:
- BEGIN
- NAMPTR n = lookup(t->fornam);
- STRING *args;
- DOLPTR argsav=0;
-
- IF t->forlst==0
- THEN args=dolv+1;
+ {
+
+ struct namnod *n = lookup(t->fornam);
+ char **args;
+ struct dolnod *argsav=0;
+
+ if (t->forlst==0) {
+ args=dolv+1;
argsav=useargs();
- ELSE ARGPTR schain=gchain;
+ }
+ else {
+ struct argnod *schain=gchain;
gchain=0;
trim((args=scan(getarg(t->forlst)))[0]);
gchain=schain;
- FI
+ }
loopcnt++;
- WHILE *args!=ENDARGS ANDF execbrk==0
- DO assign(n,*args++);
+ while (*args!=ENDARGS && execbrk==0) {
+ assign(n,*args++);
execute(t->fortre,0);
- IF execbrk<0 THEN execbrk=0 FI
- OD
- IF breakcnt THEN breakcnt-- FI
+ if (execbrk<0) { execbrk=0; }
+ }
+ if (breakcnt) { breakcnt--; }
execbrk=breakcnt; loopcnt--;
argfor=freeargs(argsav);
- END
+ }
break;
case TWH:
case TUN:
- BEGIN
- INT i=0;
+ {
+
+ int i=0;
loopcnt++;
- WHILE execbrk==0 ANDF (execute(t->whtre,0)==0)==(type==TWH)
- DO i=execute(t->dotre,0);
- IF execbrk<0 THEN execbrk=0 FI
- OD
- IF breakcnt THEN breakcnt-- FI
+ while (execbrk==0 && (execute(t->whtre,0)==0)==(type==TWH)) {
+ i=execute(t->dotre,0);
+ if (execbrk<0) { execbrk=0; }
+ }
+ if (breakcnt) { breakcnt--; }
execbrk=breakcnt; loopcnt--; exitval=i;
- END
+ }
break;
case TIF:
- IF execute(t->iftre,0)==0
- THEN execute(t->thtre,execflg);
- ELSE execute(t->eltre,execflg);
- FI
+ if (execute(t->iftre,0)==0) {
+ execute(t->thtre,execflg);
+ }
+ else {
+ execute(t->eltre,execflg);
+ }
break;
case TSW:
- BEGIN
- REG STRING r = mactrim(t->swarg);
+ {
+
+ register char *r = mactrim(t->swarg);
t=t->swlst;
- WHILE t
- DO ARGPTR rex=t->regptr;
- WHILE rex
- DO REG STRING s;
- IF gmatch(r,s=macro(rex->argval)) ORF (trim(s), eq(r,s))
- THEN execute(t->regcom,0);
+ while (t) {
+ struct argnod *rex=t->regptr;
+ while (rex) {
+ register char *s;
+ if (gmatch(r,s=macro(rex->argval)) || (trim(s), eq(r,s))) {
+ execute(t->regcom,0);
t=0; break;
- ELSE rex=rex->argnxt;
- FI
- OD
- IF t THEN t=t->regnxt FI
- OD
- END
+ }
+ else {
+ rex=rex->argnxt;
+ }
+ }
+ if (t) { t=t->regnxt; }
+ }
+ }
break;
- ENDSW
+ }
exitset();
- FI
+ }
sigchk();
tdystak(sav);
execexp(s,f)
- STRING s;
- UFD f;
+ char *s;
+ int f;
{
- FILEBLK fb;
+ struct fileblk fb;
push(&fb);
- IF s
- THEN estabf(s); fb.feval=f;
- ELIF f>=0
- THEN initf(f);
- FI
- execute(cmd(NL, NLFLG|MTFLG),0);
+ if (s) {
+ estabf(s); fb.feval=f;
+ }
+ else if (f>=0) {
+ initf(f);
+ }
+ execute(cmd('\n', NLFLG|MTFLG),0);
pop();
}
public / 43bsd.git / commitdiff