ref: 7a503757b1251c2746df7bdcd891814c1518cc28
dir: /sys/src/cmd/rc/exec.c/
#include "rc.h"
#include "getflags.h"
#include "exec.h"
#include "io.h"
#include "fns.h"
char *argv0="rc";
io *err;
int mypid;
thread *runq;
/*
* Start executing the given code at the given pc with the given redirection
*/
void
start(code *c, int pc, var *local, redir *redir)
{
thread *p = new(thread);
p->code = codecopy(c);
p->line = 0;
p->pc = pc;
p->argv = 0;
p->redir = p->startredir = redir;
p->lex = 0;
p->local = local;
p->iflag = 0;
p->pid = 0;
p->status = 0;
p->ret = runq;
runq = p;
}
void
startfunc(var *func, word *starval, var *local, redir *redir)
{
start(func->fn, func->pc, local, redir);
runq->local = newvar("*", runq->local);
runq->local->val = starval;
runq->local->changed = 1;
}
static void
popthread(void)
{
thread *p = runq;
while(p->argv) poplist();
while(p->local && (p->ret==0 || p->local!=p->ret->local))
Xunlocal();
runq = p->ret;
if(p->lex) freelexer(p->lex);
codefree(p->code);
free(p->status);
free(p);
}
word*
Newword(char *s, word *next)
{
word *p=new(word);
p->word = s;
p->next = next;
return p;
}
word*
newword(char *s, word *next)
{
return Newword(estrdup(s), next);
}
word*
Pushword(char *s)
{
word *p;
if(s==0)
panic("null pushword", 0);
if(runq->argv==0)
panic("pushword but no argv!", 0);
p = Newword(s, runq->argv->words);
runq->argv->words = p;
return p;
}
word*
pushword(char *s)
{
return Pushword(estrdup(s));
}
char*
Freeword(word *p)
{
char *s = p->word;
free(p);
return s;
}
void
freewords(word *w)
{
word *p;
while((p = w)!=0){
w = w->next;
free(Freeword(p));
}
}
char*
Popword(void)
{
word *p;
if(runq->argv==0)
panic("popword but no argv!", 0);
p = runq->argv->words;
if(p==0)
panic("popword but no word!", 0);
runq->argv->words = p->next;
return Freeword(p);
}
void
popword(void)
{
free(Popword());
}
void
pushlist(void)
{
list *p = new(list);
p->words = 0;
p->next = runq->argv;
runq->argv = p;
}
word*
Poplist(void)
{
word *w;
list *p = runq->argv;
if(p==0)
panic("poplist but no argv", 0);
w = p->words;
runq->argv = p->next;
free(p);
return w;
}
void
poplist(void)
{
freewords(Poplist());
}
int
count(word *w)
{
int n;
for(n = 0;w;n++) w = w->next;
return n;
}
void
pushredir(int type, int from, int to)
{
redir *rp = new(redir);
rp->type = type;
rp->from = from;
rp->to = to;
rp->next = runq->redir;
runq->redir = rp;
}
static void
dontclose(int fd)
{
redir *rp;
if(fd<0)
return;
for(rp = runq->redir; rp != runq->startredir; rp = rp->next){
if(rp->type == RCLOSE && rp->from == fd){
rp->type = 0;
break;
}
}
}
/*
* we are about to start a new thread that should exit on
* return, so the current stack is not needed anymore.
* free all the threads and lexers, but preserve the
* redirections and anything referenced by local.
*/
void
turfstack(var *local)
{
while(local){
thread *p;
for(p = runq; p && p->local == local; p = p->ret)
p->local = local->next;
local = local->next;
}
while(runq) {
if(runq->lex) dontclose(runq->lex->input->fd);
popthread();
}
}
void
shuffleredir(void)
{
redir **rr, *rp;
rp = runq->redir;
if(rp==0)
return;
runq->redir = rp->next;
rp->next = runq->startredir;
for(rr = &runq->redir; *rr != rp->next; rr = &((*rr)->next))
;
*rr = rp;
}
/*
* get command line flags, initialize keywords & traps.
* get values from environment.
* set $pid, $cflag, $*
* fabricate bootstrap code and start it (*=(argv);. -bq /usr/lib/rcmain $*)
* start interpreting code
*/
void
main(int argc, char *argv[])
{
code bootstrap[20];
char num[12];
char *rcmain=Rcmain;
int i;
argv0 = argv[0];
argc = getflags(argc, argv, "srdiIlxebpvVc:1m:1[command]", 1);
if(argc==-1)
usage("[file [arg ...]]");
if(argv[0][0]=='-')
flag['l'] = flagset;
if(flag['I'])
flag['i'] = 0;
else if(flag['i']==0 && argc==1 && Isatty(0)) flag['i'] = flagset;
if(flag['m']) rcmain = flag['m'][0];
err = openiofd(2);
kinit();
Trapinit();
Vinit();
inttoascii(num, mypid = getpid());
setvar("pid", newword(num, (word *)0));
setvar("cflag", flag['c']?newword(flag['c'][0], (word *)0)
:(word *)0);
setvar("rcname", newword(argv[0], (word *)0));
bootstrap[0].i = 1;
bootstrap[1].s="*bootstrap*";
bootstrap[2].f = Xmark;
bootstrap[3].f = Xword;
bootstrap[4].s="*";
bootstrap[5].f = Xassign;
bootstrap[6].f = Xmark;
bootstrap[7].f = Xmark;
bootstrap[8].f = Xword;
bootstrap[9].s="*";
bootstrap[10].f = Xdol;
bootstrap[11].f = Xword;
bootstrap[12].s = rcmain;
bootstrap[13].f = Xword;
bootstrap[14].s="-bq";
bootstrap[15].f = Xword;
bootstrap[16].s=".";
bootstrap[17].f = Xsimple;
bootstrap[18].f = Xexit;
bootstrap[19].f = 0;
start(bootstrap, 2, (var*)0, (redir*)0);
/* prime bootstrap argv */
pushlist();
for(i = argc-1;i!=0;--i) pushword(argv[i]);
for(;;){
if(flag['r'])
pfnc(err, runq);
(*runq->code[runq->pc++].f)();
if(ntrap)
dotrap();
}
}
/*
* Opcode routines
* Arguments on stack (...)
* Arguments in line [...]
* Code in line with jump around {...}
*
* Xappend(file)[fd] open file to append
* Xassign(name, val) assign val to name
* Xasync{... Xexit} make thread for {}, no wait
* Xbackq(split){... Xreturn} make thread for {}, push stdout
* Xbang complement condition
* Xcase(pat, value){...} exec code on match, leave (value) on
* stack
* Xclose[i] close file descriptor
* Xconc(left, right) concatenate, push results
* Xcount(name) push var count
* Xdelfn(name) delete function definition
* Xdol(name) get variable value
* Xdup[i j] dup file descriptor
* Xexit rc exits with status
* Xfalse{...} execute {} if false
* Xfn(name){... Xreturn} define function
* Xfor(var, list){... Xreturn} for loop
* Xglob(list) glob a list of words inplace
* Xjump[addr] goto
* Xlocal(name, val) create local variable, assign value
* Xmark mark stack
* Xmatch(pat, str) match pattern, set status
* Xpipe[i j]{... Xreturn}{... Xreturn} construct a pipe between 2 new threads,
* wait for both
* Xpipefd[type]{... Xreturn} connect {} to pipe (input or output,
* depending on type), push /dev/fd/??
* Xpopm(value) pop value from stack
* Xpush(words) push words down a list
* Xqw(words) quote words inplace
* Xrdwr(file)[fd] open file for reading and writing
* Xread(file)[fd] open file to read
* Xreturn kill thread
* Xsimple(args) run command and wait
* Xsrcline[line] set current source line number
* Xsubshell{... Xexit} execute {} in a subshell and wait
* Xtrue{...} execute {} if true
* Xunlocal delete local variable
* Xword[string] push string
* Xwrite(file)[fd] open file to write
*/
void
Xappend(void)
{
char *file;
int fd;
switch(count(runq->argv->words)){
default:
Xerror1(">> requires singleton");
return;
case 0:
Xerror1(">> requires file");
return;
case 1:
break;
}
file = runq->argv->words->word;
if((fd = Open(file, 1))<0 && (fd = Creat(file))<0){
Xerror3(">> can't open", file, Errstr());
return;
}
Seek(fd, 0L, 2);
pushredir(ROPEN, fd, runq->code[runq->pc++].i);
poplist();
}
void
Xsettrue(void)
{
setstatus("");
}
void
Xbang(void)
{
setstatus(truestatus()?"false":"");
}
void
Xclose(void)
{
pushredir(RCLOSE, runq->code[runq->pc++].i, 0);
}
void
Xdup(void)
{
pushredir(RDUP, runq->code[runq->pc].i, runq->code[runq->pc+1].i);
runq->pc+=2;
}
void
Xeflag(void)
{
if(!truestatus()) Xexit();
}
void
Xexit(void)
{
static int beenhere = 0;
if(getpid()==mypid && !beenhere){
var *trapreq = vlook("sigexit");
word *starval = vlook("*")->val;
if(trapreq->fn){
beenhere = 1;
--runq->pc;
startfunc(trapreq, copywords(starval, (word*)0), (var*)0, (redir*)0);
return;
}
}
Exit();
}
void
Xfalse(void)
{
if(truestatus()) runq->pc = runq->code[runq->pc].i;
else runq->pc++;
}
int ifnot; /* dynamic if not flag */
void
Xifnot(void)
{
if(ifnot)
runq->pc++;
else
runq->pc = runq->code[runq->pc].i;
}
void
Xjump(void)
{
runq->pc = runq->code[runq->pc].i;
}
void
Xmark(void)
{
pushlist();
}
void
Xpopm(void)
{
poplist();
}
void
Xpush(void)
{
word *t, *h = Poplist();
for(t = h; t->next; t = t->next)
;
t->next = runq->argv->words;
runq->argv->words = h;
}
static int
herefile(char *tmp)
{
char *s = tmp+strlen(tmp)-1;
static int ser;
int fd, i;
i = ser++;
while(*s == 'Y'){
*s-- = (i%26) + 'A';
i = i/26;
}
i = getpid();
while(*s == 'X'){
*s-- = (i%10) + '0';
i = i/10;
}
s++;
for(i='a'; i<'z'; i++){
if(access(tmp, 0)!=0 && (fd = Creat(tmp))>=0)
return fd;
*s = i;
}
return -1;
}
void
Xhere(void)
{
char file[]="/tmp/hereXXXXXXXXXXYY";
int fd;
io *io;
if((fd = herefile(file))<0){
Xerror3("<< can't get temp file", file, Errstr());
return;
}
io = openiofd(fd);
psubst(io, (unsigned char*)runq->code[runq->pc++].s);
flushio(io);
closeio(io);
/* open for reading and unlink */
if((fd = Open(file, 3))<0){
Xerror3("<< can't open", file, Errstr());
return;
}
pushredir(ROPEN, fd, runq->code[runq->pc++].i);
}
void
Xhereq(void)
{
char file[]="/tmp/hereXXXXXXXXXXYY", *body;
int fd;
if((fd = herefile(file))<0){
Xerror3("<< can't get temp file", file, Errstr());
return;
}
body = runq->code[runq->pc++].s;
Write(fd, body, strlen(body));
Close(fd);
/* open for reading and unlink */
if((fd = Open(file, 3))<0){
Xerror3("<< can't open", file, Errstr());
return;
}
pushredir(ROPEN, fd, runq->code[runq->pc++].i);
}
void
Xread(void)
{
char *file;
int fd;
switch(count(runq->argv->words)){
default:
Xerror1("< requires singleton");
return;
case 0:
Xerror1("< requires file");
return;
case 1:
break;
}
file = runq->argv->words->word;
if((fd = Open(file, 0))<0){
Xerror3("< can't open", file, Errstr());
return;
}
pushredir(ROPEN, fd, runq->code[runq->pc++].i);
poplist();
}
void
Xrdwr(void)
{
char *file;
int fd;
switch(count(runq->argv->words)){
default:
Xerror1("<> requires singleton");
return;
case 0:
Xerror1("<> requires file");
return;
case 1:
break;
}
file = runq->argv->words->word;
if((fd = Open(file, 2))<0){
Xerror3("<> can't open", file, Errstr());
return;
}
pushredir(ROPEN, fd, runq->code[runq->pc++].i);
poplist();
}
void
Xpopredir(void)
{
redir *rp = runq->redir;
if(rp==0)
panic("Xpopredir null!", 0);
runq->redir = rp->next;
if(rp->type==ROPEN)
Close(rp->from);
free(rp);
}
void
Xreturn(void)
{
while(runq->redir!=runq->startredir)
Xpopredir();
popthread();
if(runq==0)
Exit();
}
void
Xtrue(void)
{
if(truestatus()) runq->pc++;
else runq->pc = runq->code[runq->pc].i;
}
void
Xif(void)
{
ifnot = 1;
if(truestatus()) runq->pc++;
else runq->pc = runq->code[runq->pc].i;
}
void
Xwastrue(void)
{
ifnot = 0;
}
void
Xword(void)
{
pushword(runq->code[runq->pc++].s);
}
void
Xwrite(void)
{
char *file;
int fd;
switch(count(runq->argv->words)){
default:
Xerror1("> requires singleton");
return;
case 0:
Xerror1("> requires file");
return;
case 1:
break;
}
file = runq->argv->words->word;
if((fd = Creat(file))<0){
Xerror3("> can't create", file, Errstr());
return;
}
pushredir(ROPEN, fd, runq->code[runq->pc++].i);
poplist();
}
void
Xmatch(void)
{
word *p;
char *s;
setstatus("no match");
s = runq->argv->words->word;
for(p = runq->argv->next->words;p;p = p->next)
if(match(s, p->word, '\0')){
setstatus("");
break;
}
poplist();
poplist();
}
void
Xcase(void)
{
word *p;
char *s;
int ok = 0;
s = runq->argv->next->words->word;
for(p = runq->argv->words;p;p = p->next){
if(match(s, p->word, '\0')){
ok = 1;
break;
}
}
if(ok)
runq->pc++;
else
runq->pc = runq->code[runq->pc].i;
poplist();
}
static word*
conclist(word *lp, word *rp, word *tail)
{
word *v, *p, **end;
int ln, rn;
for(end = &v;;){
ln = strlen(lp->word), rn = strlen(rp->word);
p = Newword(emalloc(ln+rn+1), (word *)0);
memmove(p->word, lp->word, ln);
memmove(p->word+ln, rp->word, rn+1);
*end = p, end = &p->next;
if(lp->next == 0 && rp->next == 0)
break;
if(lp->next) lp = lp->next;
if(rp->next) rp = rp->next;
}
*end = tail;
return v;
}
void
Xconc(void)
{
word *lp = runq->argv->words;
word *rp = runq->argv->next->words;
word *vp = runq->argv->next->next->words;
int lc = count(lp), rc = count(rp);
if(lc!=0 || rc!=0){
if(lc==0 || rc==0){
Xerror1("null list in concatenation");
return;
}
if(lc!=1 && rc!=1 && lc!=rc){
Xerror1("mismatched list lengths in concatenation");
return;
}
vp = conclist(lp, rp, vp);
}
poplist();
poplist();
runq->argv->words = vp;
}
void
Xassign(void)
{
var *v;
if(count(runq->argv->words)!=1){
Xerror1("= variable name not singleton!");
return;
}
v = vlook(runq->argv->words->word);
poplist();
freewords(v->val);
v->val = Poplist();
v->changed = 1;
}
/*
* copy arglist a, adding the copy to the front of tail
*/
word*
copywords(word *a, word *tail)
{
word *v = 0, **end;
for(end=&v;a;a = a->next,end=&(*end)->next)
*end = newword(a->word, 0);
*end = tail;
return v;
}
void
Xdol(void)
{
word *a, *star;
char *s, *t;
int n;
if(count(runq->argv->words)!=1){
Xerror1("$ variable name not singleton!");
return;
}
n = 0;
s = runq->argv->words->word;
for(t = s;'0'<=*t && *t<='9';t++) n = n*10+*t-'0';
a = runq->argv->next->words;
if(n==0 || *t)
a = copywords(vlook(s)->val, a);
else{
star = vlook("*")->val;
if(star && 1<=n && n<=count(star)){
while(--n) star = star->next;
a = newword(star->word, a);
}
}
poplist();
runq->argv->words = a;
}
void
Xqw(void)
{
char *s, *d;
word *a, *p;
int n;
a = runq->argv->words;
if(a==0){
pushword("");
return;
}
if(a->next==0)
return;
n=0;
for(p=a;p;p=p->next)
n+=1+strlen(p->word);
s = emalloc(n+1);
d = s;
d += strlen(strcpy(d, a->word));
for(p=a->next;p;p=p->next){
*d++=' ';
d += strlen(strcpy(d, p->word));
}
free(a->word);
freewords(a->next);
a->word = s;
a->next = 0;
}
static word*
copynwords(word *a, word *tail, int n)
{
word *v, **end;
v = 0;
end = &v;
while(n-- > 0){
*end = newword(a->word, 0);
end = &(*end)->next;
a = a->next;
}
*end = tail;
return v;
}
static word*
subwords(word *val, int len, word *sub, word *a)
{
int n, m;
char *s;
if(sub==0)
return a;
a = subwords(val, len, sub->next, a);
s = sub->word;
m = 0;
n = 0;
while('0'<=*s && *s<='9')
n = n*10+ *s++ -'0';
if(*s == '-'){
if(*++s == 0)
m = len - n;
else{
while('0'<=*s && *s<='9')
m = m*10+ *s++ -'0';
m -= n;
}
}
if(n<1 || n>len || m<0)
return a;
if(n+m>len)
m = len-n;
while(--n > 0)
val = val->next;
return copynwords(val, a, m+1);
}
void
Xsub(void)
{
word *a, *v;
char *s;
if(count(runq->argv->next->words)!=1){
Xerror1("$() variable name not singleton!");
return;
}
s = runq->argv->next->words->word;
a = runq->argv->next->next->words;
v = vlook(s)->val;
a = subwords(v, count(v), runq->argv->words, a);
poplist();
poplist();
runq->argv->words = a;
}
void
Xcount(void)
{
word *a;
char *s, *t, num[12];
int n;
if(count(runq->argv->words)!=1){
Xerror1("$# variable name not singleton!");
return;
}
n = 0;
s = runq->argv->words->word;
for(t = s;'0'<=*t && *t<='9';t++) n = n*10+*t-'0';
if(n==0 || *t){
a = vlook(s)->val;
inttoascii(num, count(a));
}
else{
a = vlook("*")->val;
inttoascii(num, a && 1<=n && n<=count(a)?1:0);
}
poplist();
pushword(num);
}
void
Xlocal(void)
{
if(count(runq->argv->words)!=1){
Xerror1("local variable name must be singleton");
return;
}
runq->local = newvar(runq->argv->words->word, runq->local);
poplist();
runq->local->val = Poplist();
runq->local->changed = 1;
}
void
Xunlocal(void)
{
var *hid, *v = runq->local;
if(v==0)
panic("Xunlocal: no locals!", 0);
runq->local = v->next;
hid = vlook(v->name);
hid->changed = 1;
freevar(v);
}
void
Xfn(void)
{
var *v;
word *a;
int pc = runq->pc;
runq->pc = runq->code[pc].i;
for(a = runq->argv->words;a;a = a->next){
v = gvlook(a->word);
if(v->fn)
codefree(v->fn);
v->fn = codecopy(runq->code);
v->pc = pc+2;
v->fnchanged = 1;
}
poplist();
}
void
Xdelfn(void)
{
var *v;
word *a;
for(a = runq->argv->words;a;a = a->next){
v = gvlook(a->word);
if(v->fn)
codefree(v->fn);
v->fn = 0;
v->fnchanged = 1;
}
poplist();
}
static char*
concstatus(char *s, char *t)
{
int n, m;
if(t==0) return s;
if(s==0) return t;
n = strlen(s);
m = strlen(t);
s = erealloc(s, n+m+2);
if(n > 0) s[n++]='|';
memmove(s+n, t, m+1);
free(t);
return s;
}
void
Xpipewait(void)
{
char *old = Getstatus();
if(runq->pid==-1){
Setstatus(concstatus(runq->status, old));
runq->status=0;
}else{
while(Waitfor(runq->pid) < 0)
;
runq->pid=-1;
Setstatus(concstatus(Getstatus(), old));
}
}
static char *promptstr;
void
Xrdcmds(void)
{
thread *p = runq;
if(flag['s'] && !truestatus())
pfmt(err, "status=%v\n", vlook("status")->val);
flushio(err);
lex = p->lex;
if(p->iflag){
word *prompt = vlook("prompt")->val;
if(prompt)
promptstr = prompt->word;
else
promptstr="% ";
}
Noerror();
nerror = 0;
if(yyparse()){
if(p->iflag && (!lex->eof || Eintr())){
if(Eintr()){
pchr(err, '\n');
lex->eof = 0;
}
--p->pc; /* go back for next command */
}
}
else{
if(lex->eof){
dontclose(lex->input->fd);
freelexer(lex);
p->lex = 0;
} else
--p->pc; /* re-execute Xrdcmds after codebuf runs */
start(codebuf, 2, p->local, p->redir);
}
lex = 0;
freenodes();
}
void
pprompt(void)
{
word *prompt;
if(!runq->iflag)
return;
Prompt(promptstr);
doprompt = 0;
prompt = vlook("prompt")->val;
if(prompt && prompt->next)
promptstr = prompt->next->word;
else
promptstr = "\t";
}
char*
srcfile(thread *p)
{
return p->code[1].s;
}
void
Xerror1(char *s)
{
setstatus("error");
pfln(err, srcfile(runq), runq->line);
pfmt(err, ": %s\n", s);
flushio(err);
while(!runq->iflag) Xreturn();
}
void
Xerror2(char *s, char *e)
{
setstatus(e);
pfln(err, srcfile(runq), runq->line);
pfmt(err, ": %s: %s\n", s, e);
flushio(err);
while(!runq->iflag) Xreturn();
}
void
Xerror3(char *s, char *m, char *e)
{
setstatus(e);
pfln(err, srcfile(runq), runq->line);
pfmt(err, ": %s: %s: %s\n", s, m, e);
flushio(err);
while(!runq->iflag) Xreturn();
}
void
Setstatus(char *s)
{
setvar("status", Newword(s?s:estrdup(""), (word *)0));
}
void
setstatus(char *s)
{
Setstatus(estrdup(s));
}
char*
Getstatus(void)
{
var *status = vlook("status");
word *val = status->val;
if(val==0) return 0;
status->val=0;
status->changed=1;
freewords(val->next);
return Freeword(val);
}
char*
getstatus(void)
{
var *status = vlook("status");
return status->val?status->val->word:"";
}
int
truestatus(void)
{
char *s;
for(s = getstatus();*s;s++)
if(*s!='|' && *s!='0')
return 0;
return 1;
}
void
Xfor(void)
{
word *a = runq->argv->words;
if(a==0){
poplist();
runq->pc = runq->code[runq->pc].i;
}
else{
runq->argv->words = a->next;
a->next = 0;
freewords(runq->local->val);
runq->local->val = a;
runq->local->changed = 1;
runq->pc++;
}
}
void
Xglob(void)
{
word *a, *x;
for(a = runq->argv->words; a; a = x){
x = a->next;
globword(a);
}
}
void
Xsrcline(void)
{
runq->line = runq->code[runq->pc++].i;
}