static List *backq(Node *ifs, Node *n) {
int p[2], sp;
pid_t pid;
List *bq;
struct termios t;
if (n == NULL)
return NULL;
if (pipe(p) < 0) {
uerror("pipe");
rc_error(NULL);
}
if (interactive)
tcgetattr(0, &t);
if ((pid = rc_fork()) == 0) {
mvfd(p[1], 1);
close(p[0]);
redirq = NULL;
walk(n, FALSE);
exit(getstatus());
}
close(p[1]);
bq = bqinput(glom(ifs), p[0]);
close(p[0]);
rc_wait4(pid, &sp, TRUE);
if (interactive && WIFSIGNALED(sp))
tcsetattr(0, TCSANOW, &t);
statprint(-1, sp);
varassign("bqstatus", word(strstatus(sp), NULL), FALSE);
sigchk();
return bq;
}
/* walk -- walk through a tree, evaluating nodes */
extern List *walk(Tree *tree0, Binding *binding0, int flags) {
Tree *volatile tree = tree0;
Binding *volatile binding = binding0;
SIGCHK();
top:
if (tree == NULL)
return true;
switch (tree->kind) {
case nConcat: case nList: case nQword: case nVar: case nVarsub:
case nWord: case nThunk: case nLambda: case nCall: case nPrim: {
List *list;
Ref(Binding *, bp, binding);
list = glom(tree, binding, TRUE);
binding = bp;
RefEnd(bp);
return eval(list, binding, flags);
}
case nAssign:
return assign(tree->u[0].p, tree->u[1].p, binding);
case nLet: case nClosure:
Ref(Tree *, body, tree->u[1].p);
binding = letbindings(tree->u[0].p, binding, binding, flags);
tree = body;
RefEnd(body);
goto top;
case nLocal:
return local(tree->u[0].p, tree->u[1].p, binding, flags);
case nFor:
return forloop(tree->u[0].p, tree->u[1].p, binding, flags);
case nMatch:
return matchpattern(tree->u[0].p, tree->u[1].p, binding);
case nExtract:
return extractpattern(tree->u[0].p, tree->u[1].p, binding);
default:
panic("walk: bad node kind %d", tree->kind);
}
NOTREACHED;
}
extern void doredirs() {
List *fname;
int fd, p[2];
Rq *r;
for (r = redirq; r != NULL; r = r->n) {
switch(r->r->type) {
default:
panic("unexpected node in doredirs");
/* NOTREACHED */
case nRedir:
if (r->r->u[0].i == rHerestring) {
fname = flatten(glom(r->r->u[2].p)); /* fname is really a string */
if (pipe(p) < 0) {
uerror("pipe");
rc_error(NULL);
}
if (rc_fork() == 0) { /* child writes to pipe */
setsigdefaults(FALSE);
close(p[0]);
if (fname != NULL)
writeall(p[1], fname->w, strlen(fname->w));
exit(0);
} else {
close(p[1]);
if (mvfd(p[0], r->r->u[1].i) < 0)
rc_error(NULL);
}
} else {
fname = glob(glom(r->r->u[2].p));
if (fname == NULL)
rc_error("null filename in redirection");
if (fname->n != NULL)
rc_error("multi-word filename in redirection");
switch (r->r->u[0].i) {
default:
panic("unexpected node in doredirs");
/* NOTREACHED */
case rCreate: case rAppend: case rFrom:
fd = rc_open(fname->w, r->r->u[0].i);
break;
}
if (fd < 0) {
uerror(fname->w);
rc_error(NULL);
}
if (mvfd(fd, r->r->u[1].i) < 0)
rc_error(NULL);
}
break;
case nDup:
if (r->r->u[2].i == -1)
close(r->r->u[1].i);
else if (r->r->u[2].i != r->r->u[1].i) {
if (dup2(r->r->u[2].i, r->r->u[1].i) < 0) {
uerror("dup2");
rc_error(NULL);
}
}
}
}
redirq = NULL;
}
extern List *glom(Node *n) {
List *v, *head, *tail;
Node *words;
if (n == NULL)
return NULL;
switch (n->type) {
case nArgs:
case nLappend:
words = n->u[0].p;
tail = NULL;
while (words != NULL && (words->type == nArgs || words->type == nLappend)) {
if (words->u[1].p != NULL && words->u[1].p->type != nWord)
break;
head = glom(words->u[1].p);
if (head != NULL) {
head->n = tail;
tail = head;
}
words = words->u[0].p;
}
v = append(glom(words), tail); /* force left to right evaluation */
return append(v, glom(n->u[1].p));
case nBackq:
return backq(n->u[0].p, n->u[1].p);
case nConcat:
head = glom(n->u[0].p); /* force left-to-right evaluation */
return concat(head, glom(n->u[1].p));
case nDup:
case nRedir:
qredir(n);
return NULL;
case nWord:
return word(n->u[0].s, n->u[1].s);
case nNmpipe:
return mkcmdarg(n);
default:
/*
The next four operations depend on the left-child of glom
to be a variable name. Therefore the variable is looked up
here.
*/
if ((v = glom(n->u[0].p)) == NULL)
rc_error("null variable name");
if (v->n != NULL)
rc_error("multi-word variable name");
if (*v->w == '\0')
rc_error("zero-length variable name");
v = (*v->w == '*' && v->w[1] == '\0') ? varlookup(v->w)->n : varlookup(v->w);
switch (n->type) {
default:
panic("unexpected node in glom");
exit(1);
/* NOTREACHED */
case nCount:
return count(v);
case nFlat:
return flatten(v);
case nVar:
return v;
case nVarsub:
return varsub(v, glom(n->u[1].p));
}
}
}
/* eval -- evaluate a list, producing a list */
extern List *eval(List *list0, Binding *binding0, int flags) {
Closure *volatile cp;
List *fn;
if (++evaldepth >= maxevaldepth)
fail("es:eval", "max-eval-depth exceeded");
Ref(List *, list, list0);
Ref(Binding *, binding, binding0);
Ref(char *, funcname, NULL);
restart:
if (list == NULL) {
RefPop3(funcname, binding, list);
--evaldepth;
return true;
}
assert(list->term != NULL);
if ((cp = getclosure(list->term)) != NULL) {
switch (cp->tree->kind) {
case nPrim:
assert(cp->binding == NULL);
list = prim(cp->tree->u[0].s, list->next, binding, flags);
break;
case nThunk:
list = walk(cp->tree->u[0].p, cp->binding, flags);
break;
case nLambda:
ExceptionHandler
Push p;
Ref(Tree *, tree, cp->tree);
Ref(Binding *, context,
bindargs(tree->u[0].p,
list->next,
cp->binding));
if (funcname != NULL)
varpush(&p, "0",
mklist(mkterm(funcname,
NULL),
NULL));
list = walk(tree->u[1].p, context, flags);
if (funcname != NULL)
varpop(&p);
RefEnd2(context, tree);
CatchException (e)
if (termeq(e->term, "return")) {
list = e->next;
goto done;
}
throw(e);
EndExceptionHandler
break;
case nList: {
list = glom(cp->tree, cp->binding, TRUE);
list = append(list, list->next);
goto restart;
}
default:
panic("eval: bad closure node kind %d",
cp->tree->kind);
}
goto done;
}
/* the logic here is duplicated in $&whatis */
Ref(char *, name, getstr(list->term));
fn = varlookup2("fn-", name, binding);
if (fn != NULL) {
funcname = name;
list = append(fn, list->next);
RefPop(name);
goto restart;
}
if (isabsolute(name)) {
char *error = checkexecutable(name);
if (error != NULL)
fail("$&whatis", "%s: %s", name, error);
list = forkexec(name, list, flags & eval_inchild);
RefPop(name);
goto done;
}
RefEnd(name);
fn = pathsearch(list->term);
if (fn != NULL && fn->next == NULL
&& (cp = getclosure(fn->term)) == NULL) {
char *name = getstr(fn->term);
list = forkexec(name, list, flags & eval_inchild);
goto done;
}
list = append(fn, list->next);
goto restart;
done:
--evaldepth;
if ((flags & eval_exitonfalse) && !istrue(list))
exit(exitstatus(list));
RefEnd2(funcname, binding);
RefReturn(list);
}
extern bool walk(Node *n, bool parent) {
top: sigchk();
if (n == NULL) {
if (!parent)
exit(0);
set(TRUE);
return TRUE;
}
switch (n->type) {
case nArgs: case nBackq: case nConcat: case nCount:
case nFlat: case nLappend: case nRedir: case nVar:
case nVarsub: case nWord:
exec(glob(glom(n)), parent); /* simple command */
break;
case nBody:
walk(n->u[0].p, TRUE);
WALK(n->u[1].p, parent);
/* WALK doesn't fall through */
case nNowait: {
int pid;
if ((pid = rc_fork()) == 0) {
#if defined(RC_JOB) && defined(SIGTTOU) && defined(SIGTTIN) && defined(SIGTSTP)
setsigdefaults(FALSE);
rc_signal(SIGTTOU, SIG_IGN); /* Berkeleyized version: put it in a new pgroup. */
rc_signal(SIGTTIN, SIG_IGN);
rc_signal(SIGTSTP, SIG_IGN);
setpgid(0, getpid());
#else
setsigdefaults(TRUE); /* ignore SIGINT, SIGQUIT, SIGTERM */
#endif
mvfd(rc_open("/dev/null", rFrom), 0);
walk(n->u[0].p, FALSE);
exit(getstatus());
}
if (interactive)
fprint(2, "%d\n", pid);
varassign("apid", word(nprint("%d", pid), NULL), FALSE);
redirq = NULL; /* kill pre-redir queue */
break;
}
case nAndalso: {
bool oldcond = cond;
cond = TRUE;
if (walk(n->u[0].p, TRUE)) {
cond = oldcond;
WALK(n->u[1].p, parent);
} else
cond = oldcond;
break;
}
case nOrelse: {
bool oldcond = cond;
cond = TRUE;
if (!walk(n->u[0].p, TRUE)) {
cond = oldcond;
WALK(n->u[1].p, parent);
} else
cond = oldcond;
break;
}
case nBang:
set(!walk(n->u[0].p, TRUE));
break;
case nIf: {
bool oldcond = cond;
Node *true_cmd = n->u[1].p, *false_cmd = NULL;
if (true_cmd != NULL && true_cmd->type == nElse) {
false_cmd = true_cmd->u[1].p;
true_cmd = true_cmd->u[0].p;
}
cond = TRUE;
if (!walk(n->u[0].p, TRUE))
true_cmd = false_cmd; /* run the else clause */
cond = oldcond;
WALK(true_cmd, parent);
}
case nWhile: {
Jbwrap j;
Edata jbreak;
Estack e1, e2;
bool testtrue, oldcond = cond;
cond = TRUE;
if (!walk(n->u[0].p, TRUE)) { /* prevent spurious breaks inside test */
cond = oldcond;
break;
}
if (sigsetjmp(j.j, 1))
break;
jbreak.jb = &j;
except(eBreak, jbreak, &e1);
do {
Edata block;
block.b = newblock();
cond = oldcond;
except(eArena, block, &e2);
walk(n->u[1].p, TRUE);
testtrue = walk(n->u[0].p, TRUE);
unexcept(); /* eArena */
cond = TRUE;
} while (testtrue);
cond = oldcond;
unexcept(); /* eBreak */
break;
}
case nForin: {
List *l, *var = glom(n->u[0].p);
Jbwrap j;
Estack e1, e2;
Edata jbreak;
if (sigsetjmp(j.j, 1))
break;
jbreak.jb = &j;
except(eBreak, jbreak, &e1);
for (l = listcpy(glob(glom(n->u[1].p)), nalloc); l != NULL; l = l->n) {
Edata block;
assign(var, word(l->w, NULL), FALSE);
block.b = newblock();
except(eArena, block, &e2);
walk(n->u[2].p, TRUE);
unexcept(); /* eArena */
}
unexcept(); /* eBreak */
break;
}
case nSubshell:
if (dofork(TRUE)) {
setsigdefaults(FALSE);
walk(n->u[0].p, FALSE);
rc_exit(getstatus());
}
break;
case nAssign:
if (n->u[0].p == NULL)
rc_error("null variable name");
assign(glom(n->u[0].p), glob(glom(n->u[1].p)), FALSE);
set(TRUE);
break;
case nPipe:
dopipe(n);
break;
case nNewfn: {
List *l = glom(n->u[0].p);
if (l == NULL)
rc_error("null function name");
while (l != NULL) {
if (dashex)
prettyprint_fn(2, l->w, n->u[1].p);
fnassign(l->w, n->u[1].p);
l = l->n;
}
set(TRUE);
break;
}
case nRmfn: {
List *l = glom(n->u[0].p);
while (l != NULL) {
if (dashex)
fprint(2, "fn %S\n", l->w);
fnrm(l->w);
l = l->n;
}
set(TRUE);
break;
}
case nDup:
redirq = NULL;
break; /* Null command */
case nMatch: {
List *a = glob(glom(n->u[0].p)), *b = glom(n->u[1].p);
if (dashex)
fprint(2, (a != NULL && a->n != NULL) ? "~ (%L) %L\n" : "~ %L %L\n", a, " ", b, " ");
set(lmatch(a, b));
break;
}
case nSwitch: {
List *v = glom(n->u[0].p);
while (1) {
do {
n = n->u[1].p;
if (n == NULL)
return istrue();
} while (n->u[0].p == NULL || n->u[0].p->type != nCase);
if (lmatch(v, glom(n->u[0].p->u[0].p))) {
for (n = n->u[1].p; n != NULL && (n->u[0].p == NULL || n->u[0].p->type != nCase); n = n->u[1].p)
walk(n->u[0].p, TRUE);
break;
}
}
break;
}
case nPre: {
List *v;
if (n->u[0].p->type == nRedir || n->u[0].p->type == nDup) {
if (redirq == NULL && !dofork(parent)) /* subshell on first preredir */
break;
setsigdefaults(FALSE);
qredir(n->u[0].p);
if (!haspreredir(n->u[1].p))
doredirs(); /* no more preredirs, empty queue */
walk(n->u[1].p, FALSE);
rc_exit(getstatus());
/* NOTREACHED */
} else if (n->u[0].p->type == nAssign) {
if (isallpre(n->u[1].p)) {
walk(n->u[0].p, TRUE);
WALK(n->u[1].p, parent);
} else {
Estack e;
Edata var;
v = glom(n->u[0].p->u[0].p);
assign(v, glob(glom(n->u[0].p->u[1].p)), TRUE);
var.name = v->w;
except(eVarstack, var, &e);
walk(n->u[1].p, parent);
varrm(v->w, TRUE);
unexcept(); /* eVarstack */
}
} else
panic("unexpected node in preredir section of walk");
break;
}
case nBrace:
if (n->u[1].p == NULL) {
WALK(n->u[0].p, parent);
} else if (dofork(parent)) {
setsigdefaults(FALSE);
walk(n->u[1].p, TRUE); /* Do redirections */
redirq = NULL; /* Reset redirection queue */
walk(n->u[0].p, FALSE); /* Do commands */
rc_exit(getstatus());
/* NOTREACHED */
}
break;
case nEpilog:
qredir(n->u[0].p);
if (n->u[1].p != NULL) {
WALK(n->u[1].p, parent); /* Do more redirections. */
} else {
doredirs(); /* Okay, we hit the bottom. */
}
break;
case nNmpipe:
rc_error("named pipes cannot be executed as commands");
/* NOTREACHED */
default:
panic("unknown node in walk");
/* NOTREACHED */
}
return istrue();
}
