/*
* convert switch of the form
* switch v := i.(type) { case t1: ..; case t2: ..; }
* into if statements
*/
static void
typeswitch(Node *sw)
{
Node *def;
NodeList *cas, *hash;
Node *a, *n;
Case *c, *c0, *c1;
int ncase;
Type *t;
Val v;
if(sw->ntest == nil)
return;
if(sw->ntest->right == nil) {
setlineno(sw);
yyerror("type switch must have an assignment");
return;
}
walkexpr(&sw->ntest->right, &sw->ninit);
if(!istype(sw->ntest->right->type, TINTER)) {
yyerror("type switch must be on an interface");
return;
}
cas = nil;
/*
* predeclare temporary variables
* and the boolean var
*/
facename = temp(sw->ntest->right->type);
a = nod(OAS, facename, sw->ntest->right);
typecheck(&a, Etop);
cas = list(cas, a);
casebody(sw, facename);
boolname = temp(types[TBOOL]);
typecheck(&boolname, Erv);
hashname = temp(types[TUINT32]);
typecheck(&hashname, Erv);
t = sw->ntest->right->type;
if(isnilinter(t))
a = syslook("efacethash", 1);
else
a = syslook("ifacethash", 1);
argtype(a, t);
a = nod(OCALL, a, N);
a->list = list1(facename);
a = nod(OAS, hashname, a);
typecheck(&a, Etop);
cas = list(cas, a);
c0 = mkcaselist(sw, Stype);
if(c0 != C && c0->type == Tdefault) {
def = c0->node->right;
c0 = c0->link;
} else {
def = nod(OBREAK, N, N);
}
/*
* insert if statement into each case block
*/
for(c=c0; c!=C; c=c->link) {
n = c->node;
switch(c->type) {
case Ttypenil:
v.ctype = CTNIL;
a = nod(OIF, N, N);
a->ntest = nod(OEQ, facename, nodlit(v));
typecheck(&a->ntest, Erv);
a->nbody = list1(n->right); // if i==nil { goto l }
n->right = a;
break;
case Ttypevar:
case Ttypeconst:
n->right = typeone(n);
break;
}
}
/*
* generate list of if statements, binary search for constant sequences
*/
while(c0 != C) {
if(c0->type != Ttypeconst) {
n = c0->node;
cas = list(cas, n->right);
c0=c0->link;
continue;
}
// identify run of constants
c1 = c = c0;
while(c->link!=C && c->link->type==Ttypeconst)
c = c->link;
c0 = c->link;
c->link = nil;
// sort by hash
c1 = csort(c1, typecmp);
// for debugging: linear search
if(0) {
for(c=c1; c!=C; c=c->link) {
n = c->node;
cas = list(cas, n->right);
}
continue;
}
// combine adjacent cases with the same hash
ncase = 0;
for(c=c1; c!=C; c=c->link) {
ncase++;
hash = list1(c->node->right);
while(c->link != C && c->link->hash == c->hash) {
hash = list(hash, c->link->node->right);
c->link = c->link->link;
}
c->node->right = liststmt(hash);
}
// binary search among cases to narrow by hash
cas = list(cas, typebsw(c1, ncase));
}
if(nerrors == 0) {
cas = list(cas, def);
sw->nbody = concat(cas, sw->nbody);
sw->list = nil;
walkstmtlist(sw->nbody);
}
}
void
walkrange(Node *n)
{
Node *ohv1, *hv1, *hv2; // hidden (old) val 1, 2
Node *ha, *hit; // hidden aggregate, iterator
Node *hn, *hp; // hidden len, pointer
Node *hb; // hidden bool
Node *a, *v1, *v2; // not hidden aggregate, val 1, 2
Node *fn, *tmp;
NodeList *body, *init;
Type *th, *t;
int lno;
t = n->type;
init = nil;
a = n->right;
lno = setlineno(a);
if(t->etype == TSTRING && !eqtype(t, types[TSTRING])) {
a = nod(OCONV, n->right, N);
a->type = types[TSTRING];
}
v1 = n->list->n;
v2 = N;
if(n->list->next)
v2 = n->list->next->n;
hv2 = N;
if(v2 == N && t->etype == TARRAY) {
// will have just one reference to argument.
// no need to make a potentially expensive copy.
ha = a;
} else {
ha = temp(a->type);
init = list(init, nod(OAS, ha, a));
}
switch(t->etype) {
default:
fatal("walkrange");
case TARRAY:
hv1 = temp(types[TINT]);
hn = temp(types[TINT]);
hp = nil;
init = list(init, nod(OAS, hv1, N));
init = list(init, nod(OAS, hn, nod(OLEN, ha, N)));
if(v2) {
hp = temp(ptrto(n->type->type));
tmp = nod(OINDEX, ha, nodintconst(0));
tmp->etype = 1; // no bounds check
init = list(init, nod(OAS, hp, nod(OADDR, tmp, N)));
}
n->ntest = nod(OLT, hv1, hn);
n->nincr = nod(OASOP, hv1, nodintconst(1));
n->nincr->etype = OADD;
if(v2 == N)
body = list1(nod(OAS, v1, hv1));
else {
a = nod(OAS2, N, N);
a->list = list(list1(v1), v2);
a->rlist = list(list1(hv1), nod(OIND, hp, N));
body = list1(a);
tmp = nod(OADD, hp, nodintconst(t->type->width));
tmp->type = hp->type;
tmp->typecheck = 1;
tmp->right->type = types[tptr];
tmp->right->typecheck = 1;
body = list(body, nod(OAS, hp, tmp));
}
break;
case TMAP:
th = typ(TARRAY);
th->type = ptrto(types[TUINT8]);
// see ../../pkg/runtime/hashmap.h:/hash_iter
// Size in words.
th->bound = 5 + 4*3 + 4*4/widthptr;
hit = temp(th);
fn = syslook("mapiterinit", 1);
argtype(fn, t->down);
argtype(fn, t->type);
argtype(fn, th);
init = list(init, mkcall1(fn, T, nil, typename(t), ha, nod(OADDR, hit, N)));
n->ntest = nod(ONE, nod(OINDEX, hit, nodintconst(0)), nodnil());
fn = syslook("mapiternext", 1);
argtype(fn, th);
n->nincr = mkcall1(fn, T, nil, nod(OADDR, hit, N));
if(v2 == N) {
fn = syslook("mapiter1", 1);
argtype(fn, th);
argtype(fn, t->down);
a = nod(OAS, v1, mkcall1(fn, t->down, nil, nod(OADDR, hit, N)));
} else {
fn = syslook("mapiter2", 1);
argtype(fn, th);
argtype(fn, t->down);
argtype(fn, t->type);
a = nod(OAS2, N, N);
a->list = list(list1(v1), v2);
a->rlist = list1(mkcall1(fn, getoutargx(fn->type), nil, nod(OADDR, hit, N)));
}
body = list1(a);
break;
case TCHAN:
hv1 = temp(t->type);
hb = temp(types[TBOOL]);
n->ntest = nod(ONE, hb, nodbool(0));
a = nod(OAS2RECV, N, N);
a->typecheck = 1;
a->list = list(list1(hv1), hb);
a->rlist = list1(nod(ORECV, ha, N));
n->ntest->ninit = list1(a);
body = list1(nod(OAS, v1, hv1));
break;
case TSTRING:
ohv1 = temp(types[TINT]);
hv1 = temp(types[TINT]);
init = list(init, nod(OAS, hv1, N));
if(v2 == N)
a = nod(OAS, hv1, mkcall("stringiter", types[TINT], nil, ha, hv1));
else {
hv2 = temp(runetype);
a = nod(OAS2, N, N);
a->list = list(list1(hv1), hv2);
fn = syslook("stringiter2", 0);
a->rlist = list1(mkcall1(fn, getoutargx(fn->type), nil, ha, hv1));
}
n->ntest = nod(ONE, hv1, nodintconst(0));
n->ntest->ninit = list(list1(nod(OAS, ohv1, hv1)), a);
body = list1(nod(OAS, v1, ohv1));
if(v2 != N)
body = list(body, nod(OAS, v2, hv2));
break;
}
n->op = OFOR;
typechecklist(init, Etop);
n->ninit = concat(n->ninit, init);
typechecklist(n->ntest->ninit, Etop);
typecheck(&n->ntest, Erv);
typecheck(&n->nincr, Etop);
typechecklist(body, Etop);
n->nbody = concat(body, n->nbody);
walkstmt(&n);
lineno = lno;
}
/*
* convert switch of the form
* switch v := i.(type) { case t1: ..; case t2: ..; }
* into if statements
*/
void
typeswitch(Node *sw)
{
Node *def;
NodeList *cas;
Node *a;
Case *c, *c0, *c1;
int ncase;
Type *t;
if(sw->ntest == nil)
return;
if(sw->ntest->right == nil) {
setlineno(sw);
yyerror("type switch must have an assignment");
return;
}
walkexpr(&sw->ntest->right, &sw->ninit);
if(!istype(sw->ntest->right->type, TINTER)) {
yyerror("type switch must be on an interface");
return;
}
cas = nil;
/*
* predeclare temporary variables
* and the boolean var
*/
facename = nod(OXXX, N, N);
tempname(facename, sw->ntest->right->type);
a = nod(OAS, facename, sw->ntest->right);
typecheck(&a, Etop);
cas = list(cas, a);
casebody(sw, facename);
boolname = nod(OXXX, N, N);
tempname(boolname, types[TBOOL]);
typecheck(&boolname, Erv);
hashname = nod(OXXX, N, N);
tempname(hashname, types[TUINT32]);
typecheck(&hashname, Erv);
t = sw->ntest->right->type;
if(isnilinter(t))
a = syslook("efacethash", 1);
else
a = syslook("ifacethash", 1);
argtype(a, t);
a = nod(OCALL, a, N);
a->list = list1(facename);
a = nod(OAS, hashname, a);
typecheck(&a, Etop);
cas = list(cas, a);
c0 = mkcaselist(sw, Stype);
if(c0 != C && c0->type == Tdefault) {
def = c0->node->right;
c0 = c0->link;
} else {
def = nod(OBREAK, N, N);
}
loop:
if(c0 == C) {
cas = list(cas, def);
sw->nbody = concat(cas, sw->nbody);
sw->list = nil;
walkstmtlist(sw->nbody);
return;
}
// deal with the variables one-at-a-time
if(c0->type != Ttypeconst) {
a = typebsw(c0, 1);
cas = list(cas, a);
c0 = c0->link;
goto loop;
}
// do binary search on run of constants
ncase = 1;
for(c=c0; c->link!=C; c=c->link) {
if(c->link->type != Ttypeconst)
break;
ncase++;
}
// break the chain at the count
c1 = c->link;
c->link = C;
// sort and compile constants
c0 = csort(c0, typecmp);
a = typebsw(c0, ncase);
cas = list(cas, a);
c0 = c1;
goto loop;
}
int
word(void)
{
register unsigned int c, d, cc;
struct argnod *arg = (struct argnod *)locstak();
register unsigned char *argp = arg->argval;
unsigned char *oldargp;
int alpha = 1;
unsigned char *pc;
wdnum = 0;
wdset = 0;
while (1)
{
while (c = nextwc(), space(c)) /* skipc() */
;
if (c == COMCHAR)
{
while ((c = readwc()) != NL && c != EOF);
peekc = c;
}
else
{
break; /* out of comment - white space loop */
}
}
if (!eofmeta(c))
{
do
{
if (c == LITERAL)
{
oldargp = argp;
while ((c = readwc()) && c != LITERAL){
/*
* quote each character within
* single quotes
*/
pc = readw(c);
if (argp >= brkend)
growstak(argp);
*argp++='\\';
/* Pick up rest of multibyte character */
if (c == NL)
chkpr();
while (c = *pc++) {
if (argp >= brkend)
growstak(argp);
*argp++ = (unsigned char)c;
}
}
if (argp == oldargp) { /* null argument - '' */
/*
* Word will be represented by quoted null
* in macro.c if necessary
*/
if (argp >= brkend)
growstak(argp);
*argp++ = '"';
if (argp >= brkend)
growstak(argp);
*argp++ = '"';
}
}
else
{
if (c == 0) {
if (argp >= brkend)
growstak(argp);
*argp++ = 0;
} else {
pc = readw(c);
while (*pc) {
if (argp >= brkend)
growstak(argp);
*argp++ = *pc++;
}
}
if (c == '\\') {
if ((cc = readwc()) == 0) {
if (argp >= brkend)
growstak(argp);
*argp++ = 0;
} else {
pc = readw(cc);
while (*pc) {
if (argp >= brkend)
growstak(argp);
*argp++ = *pc++;
}
}
}
if (c == '=')
wdset |= alpha;
if (!alphanum(c))
alpha = 0;
if (qotchar(c))
{
d = c;
for (;;)
{
if ((c = nextwc()) == 0) {
if (argp >= brkend)
growstak(argp);
*argp++ = 0;
} else {
pc = readw(c);
while (*pc) {
if (argp >= brkend)
growstak(argp);
*argp++ = *pc++;
}
}
if (c == 0 || c == d)
break;
if (c == NL)
chkpr();
/*
* don't interpret quoted
* characters
*/
if (c == '\\') {
if ((cc = readwc()) == 0) {
if (argp >= brkend)
growstak(argp);
*argp++ = 0;
} else {
pc = readw(cc);
while (*pc) {
if (argp >= brkend)
growstak(argp);
*argp++ = *pc++;
}
}
}
}
}
}
} while ((c = nextwc(), !eofmeta(c)));
argp = endstak(argp);
if (!letter(arg->argval[0]))
wdset = 0;
peekn = c | MARK;
if (arg->argval[1] == 0 &&
(d = arg->argval[0], digit(d)) &&
(c == '>' || c == '<'))
{
word();
wdnum = d - '0';
}else{ /* check for reserved words */
if (reserv == FALSE ||
(wdval = syslook(arg->argval,
reserved, no_reserved)) == 0) {
wdval = 0;
}
/* set arg for reserved words too */
wdarg = arg;
}
}else if (dipchar(c)){
if ((d = nextwc()) == c)
{
wdval = c | SYMREP;
if (c == '<')
{
if ((d = nextwc()) == '-')
wdnum |= IOSTRIP;
else
peekn = d | MARK;
}
}
else
{
peekn = d | MARK;
wdval = c;
}
}
else
{
if ((wdval = c) == EOF)
wdval = EOFSYM;
if (iopend && eolchar(c))
{
struct ionod *tmp_iopend;
tmp_iopend = iopend;
iopend = 0;
copy(tmp_iopend);
}
}
reserv = FALSE;
return (wdval);
}
void
walkrange(Node *n)
{
Node *ohv1, *hv1, *hv2; // hidden (old) val 1, 2
Node *ha, *hit; // hidden aggregate, iterator
Node *a, *v1, *v2; // not hidden aggregate, val 1, 2
Node *fn;
NodeList *body, *init;
Type *th, *t;
t = n->type;
init = nil;
a = n->right;
if(t->etype == TSTRING && !eqtype(t, types[TSTRING])) {
a = nod(OCONV, n->right, N);
a->type = types[TSTRING];
}
ha = nod(OXXX, N, N);
tempname(ha, a->type);
init = list(init, nod(OAS, ha, a));
v1 = n->list->n;
hv1 = N;
v2 = N;
if(n->list->next)
v2 = n->list->next->n;
hv2 = N;
switch(t->etype) {
default:
fatal("walkrange");
case TARRAY:
hv1 = nod(OXXX, N, n);
tempname(hv1, types[TINT]);
init = list(init, nod(OAS, hv1, N));
n->ntest = nod(OLT, hv1, nod(OLEN, ha, N));
n->nincr = nod(OASOP, hv1, nodintconst(1));
n->nincr->etype = OADD;
body = list1(nod(OAS, v1, hv1));
if(v2)
body = list(body, nod(OAS, v2, nod(OINDEX, ha, hv1)));
break;
case TMAP:
th = typ(TARRAY);
th->type = ptrto(types[TUINT8]);
th->bound = (sizeof(struct Hiter) + widthptr - 1) / widthptr;
hit = nod(OXXX, N, N);
tempname(hit, th);
fn = syslook("mapiterinit", 1);
argtype(fn, t->down);
argtype(fn, t->type);
argtype(fn, th);
init = list(init, mkcall1(fn, T, nil, ha, nod(OADDR, hit, N)));
n->ntest = nod(ONE, nod(OINDEX, hit, nodintconst(0)), nodnil());
fn = syslook("mapiternext", 1);
argtype(fn, th);
n->nincr = mkcall1(fn, T, nil, nod(OADDR, hit, N));
if(v2 == N) {
fn = syslook("mapiter1", 1);
argtype(fn, th);
argtype(fn, t->down);
a = nod(OAS, v1, mkcall1(fn, t->down, nil, nod(OADDR, hit, N)));
} else {
fn = syslook("mapiter2", 1);
argtype(fn, th);
argtype(fn, t->down);
argtype(fn, t->type);
a = nod(OAS2, N, N);
a->list = list(list1(v1), v2);
a->rlist = list1(mkcall1(fn, getoutargx(fn->type), nil, nod(OADDR, hit, N)));
}
body = list1(a);
break;
case TCHAN:
hv1 = nod(OXXX, N, n);
tempname(hv1, t->type);
n->ntest = nod(ONOT, nod(OCLOSED, ha, N), N);
n->ntest->ninit = list1(nod(OAS, hv1, nod(ORECV, ha, N)));
body = list1(nod(OAS, v1, hv1));
break;
case TSTRING:
ohv1 = nod(OXXX, N, N);
tempname(ohv1, types[TINT]);
hv1 = nod(OXXX, N, N);
tempname(hv1, types[TINT]);
init = list(init, nod(OAS, hv1, N));
if(v2 == N)
a = nod(OAS, hv1, mkcall("stringiter", types[TINT], nil, ha, hv1));
else {
hv2 = nod(OXXX, N, N);
tempname(hv2, types[TINT]);
a = nod(OAS2, N, N);
a->list = list(list1(hv1), hv2);
fn = syslook("stringiter2", 0);
a->rlist = list1(mkcall1(fn, getoutargx(fn->type), nil, ha, hv1));
}
n->ntest = nod(ONE, hv1, nodintconst(0));
n->ntest->ninit = list(list1(nod(OAS, ohv1, hv1)), a);
body = list1(nod(OAS, v1, ohv1));
if(v2 != N)
body = list(body, nod(OAS, v2, hv2));
break;
}
n->op = OFOR;
typechecklist(init, Etop);
n->ninit = concat(n->ninit, init);
typechecklist(n->ntest->ninit, Etop);
typecheck(&n->ntest, Erv);
typecheck(&n->nincr, Etop);
typechecklist(body, Etop);
n->nbody = concat(body, n->nbody);
walkstmt(&n);
}
int execute(TREPTR argt, int execflg, int *pf1, int *pf2)
{
/* `stakbot' is preserved by this routine */
register TREPTR t;
STKPTR sav = savstak();
sigchk();
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) {
case TCOM:
{
STRING a1;
int argn, internal;
ARGPTR schain = gchain;
IOPTR io = t->treio;
gchain = 0;
argn = getarg((void *)t);/*FIXME*/
com = scan(argn);
a1 = com[1];
gchain = schain;
if ((internal = syslook(com[0], commands)) || argn == 0)
setlist(((COMPTR) t)->comset, 0);
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();
}
switch (internal) {
case SYSDOT:
if (a1) {
register int f;
if ((f = pathopen(getpath(a1), a1)) < 0)
failed(a1, notfound);
else
execexp(0, f);
}
break;
case SYSTIMES:
{
struct tms t;
times(&t);
prt(t.tms_cutime);
blank();
prt(t.tms_cstime);
newline();
}
break;
case SYSEXIT:
exitsh(a1 ? stoi(a1) : oldexit);
case SYSNULL:
io = 0;
break;
case SYSCONT:
execbrk = -loopcnt;
break;
case SYSBREAK:
if ((execbrk = loopcnt) && a1)
breakcnt = stoi(a1);
break;
case SYSTRAP:
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++) {
if (trapcom[i]) {
prn(i);
prs(colon);
prs(trapcom[i]);
newline();
}
}
}
break;
case SYSEXEC:
com++;
initio(io);
ioset = 0;
io = 0;
if (a1 == 0)
break;
case SYSLOGIN:
flags |= forked;
oldsigs();
execa((const char **)com);
done();
case SYSCD:
if (flags & rshflg)
failed(com[0], restricted);
else if ((a1 == 0 && (a1 = (char *)homenod.namval) == 0) || chdir(a1) < 0) /* FIXME */
failed(a1, baddir);
break;
case SYSSHFT:
if (dolc < 1)
error(badshift);
else {
dolv++;
dolc--;
}
assnum(&dolladr, dolc);
break;
case SYSWAIT:
await(-1);
break;
case SYSREAD:
exitval = readvar(&com[1]);
break;
/*
case SYSTST:
exitval=testcmd(com);
break;
*/
case SYSSET:
if (a1) {
int argc;
argc = options(argn, (const char **)com);
if (argc > 1)
setargs((const char **)com + argn - argc);
} else if (((COMPTR) t)->comset == 0)
/* Scan name chain and print */
namscan(printnam);
break;
case SYSRDONLY:
exitval = N_RDONLY;
case SYSXPORT:
if (exitval == 0)
exitval = N_EXPORT;;
if (a1) {
while (*++com)
attrib(lookup(*com), exitval);
} else {
namscan(printflg);
}
exitval = 0;
break;
case SYSEVAL:
if (a1)
execexp(a1, (UFD)&com[2]); /* FIXME */
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);
}
if (internal) {
if (io)
error(illegal);
chktrap();
break;
}
} else if (t->treio == 0)
break;
}
case TFORK:
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 && 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 */
flags |= forked;
iotemp = 0;
postclr();
settmp();
/* Turn off INTR and QUIT if `FINT' */
/* Reset ramaining signals to parent */
/* except for those `lost' by trap */
oldsigs();
if (treeflgs & FINT) {
signal(INTR, SIG_IGN);
signal(QUIT, SIG_IGN);
}
/* pipe in or out */
if (treeflgs & FPIN) {
sh_rename(pf1[INPIPE], 0);
close(pf1[OTPIPE]);
}
if (treeflgs & FPOU) {
sh_rename(pf2[OTPIPE], 1);
close(pf2[INPIPE]);
}
/* default std input for & */
if (treeflgs & FINT && ioset == 0)
sh_rename(chkopen(devnull), 0);
/* io redirection */
initio(t->treio);
if (type != TCOM)
execute(((FORKPTR) t)->forktre, 1, NULL, NULL);
else if (com[0] != ENDARGS) {
setlist(((COMPTR) t)->comset, N_EXPORT);
execa((const char **)com);
}
done();
}
case TPAR:
sh_rename(dup(2), output);
execute(((PARPTR) t)->partre, execflg, NULL, NULL);
done();
case TFIL:
{
int pv[2];
chkpipe(pv);
if (execute(((LSTPTR) t)->lstlef, 0, pf1, pv) == 0)
execute(((LSTPTR) t)->lstrit, execflg, pv, pf2);
else
closepipe(pv);
break;
}
case TLST:
execute(((LSTPTR) t)->lstlef, 0, NULL, NULL);
execute(((LSTPTR) t)->lstrit, execflg, NULL, NULL);
break;
case TAND:
if (execute(((LSTPTR) t)->lstlef, 0, NULL, NULL) == 0)
execute(((LSTPTR) t)->lstrit, execflg, NULL, NULL);
break;
case TORF:
if (execute(((LSTPTR) t)->lstlef, 0, NULL, NULL) != 0)
execute(((LSTPTR) t)->lstrit, execflg, NULL, NULL);
break;
case TFOR:
{
NAMPTR n = lookup(((FORPTR) t)->fornam);
char **args;
DOLPTR argsav = 0;
if (((FORPTR) t)->forlst == 0) {
args = (char **)dolv + 1;
argsav = useargs();
} else {
ARGPTR schain = gchain;
gchain = 0;
trim((args = scan(getarg(((FORPTR) t)->forlst)))[0]);
gchain = schain;
}
loopcnt++;
while (*args != ENDARGS && execbrk == 0) {
assign(n, *args++);
execute(((FORPTR) t)->fortre, 0, NULL, NULL);
if (execbrk < 0) {
execbrk = 0;
}
}
if (breakcnt)
breakcnt--;
execbrk = breakcnt;
loopcnt--;
argfor = freeargs(argsav);
break;
}
case TWH:
case TUN:
{
int i = 0;
loopcnt++;
while (execbrk == 0 && (execute(((WHPTR) t)->whtre, 0, NULL, NULL) == 0) == (type == TWH)) {
i = execute(((WHPTR) t)->dotre, 0, NULL, NULL);
if (execbrk < 0)
execbrk = 0;
}
if (breakcnt)
breakcnt--;
execbrk = breakcnt;
loopcnt--;
exitval = i;
break;
}
case TIF:
if (execute(((IFPTR) t)->iftre, 0, NULL, NULL) == 0)
execute(((IFPTR) t)->thtre, execflg, NULL, NULL);
else
execute(((IFPTR) t)->eltre, execflg, NULL, NULL);
break;
case TSW:
{
register char *r = mactrim(((SWPTR) t)->swarg);
t = (TREPTR) ((SWPTR) t)->swlst;
while (t) {
ARGPTR rex = ((REGPTR) t)->regptr;
while (rex) {
register char *s;
if (gmatch(r, s = macro(rex->argval)) || (trim(s), eq(r, s))) {
execute(((REGPTR)t)->regcom, 0, NULL, NULL);
t = 0;
break;
} else
rex = ((ARGPTR)rex)->argnxt;
}
if (t)
t = (TREPTR) ((REGPTR) t)->regnxt;
}
}
break;
}
exitset();
}
int word(void)
{
register char c, d;
register char *argp = locstak() + BYTESPERWORD;
int alpha = 1;
wdnum = 0;
wdset = 0;
while (1)
{
while (c = nextc(0), space(c)) /* skipc() */
;
if (c == COMCHAR)
{
while ((c = readc()) != NL && c != EOF);
peekc = c;
}
else
{
break; /* out of comment - white space loop */
}
}
if (!eofmeta(c)) {
do {
if (c == LITERAL) {
*argp++ = (DQUOTE);
while ((c = readc()) && c != LITERAL) {
*argp++ = (c | QUOTE);
chkpr(c);
}
*argp++ = (DQUOTE);
} else {
*argp++ = (c);
if (c == '=')
wdset |= alpha;
if (!alphanum(c))
alpha = 0;
if (qotchar(c)) {
d = c;
while ((*argp++ = (c = nextc(d))) && c != d)
chkpr(c);
}
}
} while ((c = nextc(0), !eofmeta(c)));
argp = endstak(argp);
if (!letter(((ARGPTR) argp)->argval[0]))
wdset = 0;
peekc = c | MARK;
if (((ARGPTR) argp)->argval[1] == 0
&& (d = ((ARGPTR) argp)->argval[0], digit(d))
&& (c == '>' || c == '<')) {
word();
wdnum = d - '0';
} else { /*check for reserved words */
if (reserv == FALSE
|| (wdval = syslook(((ARGPTR) argp)->argval, reserved)) == 0) {
wdarg = (ARGPTR) argp;
wdval = 0;
}
}
} else if (dipchar(c)) {
if ((d = nextc(0)) == c)
wdval = c | SYMREP;
else {
peekc = d | MARK;
wdval = c;
}
} else {
if ((wdval = c) == EOF)
wdval = EOFSYM;
if (iopend && eolchar(c)) {
copy(iopend);
iopend = 0;
}
}
reserv = FALSE;
return wdval;
}
void
fninit(NodeList *n)
{
int i;
Node *gatevar;
Node *a, *b, *fn;
NodeList *r;
uint32 h;
Sym *s, *initsym;
if(debug['A']) {
// sys.go or unsafe.go during compiler build
return;
}
n = initfix(n);
if(!anyinit(n))
return;
r = nil;
// (1)
snprint(namebuf, sizeof(namebuf), "initdone·");
gatevar = newname(lookup(namebuf));
addvar(gatevar, types[TUINT8], PEXTERN);
// (2)
maxarg = 0;
snprint(namebuf, sizeof(namebuf), "init");
fn = nod(ODCLFUNC, N, N);
initsym = lookup(namebuf);
fn->nname = newname(initsym);
fn->nname->defn = fn;
fn->nname->ntype = nod(OTFUNC, N, N);
declare(fn->nname, PFUNC);
funchdr(fn);
// (3)
a = nod(OIF, N, N);
a->ntest = nod(ONE, gatevar, nodintconst(0));
r = list(r, a);
// (4)
b = nod(OIF, N, N);
b->ntest = nod(OEQ, gatevar, nodintconst(2));
b->nbody = list1(nod(ORETURN, N, N));
a->nbody = list1(b);
// (5)
b = syslook("throwinit", 0);
b = nod(OCALL, b, N);
a->nbody = list(a->nbody, b);
// (6)
a = nod(OAS, gatevar, nodintconst(1));
r = list(r, a);
// (7)
for(h=0; h<NHASH; h++)
for(s = hash[h]; s != S; s = s->link) {
if(s->name[0] != 'i' || strcmp(s->name, "init") != 0)
continue;
if(s->def == N)
continue;
if(s == initsym)
continue;
// could check that it is fn of no args/returns
a = nod(OCALL, s->def, N);
r = list(r, a);
}
// (8)
r = concat(r, n);
// (9)
// could check that it is fn of no args/returns
for(i=1;; i++) {
snprint(namebuf, sizeof(namebuf), "init·%d", i);
s = lookup(namebuf);
if(s->def == N)
break;
a = nod(OCALL, s->def, N);
r = list(r, a);
}
// (10)
a = nod(OAS, gatevar, nodintconst(2));
r = list(r, a);
// (11)
a = nod(ORETURN, N, N);
r = list(r, a);
exportsym(fn->nname);
fn->nbody = r;
funcbody(fn);
curfn = fn;
typecheck(&fn, Etop);
typechecklist(r, Etop);
curfn = nil;
funccompile(fn, 0);
}
