STRING flagp;
IF argc>1 && *argp[1]=='-'
- THEN cp=argp[1];
+ ) { cp=argp[1];
flags &= ~(execpr|readpr);
WHILE *++cp
DO flagc=flagchar;
WHILE *flagc && *flagc != *cp DO flagc++ OD
IF *cp == *flagc
- THEN flags |= flagval[flagc-flagchar];
+ ) { flags |= flagval[flagc-flagchar];
} else if (*cp=='c' && argc>2 && comdiv==0
- THEN comdiv=argp[2];
+ ) { comdiv=argp[2];
argp[1]=argp[0]; argp++; argc--;
} else { failed(argv[1],badopt);
FI
flagp=flagadr;
WHILE *flagc
DO IF flags&flagval[flagc-flagchar]
- THEN *flagp++ = *flagc;
+ ) { *flagp++ = *flagc;
FI
flagc++;
OD
REG DOLPTR argblk;
IF argblk=blk
- THEN argr = argblk->dolnxt;
+ ) { argr = argblk->dolnxt;
IF (--argblk->doluse)==0
- THEN FOR argp=(STRING *)argblk->dolarg; Rcheat(*argp)!=ENDARGS; argp++
+ ) { FOR argp=(STRING *)argblk->dolarg; Rcheat(*argp)!=ENDARGS; argp++
DO free(*argp) OD
free(argblk);
FI
DOLPTR useargs()
{
IF dolh
- THEN dolh->doluse++;
+ ) { dolh->doluse++;
dolh->dolnxt=argfor;
return(argfor=dolh);
} else { return(0);
REG BLKPTR p = blokp;
REG BLKPTR q;
REP IF !busy(p)
- THEN WHILE !busy(q = p->word) DO p->word = q->word OD
+ ) { WHILE !busy(q = p->word) DO p->word = q->word OD
IF ADR(q)-ADR(p) >= rbytes
- THEN blokp = BLK(ADR(p)+rbytes);
+ ) { blokp = BLK(ADR(p)+rbytes);
IF q > blokp
- THEN blokp->word = p->word;
+ ) { blokp->word = p->word;
FI
p->word=BLK(Rcheat(blokp)|BUSY);
return(ADR(p+1));
POS reqd;
{
IF stakbas!=staktop
- THEN REG STKPTR rndstak;
+ ) { REG STKPTR rndstak;
REG BLKPTR blokstak;
pushstak(0);
BLKPTR p;
IF (p=ap) && p<bloktop
- THEN Lcheat((--p)->word) &= ~BUSY;
+ ) { Lcheat((--p)->word) &= ~BUSY;
FI
}
for (;;) {
q = Rcheat(p->word)&~BUSY;
- IF p==ptr THEN exf++ FI
- IF q<end || q>bloktop THEN abort(3) FI
- IF p==bloktop THEN break FI
+ IF p==ptr ) { exf++ FI
+ IF q<end || q>bloktop ) { abort(3) FI
+ IF p==bloktop ) { break FI
IF busy(p)
- THEN us += q-p;
+ ) { us += q-p;
} else { un += q-p;
FI
- IF p>=q THEN abort(4) FI
+ IF p>=q ) { abort(4) FI
p=q;
}
- IF exf==0 THEN abort(1) FI
+ IF exf==0 ) { abort(1) FI
prn(un); prc(SP); prn(us); prc(NL);
}
#endif
REG LSTPTR t;
IF i==0 || r==0
- THEN synbad();
+ ) { synbad();
} else { t = (LSTPTR)getstak(LSTTYPE);
t->lsttyp = type;
t->lstlef = i; t->lstrit = r;
i = list(flg);
IF wdval==NL
- THEN IF flg&NLFLG
- THEN wdval=';'; chkpr(NL);
+ ) { IF flg&NLFLG
+ ) { wdval=';'; chkpr(NL);
FI
} else if ( i==0 && (flg&MTFLG)==0
- THEN synbad();
+ ) { synbad();
FI
switch(wdval) {
case '&':
IF i
- THEN i = makefork(FINT|FPRS|FAMP, i);
+ ) { i = makefork(FINT|FPRS|FAMP, i);
} else { synbad();
FI
case ';':
IF e=cmd(sym,flg|MTFLG)
- THEN i=makelist(TLST, i, e);
+ ) { i=makelist(TLST, i, e);
FI
break;
case EOFSYM:
IF sym==NL
- THEN break;
+ ) { break;
FI
default:
IF sym
- THEN chksym(sym);
+ ) { chksym(sym);
FI
}
reserv++;
IF flg&NLFLG
- THEN skipnl();
+ ) { skipnl();
} else { word();
FI
IF (t=item(TRUE)) && (wdval=='^' || wdval=='|')
- THEN return(makelist(TFIL, makefork(FPOU,t), makefork(FPIN|FPCL,term(NLFLG))));
+ ) { return(makelist(TFIL, makefork(FPOU,t), makefork(FPIN|FPCL,term(NLFLG))));
} else { return(t);
FI
}
{
skipnl();
IF wdval==esym
- THEN return(0);
+ ) { return(0);
} else { REG REGPTR r=(REGPTR)getstak(REGTYPE);
r->regptr=0;
for(;;) {
wdarg->argnxt=r->regptr;
r->regptr=wdarg;
IF wdval || ( word()!=')' && wdval!='|' )
- THEN synbad();
+ ) { synbad();
FI
IF wdval=='|'
- THEN word();
+ ) { word();
} else { break;
FI
}
r->regcom=cmd(0,NLFLG|MTFLG);
IF wdval==ECSYM
- THEN r->regnxt=syncase(esym);
+ ) { r->regnxt=syncase(esym);
} else { chksym(esym);
r->regnxt=0;
FI
REG IOPTR io;
IF flag
- THEN io=inout((IOPTR)0);
+ ) { io=inout((IOPTR)0);
} else { io=0;
FI
((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 THEN return(t) FI
+ IF w==EFSYM ) { return(t) FI
break;
}
chkword();
((FORPTR)t)->fornam=wdarg->argval;
IF skipnl()==INSYM
- THEN chkword();
+ ) { chkword();
((FORPTR)t)->forlst=(COMPTR)item(0);
IF wdval!=NL && wdval!=';'
- THEN synbad();
+ ) { synbad();
FI
chkpr(wdval); skipnl();
FI
default:
IF io==0
- THEN return(0);
+ ) { return(0);
FI
case 0:
WHILE wdval==0
DO argp = wdarg;
IF wdset && keywd
- THEN argp->argnxt=(ARGPTR)argset;
+ ) { argp->argnxt=(ARGPTR)argset;
argset=(ARGPTR *)argp;
} else { *argtail=argp; argtail = &(argp->argnxt); keywd=flags&keyflg;
FI
word();
IF flag
- THEN ((COMPTR)t)->comio=inout(((COMPTR)t)->comio);
+ ) { ((COMPTR)t)->comio=inout(((COMPTR)t)->comio);
FI
OD
}
reserv++; word();
IF io=inout(io)
- THEN t=makefork(0,t); t->treio=io;
+ ) { t=makefork(0,t); t->treio=io;
FI
return(t);
}
case APPSYM:
case '>':
- IF wdnum==0 THEN iof |= 1 FI
+ IF wdnum==0 ) { iof |= 1 FI
iof |= IOPUT;
IF wdval==APPSYM
- THEN iof |= IOAPP; break;
+ ) { iof |= IOAPP; break;
FI
case '<':
IF (c=nextc(0))=='&'
- THEN iof |= IOMOV;
+ ) { iof |= IOMOV;
} else if ( c=='>'
- THEN iof |= IORDW;
+ ) { iof |= IORDW;
} else { peekc=c|MARK;
FI
break;
iop->ioname=wdarg->argval;
iop->iofile=iof;
IF iof&IODOC
- THEN iop->iolst=iopend; iopend=iop;
+ ) { iop->iolst=iopend; iopend=iop;
FI
word(); iop->ionxt=inout(lastio);
return(iop);
static void chkword()
{
IF word()
- THEN synbad();
+ ) { synbad();
FI
}
{
REG INT x = sym&wdval;
IF ((x&SYMFLG) ? x : sym) != wdval
- THEN synbad();
+ ) { synbad();
FI
}
static void prsym(sym)
{
IF sym&SYMFLG
- THEN REG SYSPTR sp=reserved;
+ ) { REG SYSPTR sp=reserved;
WHILE sp->sysval
&& sp->sysval!=sym
DO sp++ OD
prs(sp->sysnam);
} else if ( sym==EOFSYM
- THEN prs(endoffile);
- } else { IF sym&SYMREP THEN prc(sym) FI
+ ) { prs(endoffile);
+ } else { IF sym&SYMREP ) { prc(sym) FI
IF sym==NL
- THEN prs("newline");
+ ) { prs("newline");
} else { prc(sym);
FI
FI
{
prp(); prs(synmsg);
IF (flags&ttyflg)==0
- THEN prs(atline); prn(standin->flin);
+ ) { prs(atline); prn(standin->flin);
FI
prs(colon);
prc(LQ);
IF wdval
- THEN prsym(wdval);
+ ) { prsym(wdval);
} else { prs(wdarg->argval);
FI
prc(RQ); prs(unexpected);
* no trap has been set.
*/
IF trapnote&SIGSET
- THEN exitsh(SIGFAIL);
+ ) { exitsh(SIGFAIL);
FI
}
{
prp(); prs(s1);
IF s2
- THEN prs(colon); prs(s2);
+ ) { prs(colon); prs(s2);
FI
newline(); exitsh(ERROR);
}
*/
exitval=xno;
IF (flags & (forked|errflg|ttyflg)) != ttyflg
- THEN done();
+ ) { done();
} else {
clearup();
longjmp(errshell,1);
{
REG STRING t;
IF t=trapcom[0]
- THEN trapcom[0]=0; /*should free but not long */
+ ) { trapcom[0]=0; /*should free but not long */
execexp(t,0);
FI
rmtemp(0);
struct dirent entry;
STATBUF statb;
- IF trapnote&SIGSET THEN return(0); FI
+ IF trapnote&SIGSET ) { return(0); FI
s=cs=as; entry.d_name[DIRSIZ-1]=0; /* to end the string */
REG BOOL slash; slash=0;
WHILE !fngchar(*cs)
DO IF *cs++==0
- THEN IF rflg && slash THEN break; } else { return(0) FI
+ ) { IF rflg && slash ) { break; } else { return(0) FI
} else if ( *cs=='/'
- THEN slash++;
+ ) { slash++;
FI
OD
}
for(;;) { IF cs==s
- THEN s=nullstr;
+ ) { s=nullstr;
break;
} else if ( *--cs == '/'
- THEN *cs=0;
- IF s==cs THEN s="/" FI
+ ) { *cs=0;
+ IF s==cs ) { s="/" FI
break;
FI
}
IF stat(s,&statb)>=0
&& (statb.st_mode&S_IFMT)==S_IFDIR
&& (dirf=open(s,0))>0
- THEN dir++;
+ ) { dir++;
FI
count=0;
- IF *cs==0 THEN *cs++=0200 FI
+ IF *cs==0 ) { *cs++=0200 FI
IF dir
- THEN /* check for rescan */
+ ) { /* check for rescan */
REG STRING rs; rs=cs;
- REP IF *rs=='/' THEN rescan=rs; *rs=0; gchain=0 FI
+ REP IF *rs=='/' ) { rescan=rs; *rs=0; gchain=0 FI
PER *rs++ DONE
// FIXME: readdir
WHILE read(dirf, (void *)&entry, 32) == 32 && (trapnote&SIGSET) == 0
DO IF entry.d_ino==0 ||
(*entry.d_name=='.' && *cs!='.')
- THEN continue;
+ ) { continue;
FI
IF gmatch(entry.d_name, cs)
- THEN addg(s,entry.d_name,rescan); count++;
+ ) { addg(s,entry.d_name,rescan); count++;
FI
OD
close(dirf);
IF rescan
- THEN REG ARGPTR rchain;
+ ) { REG ARGPTR rchain;
rchain=gchain; gchain=schain;
IF count
- THEN count=0;
+ ) { count=0;
WHILE rchain
DO count += expand(rchain->argval,1);
rchain=rchain->argnxt;
CHAR c;
IF scc = *s++
- THEN IF (scc &= STRIP)==0
- THEN scc=0200;
+ ) { IF (scc &= STRIP)==0
+ ) { scc=0200;
FI
FI
switch(c = *p++) {
ok=0; lc=077777;
WHILE c = *p++
DO IF c==']'
- THEN return(ok?gmatch(s,p):0);
+ ) { return(ok?gmatch(s,p):0);
} else if ( c==MINUS
- THEN IF lc<=scc && scc<=(*p++) THEN ok++ FI
- } else { IF scc==(lc=(c&STRIP)) THEN ok++ FI
+ ) { IF lc<=scc && scc<=(*p++) ) { ok++ FI
+ } else { IF scc==(lc=(c&STRIP)) ) { ok++ FI
FI
OD
return(0);
}
default:
- IF (c&STRIP)!=scc THEN return(0) FI
+ IF (c&STRIP)!=scc ) { return(0) FI
case '?':
return(scc?gmatch(s,p):0);
case '*':
- IF *p==0 THEN return(1) FI
+ IF *p==0 ) { return(1) FI
--s;
WHILE *s
- DO IF gmatch(s++,p) THEN return(1) FI OD
+ DO IF gmatch(s++,p) ) { return(1) FI OD
return(0);
case 0:
s1=as1;
WHILE c = *s1++
DO IF (c &= STRIP)==0
- THEN *s2++='/';
+ ) { *s2++='/';
break;
FI
*s2++=c;
s1=as2;
WHILE *s2 = *s1++ DO s2++ OD
IF s1=as3
- THEN *s2++='/';
+ ) { *s2++='/';
WHILE *s2++ = *++s1 DONE
FI
makearg(endstak(s2));
signal(sig,fault);
IF sig==MEMF
- THEN IF setbrk(brkincr) == -1
- THEN error(nospace);
+ ) { IF setbrk(brkincr) == -1
+ ) { error(nospace);
FI
} else if (sig==ALARM
- THEN IF flags&waiting
- THEN done();
+ ) { IF flags&waiting
+ ) { done();
FI
} else { flag = (trapcom[sig] ? TRAPSET : SIGSET);
trapnote |= flag;
#if 0
// FIXME: need to do proper SIG_IGN checks/handling
IF (s=signal(i=n,1)&01)==0
- THEN trapflg[i] |= SIGMOD;
+ ) { trapflg[i] |= SIGMOD;
FI
#endif
return(s);
REG INT i;
IF trapflg[i=n]&SIGMOD || ignsig(i)==0
- THEN signal(i,fault);
+ ) { signal(i,fault);
FI
}
WHILE i--
DO t=trapcom[i];
IF t==0 || *t
- THEN clrsig(i);
+ ) { clrsig(i);
FI
trapflg[i]=0;
OD
{
free(trapcom[i]); trapcom[i]=0;
IF trapflg[i]&SIGMOD
- THEN signal(i,fault);
+ ) { signal(i,fault);
trapflg[i] &= ~SIGMOD;
FI
}
trapnote &= ~TRAPSET;
WHILE --i
DO IF trapflg[i]&TRAPSET
- THEN trapflg[i] &= ~TRAPSET;
+ ) { trapflg[i] &= ~TRAPSET;
IF t=trapcom[i]
- THEN INT savxit=exitval;
+ ) { INT savxit=exitval;
execexp(t,0);
exitval=savxit; exitset();
FI
REG FILE f;
IF (f=standin)->fstak
- THEN IF f->fdes>=0 THEN close(f->fdes) FI
+ ) { IF f->fdes>=0 ) { close(f->fdes) FI
standin=f->fstak;
return(TRUE);
} else { return(FALSE);
INT *pv;
{
IF pipe(pv)<0 || pv[INPIPE]<0 || pv[OTPIPE]<0
- THEN error(piperr);
+ ) { error(piperr);
FI
}
REG INT rc;
IF (rc=open(idf,0))<0
- THEN failed(idf,badopen);
+ ) { failed(idf,badopen);
} else { return(rc);
FI
}
REG INT f1, f2;
{
IF f1!=f2
- THEN dup2(f1, f2);
+ ) { dup2(f1, f2);
close(f1);
- IF f2==0 THEN ioset|=1 FI
+ IF f2==0 ) { ioset|=1 FI
FI
}
REG INT rc;
IF (rc=creat(s,0666))<0
- THEN failed(s,badcreate);
+ ) { failed(s,badcreate);
} else { return(rc);
FI
}
REG IOPTR iop;
IF iop=ioparg
- THEN copy(iop->iolst);
- ends=mactrim(iop->ioname); IF nosubst THEN iop->iofile &= ~IODOC FI
+ ) { copy(iop->iolst);
+ ends=mactrim(iop->ioname); IF nosubst ) { iop->iofile &= ~IODOC FI
fd=tmpfil();
iop->ioname=cpystak(tmpout);
iop->iolst=iotemp; iotemp=iop;
clinep=cline; chkpr(NL);
WHILE (c = (nosubst ? readc() : nextc(*ends)), !eolchar(c)) DO *clinep++ = c OD
*clinep=0;
- IF eof || eq(cline,ends) THEN break FI
+ IF eof || eq(cline,ends) ) { break FI
*clinep++=NL;
write(fd,cline,clinep-cline);
}
#define REG register
#define IF if(
-#define THEN ){
#define FI ;}
#define FOR for(
WHILE (c=getch(endch))!=endch && c
DO pushstak(c|quote) OD
zerostak();
- IF c!=endch THEN error(badsub) FI
+ IF c!=endch ) { error(badsub) FI
}
static skipto(endch)
case DQUOTE: skipto(DQUOTE); break;
case DOLLAR: IF readc()==BRACE
- THEN skipto('}');
+ ) { skipto('}');
FI
}
OD
- IF c!=endch THEN error(badsub) FI
+ IF c!=endch ) { error(badsub) FI
}
static getch(endch)
retry:
d=readc();
IF !subchar(d)
- THEN return(d);
+ ) { return(d);
FI
IF d==DOLLAR
- THEN REG INT c;
+ ) { REG INT c;
IF (c=readc(), dolchar(c))
- THEN NAMPTR n=(NAMPTR)NIL;
+ ) { NAMPTR n=(NAMPTR)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 bra=(c==BRACE) ) { c=readc() FI
IF letter(c)
- THEN argp=(STRING)relstak();
+ ) { argp=(STRING)relstak();
WHILE alphanum(c) DO pushstak(c); c=readc() OD
zerostak();
n=lookup(absstak(argp)); setstak(argp);
v = n->namval; id = n->namid;
peekc = c|MARK;;
} else if ( digchar(c)
- THEN *id=c; idb[1]=0;
+ ) { *id=c; idb[1]=0;
IF astchar(c)
- THEN dolg=1; c='1';
+ ) { dolg=1; c='1';
FI
c -= '0';
v=((c==0) ? cmdadr : (c<=dolc) ? dolv[c] : (STRING)(dolg=0));
} else if ( c=='$'
- THEN v=pidadr;
+ ) { v=pidadr;
} else if ( c=='!'
- THEN v=pcsadr;
+ ) { v=pcsadr;
} else if ( c=='#'
- THEN v=dolladr;
+ ) { v=dolladr;
} else if ( c=='?'
- THEN v=exitadr;
+ ) { v=exitadr;
} else if ( c=='-'
- THEN v=flagadr;
- } else if ( bra THEN error(badsub);
+ ) { v=flagadr;
+ } else if ( bra ) { error(badsub);
} else { goto retry;
FI
c = readc();
IF !defchar(c) && bra
- THEN error(badsub);
+ ) { error(badsub);
FI
argp=0;
IF bra
- THEN IF c!='}'
- THEN argp=(STRING)relstak();
+ ) { IF c!='}'
+ ) { argp=(STRING)relstak();
IF (v==0)^(setchar(c))
- THEN copyto('}');
+ ) { copyto('}');
} else { skipto('}');
FI
argp=absstak(argp);
} else { peekc = c|MARK; c = 0;
FI
IF v
- THEN IF c!='+'
- THEN for (;;) {
+ ) { IF c!='+'
+ ) { for (;;) {
WHILE c = *v++
DO pushstak(c|quote); OD
IF dolg==0 || (++dolg>dolc)
- THEN break;
+ ) { break;
} else { v=dolv[dolg]; pushstak(SP|(*id=='*' ? quote : 0));
FI
}
FI
} else if ( argp
- THEN IF c=='?'
- THEN failed(id,*argp?argp:badparam);
+ ) { IF c=='?'
+ ) { failed(id,*argp?argp:badparam);
} else if ( c=='='
- THEN IF n
- THEN assign(n,argp);
+ ) { IF n
+ ) { assign(n,argp);
} else { error(badsub);
FI
FI
} else if ( flags&setflg
- THEN failed(id,badparam);
+ ) { failed(id,badparam);
FI
goto retry;
} else { peekc=c|MARK;
FI
} else if ( d==endch
- THEN return(d);
+ ) { return(d);
} else if ( d==SQUOTE
- THEN comsubst(); goto retry;
+ ) { comsubst(); goto retry;
} else if ( d==DQUOTE
- THEN quoted++; quote^=QUOTE; goto retry;
+ ) { quoted++; quote^=QUOTE; goto retry;
FI
return(d);
}
quote=0; quoted=0;
copyto(0);
pop();
- IF quoted && (stakbot==staktop) THEN pushstak(QUOTE) FI
+ IF quoted && (stakbot==staktop) ) { pushstak(QUOTE) FI
quote=savq; quoted=savqu;
return(fixstak());
}
await(0);
WHILE stakbot!=staktop
DO IF (*--staktop&STRIP)!=NL
- THEN ++staktop; break;
+ ) { ++staktop; break;
FI
OD
pop();
WHILE c=(getch(DQUOTE)&STRIP)
DO pushstak(c);
IF --count == 0
- THEN flush(ot); count=CPYSIZ;
+ ) { flush(ot); count=CPYSIZ;
FI
OD
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) FI
staktop=stakbot;
}
sh_getenv();
/* look for restricted */
-/* IF c>0 && any('r', *v) THEN rflag=0 FI */
+/* IF c>0 && any('r', *v) ) { rflag=0 FI */
/* look for options */
dolc=options(c,v);
- IF dolc<2 THEN flags |= stdflg FI
+ IF dolc<2 ) { flags |= stdflg FI
IF (flags&stdflg)==0
- THEN dolc--;
+ ) { dolc--;
FI
dolv=v+c-dolc; dolc--;
dfault(&ifsnod, sptbnl);
IF (beenhere++)==FALSE
- THEN /* ? profile */
+ ) { /* ? profile */
IF *cmdadr=='-'
&& (input=pathopen(nullstr, profile))>=0
- THEN exfile(rflag); flags &= ~ttyflg;
+ ) { exfile(rflag); flags &= ~ttyflg;
FI
- IF rflag==0 THEN flags |= rshflg FI
+ IF rflag==0 ) { flags |= rshflg FI
/* open input file if specified */
IF comdiv
- THEN estabf(comdiv); input = -1;
+ ) { estabf(comdiv); input = -1;
} else { input=((flags&stdflg) ? 0 : chkopen(cmdadr));
comdiv--;
FI
/* move input */
IF input>0
- THEN Ldup(input,INIO);
+ ) { Ldup(input,INIO);
input=INIO;
FI
/* move output to safe place */
IF output==2
- THEN Ldup(dup(2),OTIO);
+ ) { Ldup(dup(2),OTIO);
output=OTIO;
FI
/* decide whether interactive */
IF (flags&intflg) || ((flags&oneflg)==0 && isatty(output) && isatty(input))
- THEN dfault(&ps1nod, (userid?stdprompt:supprompt));
+ ) { dfault(&ps1nod, (userid?stdprompt:supprompt));
dfault(&ps2nod, readmsg);
flags |= ttyflg|prompt; ignsig(KILL);
} else {
FI
IF setjmp(errshell) && prof
- THEN close(input); return;
+ ) { close(input); return;
FI
/* error return here */
loopcnt=breakcnt=peekc=0; iopend=0;
- IF input>=0 THEN initf(input) FI
+ IF input>=0 ) { initf(input) FI
/* command loop */
for(;;) {
stakchk(); /* may reduce sbrk */
exitset();
IF (flags&prompt) && standin->fstak==0 && !eof
- THEN IF mailnod.namval
+ ) { IF mailnod.namval
&& stat(mailnod.namval,&statb)>=0 && statb.st_size
&& (statb.st_mtime != mailtime)
&& mailtime
- THEN prs(mailmsg)
+ ) { prs(mailmsg)
FI
mailtime=statb.st_mtime;
prs(ps1nod.namval); alarm(TIMEOUT); flags |= waiting;
trapnote=0; peekc=readc();
IF eof
- THEN return;
+ ) { return;
FI
alarm(0); flags &= ~waiting;
execute(cmd(NL,MTFLG),0);
char eor;
{
IF (flags&prompt) && standin->fstak==0 && eor==NL
- THEN prs(ps2nod.namval);
+ ) { prs(ps2nod.namval);
FI
}
WHILE s=syscan->sysnam
DO IF first == *s
&& eq(w,s)
- THEN return(syscan->sysval);
+ ) { return(syscan->sysval);
FI
syscan++;
OD
setname(s, xp);
arg=arg->argnxt;
IF flags&execpr
- THEN prs(s);
- IF arg THEN blank(); } else { newline(); FI
+ ) { prs(s);
+ IF arg ) { blank(); } else { newline(); FI
FI
OD
}
REG NAMPTR n;
IF letter(*argscan)
- THEN WHILE alphanum(*argscan) DO argscan++ OD
+ ) { WHILE alphanum(*argscan) DO argscan++ OD
IF *argscan=='='
- THEN *argscan = 0;
+ ) { *argscan = 0;
n=lookup(argi);
*argscan++ = '=';
attrib(n, xp);
IF xp&N_ENVNAM
- THEN n->namenv = n->namval = argscan;
+ ) { n->namenv = n->namval = argscan;
} else { assign(n, argscan);
FI
return;
STRING v;
{
IF n->namval==0
- THEN assign(n,v)
+ ) { assign(n,v)
FI
}
STRING v;
{
IF n->namflg&N_RDONLY
- THEN failed(n->namid,wtfailed);
+ ) { failed(n->namid,wtfailed);
} else { replace(&n->namval,v);
FI
}
push(f); initf(dup(0));
IF lseek(0,0L,1)==-1
- THEN f->fsiz=1;
+ ) { f->fsiz=1;
FI
for(;;) {
c=nextc(0);
IF (*names && any(c, ifsnod.namval)) || eolchar(c)
- THEN zerostak();
+ ) { zerostak();
assign(n,absstak(rel)); setstak(rel);
IF *names
- THEN n=lookup(*names++);
+ ) { n=lookup(*names++);
} else { n=0;
FI
IF eolchar(c)
- THEN break;
+ ) { break;
FI
} else { pushstak(c);
FI
}
WHILE n
DO assign(n, nullstr);
- IF *names THEN n=lookup(*names++); } else { n=0; FI
+ IF *names ) { n=lookup(*names++); } else { n=0; FI
OD
- IF eof THEN rc=1 FI
+ IF eof ) { rc=1 FI
lseek(0, (long)(f->fnxt-f->fend), 1);
pop();
return(rc);
REG STRING p;
IF v
- THEN movstr(v,p=alloc(length(v)));
+ ) { movstr(v,p=alloc(length(v)));
return(p);
} else { return(0);
FI
INT LR;
IF !chkid(nam)
- THEN failed(nam,notid);
+ ) { failed(nam,notid);
FI
WHILE nscan
DO IF (LR=cf(nam,nscan->namid))==0
- THEN return(nscan);
+ ) { return(nscan);
} else if ( LR<0
- THEN prev = &(nscan->namlft);
+ ) { prev = &(nscan->namlft);
} else { prev = &(nscan->namrgt);
FI
nscan = *prev;
REG CHAR * cp=nam;
IF !letter(*cp)
- THEN return(FALSE);
+ ) { return(FALSE);
} else { WHILE *++cp
DO IF !alphanum(*cp)
- THEN return(FALSE);
+ ) { return(FALSE);
FI
OD
FI
REG NAMPTR np;
{
IF np
- THEN namwalk(np->namlft);
+ ) { namwalk(np->namlft);
(*namfn)(np);
namwalk(np->namrgt);
FI
sigchk();
IF s=n->namval
- THEN prs(n->namid);
+ ) { prs(n->namid);
prc('='); prs(s);
newline();
FI
REG NAMPTR n;
{
IF n->namflg&N_EXPORT
- THEN free(n->namenv);
+ ) { free(n->namenv);
n->namenv = make(n->namval);
} else { free(n->namval);
n->namval = make(n->namenv);
REG NAMPTR n;
{
IF n->namflg&N_EXPORT
- THEN prs(export); blank();
+ ) { prs(export); blank();
FI
IF n->namflg&N_RDONLY
- THEN prs(readonly); blank();
+ ) { prs(readonly); blank();
FI
IF n->namflg&(N_EXPORT|N_RDONLY)
- THEN prs(n->namid); newline();
+ ) { prs(n->namid); newline();
FI
}
NAMPTR n;
{
IF n->namval
- THEN *argnam++ = staknam(n);
+ ) { *argnam++ = staknam(n);
FI
}
prp()
{
IF (flags&prompt)==0 && cmdadr
- THEN prs(cmdadr); prs(colon);
+ ) { prs(cmdadr); prs(colon);
FI
}
REG STRING s;
IF s=as
- THEN write(output,s,length(s)-1);
+ ) { write(output,s,length(s)-1);
FI
}
CHAR c;
{
IF c
- THEN write(output,&c,1);
+ ) { write(output,&c,1);
FI
}
sec=t%60; t /= 60;
min=t%60;
IF hr=t/60
- THEN prn(hr); prc('h');
+ ) { prn(hr); prc('h');
FI
prn(min); prc('m');
prn(sec); prc('s');
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
+ DO IF (pr |= (d=a/i)) ) { *abuf++=d+'0' FI
a %= i;
OD
*abuf++=a+'0';
WHILE (c = *cp, digit(c)) && c && r>=0
DO r = r*10 + c - '0'; cp++ OD
IF r<0 || cp==icp
- THEN failed(icp,badnum);
+ ) { failed(icp,badnum);
} else { return(r);
FI
}
REG INT iof, fd;
IF iop
- THEN iof=iop->iofile;
+ ) { iof=iop->iofile;
ion=mactrim(iop->ioname);
IF *ion && (flags&noexec)==0
- THEN IF iof&IODOC
- THEN subst(chkopen(ion),(fd=tmpfil()));
+ ) { IF iof&IODOC
+ ) { subst(chkopen(ion),(fd=tmpfil()));
close(fd); fd=chkopen(tmpout); unlink(tmpout);
} else if ( iof&IOMOV
- THEN IF eq(minus,ion)
- THEN fd = -1;
+ ) { IF eq(minus,ion)
+ ) { fd = -1;
close(iof&IOUFD);
} else if ( (fd=stoi(ion))>=USERIO
- THEN failed(ion,badfile);
+ ) { failed(ion,badfile);
} else { fd=dup(fd);
FI
} else if ( (iof&IOPUT)==0
- THEN fd=chkopen(ion);
+ ) { fd=chkopen(ion);
} else if ( flags&rshflg
- THEN failed(ion,restricted);
+ ) { failed(ion,restricted);
} else if ( iof&IOAPP && (fd=open(ion,1))>=0
- THEN lseek(fd, 0L, 2);
+ ) { lseek(fd, 0L, 2);
} else { fd=create(ion);
FI
IF fd>=0
- THEN sh_rename(fd,iof&IOUFD);
+ ) { sh_rename(fd,iof&IOUFD);
FI
FI
initio(iop->ionxt);
{
REG STRING path;
IF any('/',s)
- THEN IF flags&rshflg
- THEN failed(s, restricted);
+ ) { IF flags&rshflg
+ ) { failed(s, restricted);
} else { return(nullstr);
FI
} else if ( (path = pathnod.namval)==0
- THEN return(defpath);
+ ) { return(defpath);
} else { return(cpystak(path));
FI
}
argp = locstak();
WHILE *scanp && *scanp!=COLON DO *argp++ = *scanp++ OD
- IF scanp!=path THEN *argp++='/' FI
- IF *scanp==COLON THEN scanp++ FI
+ IF scanp!=path ) { *argp++='/' FI
+ IF *scanp==COLON ) { scanp++ FI
path=(*scanp ? scanp : 0); scanp=name;
WHILE (*argp++ = *scanp++) DONE
return(path);
REG STRING *t = at;
IF (flags&noexec)==0
- THEN xecmsg=notfound; path=getpath(*t);
+ ) { xecmsg=notfound; path=getpath(*t);
namscan(exname);
xecenv=sh_setenv();
WHILE path=execs(path,t) DONE
flags=0;
comdiv=0; ioset=0;
clearup(); /* remove open files and for loop junk */
- IF input THEN close(input) FI
+ IF input ) { close(input) FI
close(output); output=2;
input=chkopen(p);
REG INT *pw = pwlist;
IF pcsid
- THEN WHILE *pw DO pw++ OD
+ ) { WHILE *pw DO pw++ OD
IF pwc >= MAXP-1
- THEN pw--;
+ ) { pw--;
} else { pwc++;
FI
*pw = pcsid;
p=wait(&w);
WHILE pw <= &pwlist[ipwc]
DO IF *pw==p
- THEN *pw=0; pwc--;
+ ) { *pw=0; pwc--;
} else { pw++;
FI
OD
}
- IF p == -1 THEN continue FI
+ IF p == -1 ) { continue FI
w_hi = (w>>8)&LOBYTE;
IF sig = w&0177
- THEN IF sig == 0177 /* ptrace! return */
- THEN prs("ptrace: ");
+ ) { IF sig == 0177 /* ptrace! return */
+ ) { prs("ptrace: ");
sig = w_hi;
FI
IF sysmsg[sig]
- THEN IF i!=p || (flags&prompt)==0 THEN prp(); prn(p); blank() FI
+ ) { IF i!=p || (flags&prompt)==0 ) { prp(); prn(p); blank() FI
prs(sysmsg[sig]);
- IF w&0200 THEN prs(coredump) FI
+ IF w&0200 ) { prs(coredump) FI
FI
newline();
FI
IF rc==0
- THEN rc = (sig ? sig|SIGFLG : w_hi);
+ ) { rc = (sig ? sig|SIGFLG : w_hi);
FI
wx |= w;
OD
IF wx && flags&errflg
- THEN exitsh(rc);
+ ) { exitsh(rc);
FI
exitval=rc; exitset();
}
REG CHAR q=0;
IF p=at
- THEN WHILE c = *p
+ ) { WHILE c = *p
DO *p++=c&STRIP; q |= c OD
FI
nosubst=q"E;
WHILE argp
DO *--comargn = argp->argval;
IF argp = argp->argnxt
- THEN trim(*comargn);
+ ) { trim(*comargn);
FI
IF argp==0 || Rcheat(argp)&ARGMK
- THEN gsort(comargn,comargm);
+ ) { gsort(comargn,comargm);
comargm = comargn;
FI
/* Lcheat(argp) &= ~ARGMK; */
INT k, m, n;
REG INT i, j;
- IF (n=to-from)<=1 THEN return FI
+ IF (n=to-from)<=1 ) { return FI
FOR j=1; j<=n; j*=2 DONE
DO FOR i=j; i>=0; i-=m
DO REG STRING *fromi; fromi = &from[i];
IF cf(fromi[m],fromi[0])>0
- THEN break;
+ ) { break;
} else { STRING s; s=fromi[m]; fromi[m]=fromi[0]; fromi[0]=s;
FI
OD
REG COMPTR c;
IF c=ac
- THEN argp=c->comarg;
+ ) { argp=c->comarg;
WHILE argp
DO count += split(macro(argp->argval));
argp=argp->argnxt;
WHILE (c = *s++, !any(c,ifsnod.namval) && c)
DO *argp++ = c OD
IF argp==staktop+BYTESPERWORD
- THEN IF c
- THEN continue;
+ ) { IF c
+ ) { continue;
} else { return(count);
FI
} else if (c==0
- THEN s--;
+ ) { s--;
FI
IF c=expand(((ARGPTR)(argp=endstak(argp)))->argval,0)
- THEN count += c;
+ ) { count += c;
} else { /* assign(&fngnod, argp->argval); */
makearg(argp); count++;
FI
* should be followed by `endstak'
*/
IF brkend-stakbot<BRKINCR
- THEN setbrk(brkincr);
+ ) { setbrk(brkincr);
IF brkincr < BRKMAX
- THEN brkincr += 256;
+ ) { brkincr += 256;
FI
FI
return(stakbot);
stakchk()
{
IF (brkend-stakbas)>BRKINCR+BRKINCR
- THEN setbrk(-BRKINCR);
+ ) { setbrk(-BRKINCR);
FI
}
WHILE d = *s++
DO IF d==c
- THEN return(TRUE);
+ ) { return(TRUE);
FI
OD
return(FALSE);
{
WHILE *s1++ == *s2
DO IF *s2++==0
- THEN return(0);
+ ) { return(0);
FI
OD
return(*--s1 - *s2);
{
REG STRING s;
- IF s=as THEN WHILE *s++ DONE FI
+ IF s=as ) { WHILE *s++ DONE FI
return(s-as);
}
WHILE (c=nextc(0), space(c)) DONE
IF !eofmeta(c)
- THEN REP IF c==LITERAL
- THEN *argp++=(DQUOTE);
+ ) { REP IF c==LITERAL
+ ) { *argp++=(DQUOTE);
WHILE (c=readc()) && c!=LITERAL
DO *argp++=(c|QUOTE); chkpr(c) OD
*argp++=(DQUOTE);
} else { *argp++=(c);
- IF c=='=' THEN wdset |= alpha FI
- IF !alphanum(c) THEN alpha=0 FI
+ IF c=='=' ) { wdset |= alpha FI
+ IF !alphanum(c) ) { alpha=0 FI
IF qotchar(c)
- THEN d=c;
+ ) { d=c;
WHILE (*argp++=(c=nextc(d))) && c!=d
DO chkpr(c) OD
FI
FI
PER (c=nextc(0), !eofmeta(c)) DONE
argp=endstak(argp);
- IF !letter(((ARGPTR)argp)->argval[0]) THEN wdset=0 FI
+ IF !letter(((ARGPTR)argp)->argval[0]) ) { wdset=0 FI
peekc=c|MARK;
IF ((ARGPTR)argp)->argval[1]==0 && (d=((ARGPTR)argp)->argval[0], digit(d)) && (c=='>' || c=='<')
- THEN word(); wdnum=d-'0';
+ ) { word(); wdnum=d-'0';
} else { /*check for reserved words*/
IF reserv==FALSE || (wdval=syslook(((ARGPTR)argp)->argval,reserved))==0
- THEN wdarg=(ARGPTR)argp; wdval=0;
+ ) { wdarg=(ARGPTR)argp; wdval=0;
FI
FI
} else if ( dipchar(c)
- THEN IF (d=nextc(0))==c
- THEN wdval = c|SYMREP;
+ ) { IF (d=nextc(0))==c
+ ) { wdval = c|SYMREP;
} else { peekc = d|MARK; wdval = c;
FI
} else { IF (wdval=c)==EOF
- THEN wdval=EOFSYM;
+ ) { wdval=EOFSYM;
FI
IF iopend && eolchar(c)
- THEN copy(iopend); iopend=0;
+ ) { copy(iopend); iopend=0;
FI
FI
reserv=FALSE;
{
REG CHAR c, d;
IF (d=readc())==ESCAPE
- THEN IF (c=readc())==NL
- THEN chkpr(NL); d=nextc(quote);
+ ) { IF (c=readc())==NL
+ ) { chkpr(NL); d=nextc(quote);
} else if ( quote && c!=quote && !escchar(c)
- THEN peekc=c|MARK;
+ ) { peekc=c|MARK;
} else { d = c|QUOTE;
FI
FI
retry:
IF peekc
- THEN c=peekc; peekc=0;
+ ) { c=peekc; peekc=0;
} else if ( (f=standin, f->fnxt!=f->fend)
- THEN IF (c = *f->fnxt++)==0
- THEN IF f->feval
- THEN IF estabf(*f->feval++)
- THEN c=EOF;
+ ) { IF (c = *f->fnxt++)==0
+ ) { IF f->feval
+ ) { IF estabf(*f->feval++)
+ ) { c=EOF;
} else { c=SP;
FI
} else { goto retry; /* = c=readc(); */
FI
FI
- IF flags&readpr && standin->fstak==0 THEN prc(c) FI
- IF c==NL THEN f->flin++ FI
+ IF flags&readpr && standin->fstak==0 ) { prc(c) FI
+ IF c==NL ) { f->flin++ FI
} else if ( f->feof || f->fdes<0
- THEN c=EOF; f->feof++;
+ ) { c=EOF; f->feof++;
} else if ( (len=readb())<=0
- THEN close(f->fdes); f->fdes = -1; c=EOF; f->feof++;
+ ) { close(f->fdes); f->fdes = -1; c=EOF; f->feof++;
} else { f->fend = (f->fnxt = f->fbuf)+len;
goto retry;
FI
REG FILE f=standin;
REG INT len;
- REP IF trapnote&SIGSET THEN newline(); sigchk() FI
+ REP IF trapnote&SIGSET ) { newline(); sigchk() FI
PER (len=read(f->fdes,f->fbuf,f->fsiz))<0 && trapnote DONE
return(len);
}
sigchk();
IF (t=argt) && execbrk==0
- THEN REG INT treeflgs;
+ ) { REG INT treeflgs;
INT oldexit, type;
REG STRING *com;
a1=com[1]; gchain=schain;
IF (internal=syslook(com[0],commands)) || argn==0
- THEN setlist(((COMPTR)t)->comset, 0);
+ ) { setlist(((COMPTR)t)->comset, 0);
FI
IF argn && (flags&noexec)==0
- THEN /* print command if execpr */
+ ) { /* print command if execpr */
IF flags&execpr
- THEN argn=0; prs(execpmsg);
+ ) { argn=0; prs(execpmsg);
WHILE com[argn]!=ENDARGS
DO prs(com[argn++]); blank() OD
newline();
case SYSDOT:
IF a1
- THEN REG INT f;
+ ) { REG INT f;
IF (f=pathopen(getpath(a1), a1)) < 0
- THEN failed(a1,notfound);
+ ) { failed(a1,notfound);
} else { execexp(0,f);
FI
FI
case SYSBREAK:
IF (execbrk=loopcnt) && a1
- THEN breakcnt=stoi(a1);
+ ) { breakcnt=stoi(a1);
FI
break;
case SYSTRAP:
IF a1
- THEN BOOL clear;
+ ) { BOOL clear;
IF (clear=digit(*a1))==0
- THEN ++com;
+ ) { ++com;
FI
WHILE *++com
DO INT i;
IF (i=stoi(*com))>=MAXTRAP || i<MINTRAP
- THEN failed(*com,badtrap);
+ ) { failed(*com,badtrap);
} else if ( clear
- THEN clrsig(i);
+ ) { clrsig(i);
} else { replace(&trapcom[i],a1);
IF *a1
- THEN getsig(i);
+ ) { getsig(i);
} else { ignsig(i);
FI
FI
FOR i=0; i<MAXTRAP; i++
DO IF trapcom[i]
- THEN prn(i); prs(colon); prs(trapcom[i]); newline();
+ ) { prn(i); prs(colon); prs(trapcom[i]); newline();
FI
OD
FI
case SYSEXEC:
com++;
initio(io); ioset=0; io=0;
- IF a1==0 THEN break FI
+ IF a1==0 ) { break FI
case SYSLOGIN:
flags |= forked;
case SYSCD:
IF flags&rshflg
- THEN failed(com[0],restricted);
+ ) { failed(com[0],restricted);
} else if ( (a1==0 && (a1=homenod.namval)==0) || chdir(a1)<0
- THEN failed(a1,baddir);
+ ) { failed(a1,baddir);
FI
break;
case SYSSHFT:
IF dolc<1
- THEN error(badshift);
+ ) { error(badshift);
} else { dolv++; dolc--;
FI
assnum(&dolladr, dolc);
case SYSSET:
IF a1
- THEN INT argc;
+ ) { INT argc;
argc = options(argn,com);
IF argc>1
- THEN setargs(com+argn-argc);
+ ) { setargs(com+argn-argc);
FI
} else if ( ((COMPTR)t)->comset==0
- THEN /*scan name chain and print*/
+ ) { /*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; FI
IF a1
- THEN WHILE *++com
+ ) { WHILE *++com
DO attrib(lookup(*com), exitval) OD
} else { namscan(printflg);
FI
case SYSEVAL:
IF a1
- THEN execexp(a1,&com[2]);
+ ) { execexp(a1,&com[2]);
FI
break;
}
IF internal
- THEN IF io THEN error(illegal) FI
+ ) { IF io ) { error(illegal) FI
chktrap();
break;
FI
} else if ( t->treio==0
- THEN break;
+ ) { break;
FI
}
case TFORK:
IF execflg && (treeflgs&(FAMP|FPOU))==0
- THEN parent=0;
+ ) { parent=0;
} else { WHILE (parent=fork()) == -1
DO sigchk(); alarm(10); pause() OD
FI
IF parent
- THEN /* This is the parent branch of fork; */
+ ) { /* This is the parent branch of fork; */
/* it may or may not wait for the child. */
IF treeflgs&FPRS && flags&ttyflg
- THEN prn(parent); newline();
+ ) { prn(parent); newline();
FI
- IF treeflgs&FPCL THEN closepipe(pf1) FI
+ IF treeflgs&FPCL ) { closepipe(pf1) FI
IF (treeflgs&(FAMP|FPOU))==0
- THEN await(parent);
+ ) { await(parent);
} else if ( (treeflgs&FAMP)==0
- THEN post(parent);
+ ) { post(parent);
} else { assnum(&pcsadr, parent);
FI
/* except for those `lost' by trap */
oldsigs();
IF treeflgs&FINT
- THEN signal(INTR,1); signal(QUIT,1);
+ ) { signal(INTR,1); signal(QUIT,1);
FI
/* pipe in or out */
IF treeflgs&FPIN
- THEN sh_rename(pf1[INPIPE],0);
+ ) { sh_rename(pf1[INPIPE],0);
close(pf1[OTPIPE]);
FI
IF treeflgs&FPOU
- THEN sh_rename(pf2[OTPIPE],1);
+ ) { sh_rename(pf2[OTPIPE],1);
close(pf2[INPIPE]);
FI
/* default std input for & */
IF treeflgs&FINT && ioset==0
- THEN sh_rename(chkopen(devnull),0);
+ ) { sh_rename(chkopen(devnull),0);
FI
/* io redirection */
initio(t->treio);
IF type!=TCOM
- THEN execute(((FORKPTR)t)->forktre,1);
+ ) { execute(((FORKPTR)t)->forktre,1);
} else if ( com[0]!=ENDARGS
- THEN setlist(((COMPTR)t)->comset,N_EXPORT);
+ ) { setlist(((COMPTR)t)->comset,N_EXPORT);
execa(com);
FI
done();
{
INT pv[2]; chkpipe(pv);
IF execute(((LSTPTR)t)->lstlef, 0, pf1, pv)==0
- THEN execute(((LSTPTR)t)->lstrit, execflg, pv, pf2);
+ ) { execute(((LSTPTR)t)->lstrit, execflg, pv, pf2);
} else { closepipe(pv);
FI
}
case TAND:
IF execute(((LSTPTR)t)->lstlef,0)==0
- THEN execute(((LSTPTR)t)->lstrit,execflg);
+ ) { execute(((LSTPTR)t)->lstrit,execflg);
FI
break;
case TORF:
IF execute(((LSTPTR)t)->lstlef,0)!=0
- THEN execute(((LSTPTR)t)->lstrit,execflg);
+ ) { execute(((LSTPTR)t)->lstrit,execflg);
FI
break;
DOLPTR argsav=0;
IF ((FORPTR)t)->forlst==0
- THEN args=dolv+1;
+ ) { args=dolv+1;
argsav=useargs();
} else { ARGPTR schain=gchain;
gchain=0;
WHILE *args!=ENDARGS && execbrk==0
DO assign(n,*args++);
execute(((FORPTR)t)->fortre,0);
- IF execbrk<0 THEN execbrk=0 FI
+ IF execbrk<0 ) { execbrk=0 FI
OD
- IF breakcnt THEN breakcnt-- FI
+ IF breakcnt ) { breakcnt-- FI
execbrk=breakcnt; loopcnt--;
argfor=freeargs(argsav);
}
loopcnt++;
WHILE execbrk==0 && (execute(((WHPTR)t)->whtre,0)==0)==(type==TWH)
DO i=execute(((WHPTR)t)->dotre,0);
- IF execbrk<0 THEN execbrk=0 FI
+ IF execbrk<0 ) { execbrk=0 FI
OD
- IF breakcnt THEN breakcnt-- FI
+ IF breakcnt ) { breakcnt-- FI
execbrk=breakcnt; loopcnt--; exitval=i;
}
break;
case TIF:
IF execute(((IFPTR)t)->iftre,0)==0
- THEN execute(((IFPTR)t)->thtre,execflg);
+ ) { execute(((IFPTR)t)->thtre,execflg);
} else { execute(((IFPTR)t)->eltre,execflg);
FI
break;
WHILE rex
DO REG STRING s;
IF gmatch(r,s=macro(rex->argval)) || (trim(s), eq(r,s))
- THEN execute(((REGPTR)t)->regcom,0);
+ ) { execute(((REGPTR)t)->regcom,0);
t=0; break;
} else { rex=((ARGPTR)rex)->argnxt;
FI
OD
- IF t THEN t=(TREPTR)((REGPTR)t)->regnxt FI
+ IF t ) { t=(TREPTR)((REGPTR)t)->regnxt FI
OD
}
break;
FILEBLK fb;
push(&fb);
IF s
- THEN estabf(s); fb.feval=(STRING *)f;
+ ) { estabf(s); fb.feval=(STRING *)f;
} else if ( f>=0
- THEN initf(f);
+ ) { initf(f);
FI
execute(cmd(NL, NLFLG|MTFLG),0);
pop();
public / FUZIX.git / commitdiff