sh1.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 "sh.h"
/* -------- sh.c -------- */
/*
 * shell
 */

/* #include "sh.h" */

int     intr;
int     inparse;
char    flags['z'-'a'+1];
char    *flag = flags-'a';
char    *elinep = line+sizeof(line)-5;
char    *null   = "";
int     heedint =1;
struct  env     e ={line, iostack, iostack-1,
                    (xint *)NULL, FDBASE, (struct env *)NULL};

extern  char    **environ;      /* environment pointer */

/*
 * default shell, search rules
 */
char    shellname[] = "/bin/sh";
char    search[] = ":/bin:/usr/bin";

_PROTOTYPE(void (*qflag), (int)) = SIG_IGN;

_PROTOTYPE(int main, (int argc, char **argv ));
_PROTOTYPE(int newfile, (char *s ));
_PROTOTYPE(static char *findeq, (char *cp ));
_PROTOTYPE(static char *cclass, (char *p, int sub ));
_PROTOTYPE(void initarea, (void));

int main(argc, argv)
int argc;
register char **argv;
{
        register int f;
        register char *s;
        int cflag;
        char *name, **ap;
        int (*iof)();

        initarea();
        if ((ap = environ) != NULL) {
                while (*ap)
                        assign(*ap++, !COPYV);
                for (ap = environ; *ap;)
                        export(lookup(*ap++));
        }
        closeall();
        areanum = 1;

        shell = lookup("SHELL");
        if (shell->value == null)
                setval(shell, shellname);
        export(shell);

        homedir = lookup("HOME");
        if (homedir->value == null)
                setval(homedir, "/");
        export(homedir);

        setval(lookup("$"), itoa(getpid(), 5));

        path = lookup("PATH");
        if (path->value == null)
                setval(path, search);
        export(path);

        ifs = lookup("IFS");
        if (ifs->value == null)
                setval(ifs, " \t\n");

        prompt = lookup("PS1");
        if (prompt->value == null)
#ifndef UNIXSHELL
                setval(prompt, "$ ");
#else
                setval(prompt, "% ");
#endif

        if (geteuid() == 0) {
                setval(prompt, "# ");
                prompt->status &= ~EXPORT;
        }
        cprompt = lookup("PS2");
        if (cprompt->value == null)
                setval(cprompt, "> ");

        iof = filechar;
        cflag = 0;
        name = *argv++;
        if (--argc >= 1) {
                if(argv[0][0] == '-' && argv[0][1] != '\0') {
                        for (s = argv[0]+1; *s; s++)
                                switch (*s) {
                                case 'c':
                                        prompt->status &= ~EXPORT;
                                        cprompt->status &= ~EXPORT;
                                        setval(prompt, "");
                                        setval(cprompt, "");
                                        cflag = 1;
                                        if (--argc > 0)
                                                PUSHIO(aword, *++argv, iof = nlchar);
                                        break;
        
                                case 'q':
                                        qflag = SIG_DFL;
                                        break;

                                case 's':
                                        /* standard input */
                                        break;

                                case 't':
                                        prompt->status &= ~EXPORT;
                                        setval(prompt, "");
                                        iof = linechar;
                                        break;
        
                                case 'i':
                                        talking++;
                                default:
                                        if (*s>='a' && *s<='z')
                                                flag[*s]++;
                                }
                } else {
                        argv--;
                        argc++;
                }
                if (iof == filechar && --argc > 0) {
                        setval(prompt, "");
                        setval(cprompt, "");
                        prompt->status &= ~EXPORT;
                        cprompt->status &= ~EXPORT;
                        if (newfile(name = *++argv))
                                exit(1);
                }
        }
        setdash();
        if (e.iop < iostack) {
                PUSHIO(afile, 0, iof);
                if (isatty(0) && isatty(1) && !cflag)
                        talking++;
        }
        signal(SIGQUIT, qflag);
        if (name && name[0] == '-') {
                talking++;
                if ((f = open(".profile", 0)) >= 0)
                        next(remap(f));
                if ((f = open("/etc/profile", 0)) >= 0)
                        next(remap(f));
        }
        if (talking)
                signal(SIGTERM, sig);
        if (signal(SIGINT, SIG_IGN) != SIG_IGN)
                signal(SIGINT, onintr);
        dolv = argv;
        dolc = argc;
        dolv[0] = name;
        if (dolc > 1)
                for (ap = ++argv; --argc > 0;)
                        if (assign(*ap = *argv++, !COPYV))
                                dolc--; /* keyword */
                        else
                                ap++;
        setval(lookup("#"), putn((--dolc < 0) ? (dolc = 0) : dolc));

        for (;;) {
                if (talking && e.iop <= iostack)
                        prs(prompt->value);
                onecommand();
        }
}

void
setdash()
{
        register char *cp, c;
        char m['z'-'a'+1];

        cp = m;
        for (c='a'; c<='z'; c++)
                if (flag[c])
                        *cp++ = c;
        *cp = 0;
        setval(lookup("-"), m);
}

int
newfile(s)
register char *s;
{
        register f;

        if (strcmp(s, "-") != 0) {
                f = open(s, 0);
                if (f < 0) {
                        prs(s);
                        err(": cannot open");
                        return(1);
                }
        } else
                f = 0;
        next(remap(f));
        return(0);
}

void
onecommand()
{
        register i;
        jmp_buf m1;

        while (e.oenv)
                quitenv();
        areanum = 1;
        freehere(areanum);
        freearea(areanum);
        garbage();
        wdlist = 0;
        iolist = 0;
        e.errpt = 0;
        e.linep = line;
        yynerrs = 0;
        multiline = 0;
        inparse = 1;
        intr = 0;
        execflg = 0;
        setjmp(failpt = m1);    /* Bruce Evans' fix */
        if (setjmp(failpt = m1) || yyparse() || intr) {
                while (e.oenv)
                        quitenv();
                scraphere();
                if (!talking && intr)
                        leave();
                inparse = 0;
                intr = 0;
                return;
        }
        inparse = 0;
        brklist = 0;
        intr = 0;
        execflg = 0;
        if (!flag['n'])
                execute(outtree, NOPIPE, NOPIPE, 0);
        if (!talking && intr) {
                execflg = 0;
                leave();
        }
        if ((i = trapset) != 0) {
                trapset = 0;
                runtrap(i);
        }
}

void
fail()
{
        longjmp(failpt, 1);
        /* NOTREACHED */
}

void
leave()
{
        if (execflg)
                fail();
        scraphere();
        freehere(1);
        runtrap(0);
        exit(exstat);
        /* NOTREACHED */
}

void
warn(s)
register char *s;
{
        if(*s) {
                prs(s);
                exstat = -1;
        }
        prs("\n");
        if (flag['e'])
                leave();
}

void
err(s)
char *s;
{
        warn(s);
        if (flag['n'])
                return;
        if (!talking)
                leave();
        if (e.errpt)
                longjmp(e.errpt, 1);
        closeall();
        e.iop = e.iobase = iostack;
}

int
newenv(f)
int f;
{
        register struct env *ep;

        if (f) {
                quitenv();
                return(1);
        }
        ep = (struct env *) space(sizeof(*ep));
        if (ep == NULL) {
                while (e.oenv)
                        quitenv();
                fail();
        }
        *ep = e;
        e.oenv = ep;
        e.errpt = errpt;
        return(0);
}

void
quitenv()
{
        register struct env *ep;
        register fd;

        if ((ep = e.oenv) != NULL) {
                fd = e.iofd;
                e = *ep;
                /* should close `'d files */
                DELETE(ep);
                while (--fd >= e.iofd)
                        close(fd);
        }
}

/*
 * Is any character from s1 in s2?
 */
int
anys(s1, s2)
register char *s1, *s2;
{
        while (*s1)
                if (any(*s1++, s2))
                        return(1);
        return(0);
}

/*
 * Is character c in s?
 */
int
any(c, s)
register int c;
register char *s;
{
        while (*s)
                if (*s++ == c)
                        return(1);
        return(0);
}

char *
putn(n)
register int n;
{
        return(itoa(n, -1));
}

char *
itoa(u, n)
register unsigned u;
int n;
{
        register char *cp;
        static char s[20];
        int m;

        m = 0;
        if (n < 0 && (int) u < 0) {
                m++;
                u = -u;
        }
        cp = s+sizeof(s);
        *--cp = 0;
        do {
                *--cp = u%10 + '0';
                u /= 10;
        } while (--n > 0 || u);
        if (m)
                *--cp = '-';
        return(cp);
}

void
next(f)
int f;
{
        PUSHIO(afile, f, filechar);
}

void
onintr(s)
int s;                          /* ANSI C requires a parameter */
{
        signal(SIGINT, onintr);
        intr = 1;
        if (talking) {
                if (inparse) {
                        prs("\n");
                        fail();
                }
        }
        else if (heedint) {
                execflg = 0;
                leave();
        }
}

int
letter(c)
register c;
{
        return((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_');
}

int
digit(c)
register c;
{
        return(c >= '0' && c <= '9');
}

int
letnum(c)
register c;
{
        return(letter(c) || digit(c));
}

char *
space(n)
int n;
{
        register char *cp;

        if ((cp = getcell(n)) == 0)
                err("out of string space");
        return(cp);
}

char *
strsave(s, a)
register char *s;
int a;
{
        register char *cp, *xp;

        if ((cp = space(strlen(s)+1)) != NULL) {
                setarea((char *)cp, a);
                for (xp = cp; (*xp++ = *s++) != '\0';)
                        ;
                return(cp);
        }
        return("");
}

void
xfree(s)
register char *s;
{
        DELETE(s);
}

/*
 * trap handling
 */
void
sig(i)
register int i;
{
        trapset = i;
        signal(i, sig);
}

void runtrap(i)
int i;
{
        char *trapstr;

        if ((trapstr = trap[i]) == NULL)
                return;
        if (i == 0)
                trap[i] = 0;
        RUN(aword, trapstr, nlchar);
}

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

/*
 * Find the given name in the dictionary
 * and return its value.  If the name was
 * not previously there, enter it now and
 * return a null value.
 */
struct var *
lookup(n)
register char *n;
{
        register struct var *vp;
        register char *cp;
        register int c;
        static struct var dummy;

        if (digit(*n)) {
                dummy.name = n;
                for (c = 0; digit(*n) && c < 1000; n++)
                        c = c*10 + *n-'0';
                dummy.status = RONLY;
                dummy.value = c <= dolc? dolv[c]: null;
                return(&dummy);
        }
        for (vp = vlist; vp; vp = vp->next)
                if (eqname(vp->name, n))
                        return(vp);
        cp = findeq(n);
        vp = (struct var *)space(sizeof(*vp));
        if (vp == 0 || (vp->name = space((int)(cp-n)+2)) == 0) {
                dummy.name = dummy.value = "";
                return(&dummy);
        }
        for (cp = vp->name; (*cp = *n++) && *cp != '='; cp++)
                ;
        if (*cp == 0)
                *cp = '=';
        *++cp = 0;
        setarea((char *)vp, 0);
        setarea((char *)vp->name, 0);
        vp->value = null;
        vp->next = vlist;
        vp->status = GETCELL;
        vlist = vp;
        return(vp);
}

/*
 * give variable at `vp' the value `val'.
 */
void
setval(vp, val)
struct var *vp;
char *val;
{
        nameval(vp, val, (char *)NULL);
}

/*
 * if name is not NULL, it must be
 * a prefix of the space `val',
 * and end with `='.
 * this is all so that exporting
 * values is reasonably painless.
 */
void
nameval(vp, val, name)
register struct var *vp;
char *val, *name;
{
        register char *cp, *xp;
        char *nv;
        int fl;

        if (vp->status & RONLY) {
                for (xp = vp->name; *xp && *xp != '=';)
                        putc(*xp++);
                err(" is read-only");
                return;
        }
        fl = 0;
        if (name == NULL) {
                xp = space(strlen(vp->name)+strlen(val)+2);
                if (xp == 0)
                        return;
                /* make string:  name=value */
                setarea((char *)xp, 0);
                name = xp;
                for (cp = vp->name; (*xp = *cp++) && *xp!='='; xp++)
                        ;
                if (*xp++ == 0)
                        xp[-1] = '=';
                nv = xp;
                for (cp = val; (*xp++ = *cp++) != '\0';)
                        ;
                val = nv;
                fl = GETCELL;
        }
        if (vp->status & GETCELL)
                xfree(vp->name);        /* form new string `name=value' */
        vp->name = name;
        vp->value = val;
        vp->status |= fl;
}

void
export(vp)
struct var *vp;
{
        vp->status |= EXPORT;
}

void
ronly(vp)
struct var *vp;
{
        if (letter(vp->name[0]))        /* not an internal symbol ($# etc) */
                vp->status |= RONLY;
}

int
isassign(s)
register char *s;
{
        if (!letter((int)*s))
                return(0);
        for (; *s != '='; s++)
                if (*s == 0 || !letnum(*s))
                        return(0);
        return(1);
}

int
assign(s, cf)
register char *s;
int cf;
{
        register char *cp;
        struct var *vp;

        if (!letter(*s))
                return(0);
        for (cp = s; *cp != '='; cp++)
                if (*cp == 0 || !letnum(*cp))
                        return(0);
        vp = lookup(s);
        nameval(vp, ++cp, cf == COPYV? (char *)NULL: s);
        if (cf != COPYV)
                vp->status &= ~GETCELL;
        return(1);
}

int
checkname(cp)
register char *cp;
{
        if (!letter(*cp++))
                return(0);
        while (*cp)
                if (!letnum(*cp++))
                        return(0);
        return(1);
}

void
putvlist(f, out)
register int f, out;
{
        register struct var *vp;

        for (vp = vlist; vp; vp = vp->next)
                if (vp->status & f && letter(*vp->name)) {
                        if (vp->status & EXPORT)
                                write(out, "export ", 7);
                        if (vp->status & RONLY)
                                write(out, "readonly ", 9);
                        write(out, vp->name, (int)(findeq(vp->name) - vp->name));
                        write(out, "\n", 1);
                }
}

int
eqname(n1, n2)
register char *n1, *n2;
{
        for (; *n1 != '=' && *n1 != 0; n1++)
                if (*n2++ != *n1)
                        return(0);
        return(*n2 == 0 || *n2 == '=');
}

static char *
findeq(cp)
register char *cp;
{
        while (*cp != '\0' && *cp != '=')
                cp++;
        return(cp);
}

/* -------- gmatch.c -------- */
/*
 * int gmatch(string, pattern)
 * char *string, *pattern;
 *
 * Match a pattern as in sh(1).
 */

#define CMASK   0377
#define QUOTE   0200
#define QMASK   (CMASK&~QUOTE)
#define NOT     '!'     /* might use ^ */

int
gmatch(s, p)
register char *s, *p;
{
        register int sc, pc;

        if (s == NULL || p == NULL)
                return(0);
        while ((pc = *p++ & CMASK) != '\0') {
                sc = *s++ & QMASK;
                switch (pc) {
                case '[':
                        if ((p = cclass(p, sc)) == NULL)
                                return(0);
                        break;

                case '?':
                        if (sc == 0)
                                return(0);
                        break;

                case '*':
                        s--;
                        do {
                                if (*p == '\0' || gmatch(s, p))
                                        return(1);
                        } while (*s++ != '\0');
                        return(0);

                default:
                        if (sc != (pc&~QUOTE))
                                return(0);
                }
        }
        return(*s == 0);
}

static char *
cclass(p, sub)
register char *p;
register int sub;
{
        register int c, d, not, found;

        if ((not = *p == NOT) != 0)
                p++;
        found = not;
        do {
                if (*p == '\0')
                        return((char *)NULL);
                c = *p & CMASK;
                if (p[1] == '-' && p[2] != ']') {
                        d = p[2] & CMASK;
                        p++;
                } else
                        d = c;
                if (c == sub || (c <= sub && sub <= d))
                        found = !not;
        } while (*++p != ']');
        return(found? p+1: (char *)NULL);
}

/* -------- area.c -------- */
#define REGSIZE         sizeof(struct region)
#define GROWBY          256
#undef  SHRINKBY        64
#define FREE 32767
#define BUSY 0
#define ALIGN (sizeof(int)-1)

/* #include "area.h" */

struct region {
        struct  region *next;
        int     area;
};

/*
 * All memory between (char *)areabot and (char *)(areatop+1) is
 * exclusively administered by the area management routines.
 * It is assumed that sbrk() and brk() manipulate the high end.
 */
static  struct region *areabot;         /* bottom of area */
static  struct region *areatop;         /* top of area */
static  struct region *areanxt;         /* starting point of scan */

void
initarea()
{
        while ((int)sbrk(0) & ALIGN)
                sbrk(1);
        areabot = (struct region *)sbrk(REGSIZE);
        areabot->next = areabot;
        areabot->area = BUSY;
        areatop = areabot;
        areanxt = areabot;
}

char *
getcell(nbytes)
unsigned nbytes;
{
        register int nregio;
        register struct region *p, *q;
        register i;

        if (nbytes == 0)
                abort();        /* silly and defeats the algorithm */
        /*
         * round upwards and add administration area
         */
        nregio = (nbytes+(REGSIZE-1))/REGSIZE + 1;
        for (p = areanxt;;) {
                if (p->area > areanum) {
                        /*
                         * merge free cells
                         */
                        while ((q = p->next)->area > areanum && q != areanxt)
                                p->next = q->next;
                        /*
                         * exit loop if cell big enough
                         */
                        if (q >= p + nregio)
                                goto found;
                }
                p = p->next;
                if (p == areanxt)
                        break;
        }
        i = nregio >= GROWBY ? nregio : GROWBY;
        p = (struct region *)sbrk(i * REGSIZE);
        if (p == (struct region *)-1)
                return((char *)NULL);
        p--;
        if (p != areatop)
                abort();        /* allocated areas are contiguous */
        q = p + i;
        p->next = q;
        p->area = FREE;
        q->next = areabot;
        q->area = BUSY;
        areatop = q;
found:
        /*
         * we found a FREE area big enough, pointed to by 'p', and up to 'q'
         */
        areanxt = p + nregio;
        if (areanxt < q) {
                /*
                 * split into requested area and rest
                 */
                if (areanxt+1 > q)
                        abort();        /* insufficient space left for admin */
                areanxt->next = q;
                areanxt->area = FREE;
                p->next = areanxt;
        }
        p->area = areanum;
        return((char *)(p+1));
}

void
freecell(cp)
char *cp;
{
        register struct region *p;

        if ((p = (struct region *)cp) != NULL) {
                p--;
                if (p < areanxt)
                        areanxt = p;
                p->area = FREE;
        }
}

void
freearea(a)
register int a;
{
        register struct region *p, *top;

        top = areatop;
        for (p = areabot; p != top; p = p->next)
                if (p->area >= a)
                        p->area = FREE;
}

void
setarea(cp,a)
char *cp;
int a;
{
        register struct region *p;

        if ((p = (struct region *)cp) != NULL)
                (p-1)->area = a;
}

int
getarea(cp)
char *cp;
{
        return ((struct region*)cp-1)->area;
}

void
garbage()
{
        register struct region *p, *q, *top;

        top = areatop;
        for (p = areabot; p != top; p = p->next) {
                if (p->area > areanum) {
                        while ((q = p->next)->area > areanum)
                                p->next = q->next;
                        areanxt = p;
                }
        }
#ifdef SHRINKBY
        if (areatop >= q + SHRINKBY && q->area > areanum) {
                brk((char *)(q+1));
                q->next = areabot;
                q->area = BUSY;
                areatop = q;
        }
#endif
}

---