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