sh3.c

Go to the documentation of this file.

#define Extern extern
#include <sys/types.h>
#include <signal.h>
#include <errno.h>
#include <setjmp.h>
#include <stddef.h>
#include <time.h>
#include <sys/times.h>
#include <sys/stat.h>
#include <sys/wait.h>
#undef NULL
#include "sh.h"

/* -------- exec.c -------- */
/* #include "sh.h" */

/*
 * execute tree
 */

static  char    *signame[] = {
        "Signal 0",
        "Hangup",
        (char *)NULL,   /* interrupt */
        "Quit",
        "Illegal instruction",
        "Trace/BPT trap",
        "Abort",
        "EMT trap",
        "Floating exception",
        "Killed",
        "Bus error",
        "Memory fault",
        "Bad system call",
        (char *)NULL,   /* broken pipe */
        "Alarm clock",
        "Terminated",
};
#define NSIGNAL (sizeof(signame)/sizeof(signame[0]))


_PROTOTYPE(static int forkexec, (struct op *t, int *pin, int *pout, int act, char **wp, int *pforked ));
_PROTOTYPE(static int parent, (void));
_PROTOTYPE(int iosetup, (struct ioword *iop, int pipein, int pipeout ));
_PROTOTYPE(static void echo, (char **wp ));
_PROTOTYPE(static struct op **find1case, (struct op *t, char *w ));
_PROTOTYPE(static struct op *findcase, (struct op *t, char *w ));
_PROTOTYPE(static void brkset, (struct brkcon *bc ));
_PROTOTYPE(int dolabel, (void));
_PROTOTYPE(int dochdir, (struct op *t ));
_PROTOTYPE(int doshift, (struct op *t ));
_PROTOTYPE(int dologin, (struct op *t ));
_PROTOTYPE(int doumask, (struct op *t ));
_PROTOTYPE(int doexec, (struct op *t ));
_PROTOTYPE(int dodot, (struct op *t ));
_PROTOTYPE(int dowait, (struct op *t ));
_PROTOTYPE(int doread, (struct op *t ));
_PROTOTYPE(int doeval, (struct op *t ));
_PROTOTYPE(int dotrap, (struct op *t ));
_PROTOTYPE(int getsig, (char *s ));
_PROTOTYPE(void setsig, (int n, void (*f)()));
_PROTOTYPE(int getn, (char *as ));
_PROTOTYPE(int dobreak, (struct op *t ));
_PROTOTYPE(int docontinue, (struct op *t ));
_PROTOTYPE(static int brkcontin, (char *cp, int val ));
_PROTOTYPE(int doexit, (struct op *t ));
_PROTOTYPE(int doexport, (struct op *t ));
_PROTOTYPE(int doreadonly, (struct op *t ));
_PROTOTYPE(static void rdexp, (char **wp, void (*f)(), int key));
_PROTOTYPE(static void badid, (char *s ));
_PROTOTYPE(int doset, (struct op *t ));
_PROTOTYPE(void varput, (char *s, int out ));
_PROTOTYPE(int dotimes, (void));

int
execute(t, pin, pout, act)
register struct op *t;
int *pin, *pout;
int act;
{
        register struct op *t1;
        int i, pv[2], rv, child, a;
        char *cp, **wp, **wp2;
        struct var *vp;
        struct brkcon bc;

        if (t == NULL)
                return(0);
        rv = 0;
        a = areanum++;
        wp = (wp2 = t->words) != NULL
             ? eval(wp2, t->type == TCOM ? DOALL : DOALL & ~DOKEY)
             : NULL;

        switch(t->type) {
        case TPAREN:
        case TCOM:
                rv = forkexec(t, pin, pout, act, wp, &child);
                if (child) {
                        exstat = rv;
                        leave();
                }
                break;

        case TPIPE:
                if ((rv = openpipe(pv)) < 0)
                        break;
                pv[0] = remap(pv[0]);
                pv[1] = remap(pv[1]);
                (void) execute(t->left, pin, pv, 0);
                rv = execute(t->right, pv, pout, 0);
                break;

        case TLIST:
                (void) execute(t->left, pin, pout, 0);
                rv = execute(t->right, pin, pout, 0);
                break;

        case TASYNC:
                i = parent();
                if (i != 0) {
                        if (i != -1) {
                                setval(lookup("!"), putn(i));
                                if (pin != NULL)
                                        closepipe(pin);
                                if (talking) {
                                        prs(putn(i));
                                        prs("\n");
                                }
                        } else
                                rv = -1;
                        setstatus(rv);
                } else {
                        signal(SIGINT, SIG_IGN);
                        signal(SIGQUIT, SIG_IGN);
                        if (talking)
                                signal(SIGTERM, SIG_DFL);
                        talking = 0;
                        if (pin == NULL) {
                                close(0);
                                open("/dev/null", 0);
                        }
                        exit(execute(t->left, pin, pout, FEXEC));
                }
                break;

        case TOR:
        case TAND:
                rv = execute(t->left, pin, pout, 0);
                if ((t1 = t->right)!=NULL && (rv == 0) == (t->type == TAND))
                        rv = execute(t1, pin, pout, 0);
                break;

        case TFOR:
                if (wp == NULL) {
                        wp = dolv+1;
                        if ((i = dolc) < 0)
                                i = 0;
                } else {
                        i = -1;
                        while (*wp++ != NULL)
                                ;                       
                }
                vp = lookup(t->str);
                while (setjmp(bc.brkpt))
                        if (isbreak)
                                goto broken;
                brkset(&bc);
                for (t1 = t->left; i-- && *wp != NULL;) {
                        setval(vp, *wp++);
                        rv = execute(t1, pin, pout, 0);
                }
                brklist = brklist->nextlev;
                break;

        case TWHILE:
        case TUNTIL:
                while (setjmp(bc.brkpt))
                        if (isbreak)
                                goto broken;
                brkset(&bc);
                t1 = t->left;
                while ((execute(t1, pin, pout, 0) == 0) == (t->type == TWHILE))
                        rv = execute(t->right, pin, pout, 0);
                brklist = brklist->nextlev;
                break;

        case TIF:
        case TELIF:
                if (t->right != NULL) {
                rv = !execute(t->left, pin, pout, 0) ?
                        execute(t->right->left, pin, pout, 0):
                        execute(t->right->right, pin, pout, 0);
                }
                break;

        case TCASE:
                if ((cp = evalstr(t->str, DOSUB|DOTRIM)) == 0)
                        cp = "";
                if ((t1 = findcase(t->left, cp)) != NULL)
                        rv = execute(t1, pin, pout, 0);
                break;

        case TBRACE:
/*
                if (iopp = t->ioact)
                        while (*iopp)
                                if (iosetup(*iopp++, pin!=NULL, pout!=NULL)) {
                                        rv = -1;
                                        break;
                                }
*/
                if (rv >= 0 && (t1 = t->left))
                        rv = execute(t1, pin, pout, 0);
                break;
        }

broken:
        t->words = wp2;
        isbreak = 0;
        freehere(areanum);
        freearea(areanum);
        areanum = a;
        if (talking && intr) {
                closeall();
                fail();
        }
        if ((i = trapset) != 0) {
                trapset = 0;
                runtrap(i);
        }
        return(rv);
}

static int
forkexec(t, pin, pout, act, wp, pforked)
register struct op *t;
int *pin, *pout;
int act;
char **wp;
int *pforked;
{
        int i, rv, (*shcom)();
        register int f;
        char *cp;
        struct ioword **iopp;
        int resetsig;
        char **owp;

        owp = wp;
        resetsig = 0;
        *pforked = 0;
        shcom = NULL;
        rv = -1;        /* system-detected error */
        if (t->type == TCOM) {
                while ((cp = *wp++) != NULL)
                        ;
                cp = *wp;

                /* strip all initial assignments */
                /* not correct wrt PATH=yyy command  etc */
                if (flag['x'])
                        echo (cp ? wp: owp);
                if (cp == NULL && t->ioact == NULL) {
                        while ((cp = *owp++) != NULL && assign(cp, COPYV))
                                ;
                        return(setstatus(0));
                }
                else if (cp != NULL)
                        shcom = inbuilt(cp);
        }
        t->words = wp;
        f = act;
        if (shcom == NULL && (f & FEXEC) == 0) {
                i = parent();
                if (i != 0) {
                        if (i == -1)
                                return(rv);
                        if (pin != NULL)
                                closepipe(pin);
                        return(pout==NULL? setstatus(waitfor(i,0)): 0);
                }
                if (talking) {
                        signal(SIGINT, SIG_IGN);
                        signal(SIGQUIT, SIG_IGN);
                        resetsig = 1;
                }
                talking = 0;
                intr = 0;
                (*pforked)++;
                brklist = 0;
                execflg = 0;
        }
        if (owp != NULL)
                while ((cp = *owp++) != NULL && assign(cp, COPYV))
                        if (shcom == NULL)
                                export(lookup(cp));
#ifdef COMPIPE
        if ((pin != NULL || pout != NULL) && shcom != NULL && shcom != doexec) {
                err("piping to/from shell builtins not yet done");
                return(-1);
        }
#endif
        if (pin != NULL) {
                dup2(pin[0], 0);
                closepipe(pin);
        }
        if (pout != NULL) {
                dup2(pout[1], 1);
                closepipe(pout);
        }
        if ((iopp = t->ioact) != NULL) {
                if (shcom != NULL && shcom != doexec) {
                        prs(cp);
                        err(": cannot redirect shell command");
                        return(-1);
                }
                while (*iopp)
                        if (iosetup(*iopp++, pin!=NULL, pout!=NULL))
                                return(rv);
        }
        if (shcom)
                return(setstatus((*shcom)(t)));
        /* should use FIOCEXCL */
        for (i=FDBASE; i<NOFILE; i++)
                close(i);
        if (resetsig) {
                signal(SIGINT, SIG_DFL);
                signal(SIGQUIT, SIG_DFL);
        }
        if (t->type == TPAREN)
                exit(execute(t->left, NOPIPE, NOPIPE, FEXEC));
        if (wp[0] == NULL)
                exit(0);
        cp = rexecve(wp[0], wp, makenv());
        prs(wp[0]); prs(": "); warn(cp);
        if (!execflg)
                trap[0] = NULL;
        leave();
        /* NOTREACHED */
}

/*
 * common actions when creating a new child
 */
static int
parent()
{
        register int i;

        i = fork();
        if (i != 0) {
                if (i == -1)
                        warn("try again");
        }
        return(i);
}

/*
 * 0< 1> are ignored as required
 * within pipelines.
 */
int
iosetup(iop, pipein, pipeout)
register struct ioword *iop;
int pipein, pipeout;
{
        register u;
        char *cp, *msg;

        if (iop->io_unit == IODEFAULT)  /* take default */
                iop->io_unit = iop->io_flag&(IOREAD|IOHERE)? 0: 1;
        if (pipein && iop->io_unit == 0)
                return(0);
        if (pipeout && iop->io_unit == 1)
                return(0);
        msg = iop->io_flag&(IOREAD|IOHERE)? "open": "create";
        if ((iop->io_flag & IOHERE) == 0) {
                cp = iop->io_name;
                if ((cp = evalstr(cp, DOSUB|DOTRIM)) == NULL)
                        return(1);
        }
        if (iop->io_flag & IODUP) {
                if (cp[1] || (!digit(*cp) && *cp != '-')) {
                        prs(cp);
                        err(": illegal >& argument");
                        return(1);
                }
                if (*cp == '-')
                        iop->io_flag = IOCLOSE;
                iop->io_flag &= ~(IOREAD|IOWRITE);
        }
        switch (iop->io_flag) {
        case IOREAD:
                u = open(cp, 0);
                break;

        case IOHERE:
        case IOHERE|IOXHERE:
                u = herein(iop->io_name, iop->io_flag&IOXHERE);
                cp = "here file ";
                break;

        case IOWRITE|IOCAT:
                if ((u = open(cp, 1)) >= 0) {
                        lseek(u, (long)0, 2);
                        break;
                }
        case IOWRITE:
                u = creat(cp, 0666);
                break;

        case IODUP:
                u = dup2(*cp-'0', iop->io_unit);
                break;

        case IOCLOSE:
                close(iop->io_unit);
                return(0);
        }
        if (u < 0) {
                int e=errno;
                prs(cp);
                if (iop->io_flag&IOHERE) prs(iop->io_name);
                prs(": cannot ");
                prs(msg);
                prs(" (");
                prs(strerror(e));
                warn(")");
                return(1);
        } else {
                if (u != iop->io_unit) {
                        dup2(u, iop->io_unit);
                        close(u);
                }
        }
        return(0);
}

static void
echo(wp)
register char **wp;
{
        register i;

        prs("+");
        for (i=0; wp[i]; i++) {
                if (i)
                        prs(" ");
                prs(wp[i]);
        }
        prs("\n");
}

static struct op **
find1case(t, w)
struct op *t;
char *w;
{
        register struct op *t1;
        struct op **tp;
        register char **wp, *cp;

        if (t == NULL)
                return((struct op **)NULL);
        if (t->type == TLIST) {
                if ((tp = find1case(t->left, w)) != NULL)
                        return(tp);
                t1 = t->right;  /* TPAT */
        } else
                t1 = t;
        for (wp = t1->words; *wp;)
                if ((cp = evalstr(*wp++, DOSUB)) && gmatch(w, cp))
                        return(&t1->left);
        return((struct op **)NULL);
}

static struct op *
findcase(t, w)
struct op *t;
char *w;
{
        register struct op **tp;

        return((tp = find1case(t, w)) != NULL? *tp: (struct op *)NULL);
}

/*
 * Enter a new loop level (marked for break/continue).
 */
static void
brkset(bc)
struct brkcon *bc;
{
        bc->nextlev = brklist;
        brklist = bc;
}

/*
 * Wait for the last process created.
 * Print a message for each process found
 * that was killed by a signal.
 * Ignore interrupt signals while waiting
 * unless `canintr' is true.
 */
int
waitfor(lastpid, canintr)
register int lastpid;
int canintr;
{
        register int pid, rv;
        int s;
        int oheedint = heedint;

        heedint = 0;
        rv = 0;
        do {
                pid = wait(&s);
                if (pid == -1) {
                        if (errno != EINTR || canintr)
                                break;
                } else {
                        if ((rv = WAITSIG(s)) != 0) {
                                if (rv < NSIGNAL) {
                                        if (signame[rv] != NULL) {
                                                if (pid != lastpid) {
                                                        prn(pid);
                                                        prs(": ");
                                                }
                                                prs(signame[rv]);
                                        }
                                } else {
                                        if (pid != lastpid) {
                                                prn(pid);
                                                prs(": ");
                                        }
                                        prs("Signal "); prn(rv); prs(" ");
                                }
                                if (WAITCORE(s))
                                        prs(" - core dumped");
                                if (rv >= NSIGNAL || signame[rv])
                                        prs("\n");
                                rv = -1;
                        } else
                                rv = WAITVAL(s);
                }
        } while (pid != lastpid);
        heedint = oheedint;
        if (intr)
                if (talking) {
                        if (canintr)
                                intr = 0;
                } else {
                        if (exstat == 0) exstat = rv;
                        onintr(0);
                }
        return(rv);
}

int
setstatus(s)
register int s;
{
        exstat = s;
        setval(lookup("?"), putn(s));
        return(s);
}

/*
 * PATH-searching interface to execve.
 * If getenv("PATH") were kept up-to-date,
 * execvp might be used.
 */
char *
rexecve(c, v, envp)
char *c, **v, **envp;
{
        register int i;
        register char *sp, *tp;
        int eacces = 0, asis = 0;

        sp = any('/', c)? "": path->value;
        asis = *sp == '\0';
        while (asis || *sp != '\0') {
                asis = 0;
                tp = e.linep;
                for (; *sp != '\0'; tp++)
                        if ((*tp = *sp++) == ':') {
                                asis = *sp == '\0';
                                break;
                        }
                if (tp != e.linep)
                        *tp++ = '/';
                for (i = 0; (*tp++ = c[i++]) != '\0';)
                        ;
                execve(e.linep, v, envp);
                switch (errno) {
                case ENOEXEC:
                        *v = e.linep;
                        tp = *--v;
                        *v = e.linep;
                        execve("/bin/sh", v, envp);
                        *v = tp;
                        return("no Shell");

                case ENOMEM:
                        return("program too big");

                case E2BIG:
                        return("argument list too long");

                case EACCES:
                        eacces++;
                        break;
                }
        }
        return(errno==ENOENT ? "not found" : "cannot execute");
}

/*
 * Run the command produced by generator `f'
 * applied to stream `arg'.
 */
int
run(argp, f)
struct ioarg *argp;
int (*f)();
{
        struct op *otree;
        struct wdblock *swdlist;
        struct wdblock *siolist;
        jmp_buf ev, rt;
        xint *ofail;
        int rv;

        areanum++;
        swdlist = wdlist;
        siolist = iolist;
        otree = outtree;
        ofail = failpt;
        rv = -1;
        if (newenv(setjmp(errpt = ev)) == 0) {
                wdlist = 0;
                iolist = 0;
                pushio(argp, f);
                e.iobase = e.iop;
                yynerrs = 0;
                if (setjmp(failpt = rt) == 0 && yyparse() == 0)
                        rv = execute(outtree, NOPIPE, NOPIPE, 0);
                quitenv();
        }
        wdlist = swdlist;
        iolist = siolist;
        failpt = ofail;
        outtree = otree;
        freearea(areanum--);
        return(rv);
}

/* -------- do.c -------- */
/* #include "sh.h" */

/*
 * built-in commands: doX
 */

int
dolabel()
{
        return(0);
}

int
dochdir(t)
register struct op *t;
{
        register char *cp, *er;

        if ((cp = t->words[1]) == NULL && (cp = homedir->value) == NULL)
                er = ": no home directory";
        else if(chdir(cp) < 0)
                er = ": bad directory";
        else
                return(0);
        prs(cp != NULL? cp: "cd");
        err(er);
        return(1);
}

int
doshift(t)
register struct op *t;
{
        register n;

        n = t->words[1]? getn(t->words[1]): 1;
        if(dolc < n) {
                err("nothing to shift");
                return(1);
        }
        dolv[n] = dolv[0];
        dolv += n;
        dolc -= n;
        setval(lookup("#"), putn(dolc));
        return(0);
}

/*
 * execute login and newgrp directly
 */
int
dologin(t)
struct op *t;
{
        register char *cp;

        if (talking) {
                signal(SIGINT, SIG_DFL);
                signal(SIGQUIT, SIG_DFL);
        }
        cp = rexecve(t->words[0], t->words, makenv());
        prs(t->words[0]); prs(": "); err(cp);
        return(1);
}

int
doumask(t)
register struct op *t;
{
        register int i, n;
        register char *cp;

        if ((cp = t->words[1]) == NULL) {
                i = umask(0);
                umask(i);
                for (n=3*4; (n-=3) >= 0;)
                        putc('0'+((i>>n)&07));
                putc('\n');
        } else {
                for (n=0; *cp>='0' && *cp<='9'; cp++)
                        n = n*8 + (*cp-'0');
                umask(n);
        }
        return(0);
}

int
doexec(t)
register struct op *t;
{
        register i;
        jmp_buf ex;
        xint *ofail;

        t->ioact = NULL;
        for(i = 0; (t->words[i]=t->words[i+1]) != NULL; i++)
                ;
        if (i == 0)
                return(1);
        execflg = 1;
        ofail = failpt;
        if (setjmp(failpt = ex) == 0)
                execute(t, NOPIPE, NOPIPE, FEXEC);
        failpt = ofail;
        execflg = 0;
        return(1);
}

int
dodot(t)
struct op *t;
{
        register i;
        register char *sp, *tp;
        char *cp;

        if ((cp = t->words[1]) == NULL)
                return(0);
        sp = any('/', cp)? ":": path->value;
        while (*sp) {
                tp = e.linep;
                while (*sp && (*tp = *sp++) != ':')
                        tp++;
                if (tp != e.linep)
                        *tp++ = '/';
                for (i = 0; (*tp++ = cp[i++]) != '\0';)
                        ;
                if ((i = open(e.linep, 0)) >= 0) {
                        exstat = 0;
                        next(remap(i));
                        return(exstat);
                }
        }
        prs(cp);
        err(": not found");
        return(-1);
}

int
dowait(t)
struct op *t;
{
        register i;
        register char *cp;

        if ((cp = t->words[1]) != NULL) {
                i = getn(cp);
                if (i == 0)
                        return(0);
        } else
                i = -1;
        setstatus(waitfor(i, 1));
        return(0);
}

int
doread(t)
struct op *t;
{
        register char *cp, **wp;
        register nb;
        register int  nl = 0;

        if (t->words[1] == NULL) {
                err("Usage: read name ...");
                return(1);
        }
        for (wp = t->words+1; *wp; wp++) {
                for (cp = e.linep; !nl && cp < elinep-1; cp++)
                        if ((nb = read(0, cp, sizeof(*cp))) != sizeof(*cp) ||
                            (nl = (*cp == '\n')) ||
                            (wp[1] && any(*cp, ifs->value)))
                                break;
                *cp = 0;
                if (nb <= 0)
                        break;
                setval(lookup(*wp), e.linep);
        }
        return(nb <= 0);
}

int
doeval(t)
register struct op *t;
{
        return(RUN(awordlist, t->words+1, wdchar));
}

int
dotrap(t)
register struct op *t;
{
        register int  n, i;
        register int  resetsig;

        if (t->words[1] == NULL) {
                for (i=0; i<=_NSIG; i++)
                        if (trap[i]) {
                                prn(i);
                                prs(": ");
                                prs(trap[i]);
                                prs("\n");
                        }
                return(0);
        }
        resetsig = digit(*t->words[1]);
        for (i = resetsig ? 1 : 2; t->words[i] != NULL; ++i) {
                n = getsig(t->words[i]);
                xfree(trap[n]);
                trap[n] = 0;
                if (!resetsig) {
                        if (*t->words[1] != '\0') {
                                trap[n] = strsave(t->words[1], 0);
                                setsig(n, sig);
                        } else
                                setsig(n, SIG_IGN);
                } else {
                        if (talking)
                                if (n == SIGINT)
                                        setsig(n, onintr);
                                else
                                        setsig(n, n == SIGQUIT ? SIG_IGN 
                                                               : SIG_DFL);
                        else
                                setsig(n, SIG_DFL);
                }
        }
        return(0);
}

int
getsig(s)
char *s;
{
        register int n;

        if ((n = getn(s)) < 0 || n > _NSIG) {
                err("trap: bad signal number");
                n = 0;
        }
        return(n);
}

void
setsig(n, f)
register n;
_PROTOTYPE(void (*f), (int));
{
        if (n == 0)
                return;
        if (signal(n, SIG_IGN) != SIG_IGN || ourtrap[n]) {
                ourtrap[n] = 1;
                signal(n, f);
        }
}

int
getn(as)
char *as;
{
        register char *s;
        register n, m;

        s = as;
        m = 1;
        if (*s == '-') {
                m = -1;
                s++;
        }
        for (n = 0; digit(*s); s++)
                n = (n*10) + (*s-'0');
        if (*s) {
                prs(as);
                err(": bad number");
        }
        return(n*m);
}

int
dobreak(t)
struct op *t;
{
        return(brkcontin(t->words[1], 1));
}

int
docontinue(t)
struct op *t;
{
        return(brkcontin(t->words[1], 0));
}

static int
brkcontin(cp, val)
register char *cp;
int val;
{
        register struct brkcon *bc;
        register nl;

        nl = cp == NULL? 1: getn(cp);
        if (nl <= 0)
                nl = 999;
        do {
                if ((bc = brklist) == NULL)
                        break;
                brklist = bc->nextlev;
        } while (--nl);
        if (nl) {
                err("bad break/continue level");
                return(1);
        }
        isbreak = val;
        longjmp(bc->brkpt, 1);
        /* NOTREACHED */
}

int
doexit(t)
struct op *t;
{
        register char *cp;

        execflg = 0;
        if ((cp = t->words[1]) != NULL)
                setstatus(getn(cp));
        leave();
        /* NOTREACHED */
}

int
doexport(t)
struct op *t;
{
        rdexp(t->words+1, export, EXPORT);
        return(0);
}

int
doreadonly(t)
struct op *t;
{
        rdexp(t->words+1, ronly, RONLY);
        return(0);
}

static void
rdexp(wp, f, key)
register char **wp;
void (*f)();
int key;
{
        if (*wp != NULL) {
                for (; *wp != NULL; wp++)
                        if (checkname(*wp))
                                (*f)(lookup(*wp));
                        else
                                badid(*wp);
        } else
                putvlist(key, 1);
}

static void
badid(s)
register char *s;
{
        prs(s);
        err(": bad identifier");
}

int
doset(t)
register struct op *t;
{
        register struct var *vp;
        register char *cp;
        register n;

        if ((cp = t->words[1]) == NULL) {
                for (vp = vlist; vp; vp = vp->next)
                        varput(vp->name, 1);
                return(0);
        }
        if (*cp == '-') {
                /* bad: t->words++; */
                for(n = 0; (t->words[n]=t->words[n+1]) != NULL; n++)
                        ;
                if (*++cp == 0)
                        flag['x'] = flag['v'] = 0;
                else
                        for (; *cp; cp++)
                                switch (*cp) {
                                case 'e':
                                        if (!talking)
                                                flag['e']++;
                                        break;

                                default:
                                        if (*cp>='a' && *cp<='z')
                                                flag[*cp]++;
                                        break;
                                }
                setdash();
        }
        if (t->words[1]) {
                t->words[0] = dolv[0];
                for (n=1; t->words[n]; n++)
                        setarea((char *)t->words[n], 0);
                dolc = n-1;
                dolv = t->words;
                setval(lookup("#"), putn(dolc));
                setarea((char *)(dolv-1), 0);
        }
        return(0);
}

void
varput(s, out)
register char *s;
int out;
{
        if (letnum(*s)) {
                write(out, s, strlen(s));
                write(out, "\n", 1);
        }
}


#define SECS    60L
#define MINS    3600L

int
dotimes()
{
        struct tms tbuf;

        times(&tbuf);

        prn((int)(tbuf.tms_cutime / MINS));
        prs("m");
        prn((int)((tbuf.tms_cutime % MINS) / SECS));
        prs("s ");
        prn((int)(tbuf.tms_cstime / MINS));
        prs("m");
        prn((int)((tbuf.tms_cstime % MINS) / SECS));
        prs("s\n");
        return(0);
}

struct  builtin {
        char    *command;
        int     (*fn)();
};
static struct   builtin builtin[] = {
        ":",            dolabel,
        "cd",           dochdir,
        "shift",        doshift,
        "exec",         doexec,
        "wait",         dowait,
        "read",         doread,
        "eval",         doeval,
        "trap",         dotrap,
        "break",        dobreak,
        "continue",     docontinue,
        "exit",         doexit,
        "export",       doexport,
        "readonly",     doreadonly,
        "set",          doset,
        ".",            dodot,
        "umask",        doumask,
        "login",        dologin,
        "newgrp",       dologin,
        "times",        dotimes,
        0,
};

int (*inbuilt(s))()
register char *s;
{
        register struct builtin *bp;

        for (bp = builtin; bp->command != NULL; bp++)
                if (strcmp(bp->command, s) == 0)
                        return(bp->fn);
        return((int(*)())NULL);
}

---