URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [uclinux/] [userland/] [sh/] [sh1.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


#define Extern extern
#include <sys/types.h>
#include <signal.h>
 
#include <stdio.h>
#include <errno.h>
#include <setjmp.h>
#include <stdlib.h>
#include "sh.h"
 
/* Globals */
char    **dolv;
int     dolc;
int     exstat;
char    gflg;
int     talking;        /* interactive (talking-type wireless) */
int     execflg;
int     multiline;      /* \n changed to ; */
struct  op      *outtree;       /* result from parser */
xint    *failpt;
xint    *errpt;
struct  brkcon  *brklist;
int     isbreak;
struct  wdblock *wdlist;
struct  wdblock *iolist;
char    *trap[_NSIG+1];
char    ourtrap[_NSIG+1];
int     trapset;        /* trap pending */
int     yynerrs;        /* yacc */
char    line[LINELIM];
struct  var     *vlist;         /* dictionary */
struct  var     *homedir;       /* home directory */
struct  var     *prompt;        /* main prompt */
struct  var     *cprompt;       /* continuation prompt */
struct  var     *path;          /* search path for commands */
struct  var     *shell;         /* shell to interpret command files */
struct  var     *ifs;           /* field separators */
struct  ioarg ioargstack[NPUSH];
struct  io      iostack[NPUSH];
int     areanum;        /* current allocation area */
 
 
/* -------- 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";
 
void (*qflag)(int) = SIG_IGN;
//_PROTOTYPE(void (*qflag), (int)) = SIG_IGN;
 
int main(int argc, char **argv);
int newfile(char *s);
static char *findeq(char *cp);
static char *cclass(char *p, int sub);
static void initarea(void);
 
 
#undef abort
#define abort() exit(1)
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[(int)*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;
        register int 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 int 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 int 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 int 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 int c;
{
        return((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_');
}
 
int
digit(c)
register int c;
{
        return(c >= '0' && c <= '9');
}
 
int
letnum(c)
register int 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++, stderr);
                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);
}
 
 
//#if 0
 
 
/* -------- 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 */
static void * brktop;
static void * brkaddr;
 
//#define sbrk(X) ({ void * __q = -1; if (brkaddr + (int)(X) < brktop) { __q = brkaddr; brkaddr+=(int)(X); } __q;})
 
static void
initarea()
{
        brkaddr = malloc(65000);
        brktop = brkaddr + 65000;
 
        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 int i;
 
        if (nbytes == 0) {
                puts("Boo");
                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) {
                puts("not contig");
                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) {
                        puts("OOM");
                        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
}
 
//#endif

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [uclinux/] [userland/] [sh/] [sh1.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	199	simons	`#define Extern extern`
2			`#include <sys/types.h>`
3			`#include <signal.h>`
4
5			`#include <stdio.h>`
6			`#include <errno.h>`
7			`#include <setjmp.h>`
8			`#include <stdlib.h>`
9			`#include "sh.h"`
10
11			`/* Globals */`
12			`char **dolv;`
13			`int dolc;`
14			`int exstat;`
15			`char gflg;`
16			`int talking; /* interactive (talking-type wireless) */`
17			`int execflg;`
18			`int multiline; /* \n changed to ; */`
19			`struct op outtree; / result from parser */`
20			`xint *failpt;`
21			`xint *errpt;`
22			`struct brkcon *brklist;`
23			`int isbreak;`
24			`struct wdblock *wdlist;`
25			`struct wdblock *iolist;`
26			`char *trap[_NSIG+1];`
27			`char ourtrap[_NSIG+1];`
28			`int trapset; /* trap pending */`
29			`int yynerrs; /* yacc */`
30			`char line[LINELIM];`
31			`struct var vlist; / dictionary */`
32			`struct var homedir; / home directory */`
33			`struct var prompt; / main prompt */`
34			`struct var cprompt; / continuation prompt */`
35			`struct var path; / search path for commands */`
36			`struct var shell; / shell to interpret command files */`
37			`struct var ifs; / field separators */`
38			`struct ioarg ioargstack[NPUSH];`
39			`struct io iostack[NPUSH];`
40			`int areanum; /* current allocation area */`
41
42
43			`/* -------- sh.c -------- */`
44			`/*`
45			`* shell`
46			`*/`
47
48			`/* #include "sh.h" */`
49
50			`int intr;`
51			`int inparse;`
52			`char flags['z'-'a'+1];`
53			`char *flag = flags-'a';`
54			`char *elinep = line+sizeof(line)-5;`
55			`char *null = "";`
56			`int heedint =1;`
57			`struct env e ={line, iostack, iostack-1,`
58			`(xint )NULL, FDBASE, (struct env )NULL};`
59
60			`extern char *environ; / environment pointer */`
61
62			`/*`
63			`* default shell, search rules`
64			`*/`
65			`char shellname[] = "/bin/sh";`
66			`char search[] = ":/bin:/usr/bin";`
67
68			`void (*qflag)(int) = SIG_IGN;`
69			`//_PROTOTYPE(void (*qflag), (int)) = SIG_IGN;`
70
71			`int main(int argc, char **argv);`
72			`int newfile(char *s);`
73			`static char findeq(char cp);`
74			`static char cclass(char p, int sub);`
75			`static void initarea(void);`
76
77
78			`#undef abort`
79			`#define abort() exit(1)`
80			`int main(argc, argv)`
81			`int argc;`
82			`register char **argv;`
83			`{`
84			`register int f;`
85			`register char *s;`
86			`int cflag;`
87			`char name, *ap;`
88			`int (*iof)();`
89			`initarea();`
90
91			`if ((ap = environ) != NULL) {`
92			`while (*ap)`
93			`assign(*ap++, !COPYV);`
94			`for (ap = environ; *ap;)`
95			`export(lookup(*ap++));`
96			`}`
97			`closeall();`
98			`areanum = 1;`
99
100			`shell = lookup("SHELL");`
101			`if (shell->value == null)`
102			`setval(shell, shellname);`
103			`export(shell);`
104
105			`homedir = lookup("HOME");`
106			`if (homedir->value == null)`
107			`setval(homedir, "/");`
108			`export(homedir);`
109
110			`setval(lookup("$"), itoa(getpid(), 5));`
111
112			`path = lookup("PATH");`
113			`if (path->value == null)`
114			`setval(path, search);`
115			`export(path);`
116
117			`ifs = lookup("IFS");`
118			`if (ifs->value == null)`
119			`setval(ifs, " \t\n");`
120
121			`prompt = lookup("PS1");`
122			`if (prompt->value == null)`
123			`#ifndef UNIXSHELL`
124			`setval(prompt, "$ ");`
125			`#else`
126			`setval(prompt, "% ");`
127			`#endif`
128
129			`if (geteuid() == 0) {`
130			`setval(prompt, "# ");`
131			`prompt->status &= ~EXPORT;`
132			`}`
133			`cprompt = lookup("PS2");`
134			`if (cprompt->value == null)`
135			`setval(cprompt, "> ");`
136
137			`iof = filechar;`
138			`cflag = 0;`
139			`name = *argv++;`
140			`if (--argc >= 1) {`
141			`if(argv[0][0] == '-' && argv[0][1] != '\0') {`
142			`for (s = argv[0]+1; *s; s++)`
143			`switch (*s) {`
144			`case 'c':`
145			`prompt->status &= ~EXPORT;`
146			`cprompt->status &= ~EXPORT;`
147			`setval(prompt, "");`
148			`setval(cprompt, "");`
149			`cflag = 1;`
150			`if (--argc > 0)`
151			`PUSHIO(aword, *++argv, iof = nlchar);`
152			`break;`
153
154			`case 'q':`
155			`qflag = SIG_DFL;`
156			`break;`
157
158			`case 's':`
159			`/* standard input */`
160			`break;`
161
162			`case 't':`
163			`prompt->status &= ~EXPORT;`
164			`setval(prompt, "");`
165			`iof = linechar;`
166			`break;`
167
168			`case 'i':`
169			`talking++;`
170			`default:`
171			`if (s>='a' && s<='z')`
172			`flag[(int)*s]++;`
173			`}`
174			`} else {`
175			`argv--;`
176			`argc++;`
177			`}`
178			`if (iof == filechar && --argc > 0) {`
179			`setval(prompt, "");`
180			`setval(cprompt, "");`
181			`prompt->status &= ~EXPORT;`
182			`cprompt->status &= ~EXPORT;`
183			`if (newfile(name = *++argv))`
184			`exit(1);`
185			`}`
186			`}`
187			`setdash();`
188			`if (e.iop < iostack) {`
189			`PUSHIO(afile, 0, iof);`
190			`if (isatty(0) && isatty(1) && !cflag)`
191			`talking++;`
192			`}`
193			`signal(SIGQUIT, qflag);`
194			`if (name && name[0] == '-') {`
195			`talking++;`
196			`if ((f = open(".profile", 0)) >= 0)`
197			`next(remap(f));`
198			`if ((f = open("/etc/profile", 0)) >= 0)`
199			`next(remap(f));`
200			`}`
201			`if (talking)`
202			`signal(SIGTERM, sig);`
203			`if (signal(SIGINT, SIG_IGN) != SIG_IGN)`
204			`signal(SIGINT, onintr);`
205			`dolv = argv;`
206			`dolc = argc;`
207			`dolv[0] = name;`
208			`if (dolc > 1) {`
209			`for (ap = ++argv; --argc > 0;) {`
210			`if (assign(ap = argv++, !COPYV)) {`
211			`dolc--; /* keyword */`
212			`} else {`
213			`ap++;`
214			`}`
215			`}`
216			`}`
217			`setval(lookup("#"), putn((--dolc < 0) ? (dolc = 0) : dolc));`
218
219			`for (;;) {`
220			`if (talking && e.iop <= iostack)`
221			`prs(prompt->value);`
222			`onecommand();`
223			`}`
224			`}`
225
226			`void`
227			`setdash()`
228			`{`
229			`register char *cp;`
230			`register int c;`
231			`char m['z'-'a'+1];`
232
233			`cp = m;`
234			`for (c='a'; c<='z'; c++)`
235			`if (flag[c])`
236			`*cp++ = c;`
237			`*cp = 0;`
238			`setval(lookup("-"), m);`
239			`}`
240
241			`int`
242			`newfile(s)`
243			`register char *s;`
244			`{`
245			`register int f;`
246
247			`if (strcmp(s, "-") != 0) {`
248			`f = open(s, 0);`
249			`if (f < 0) {`
250			`prs(s);`
251			`err(": cannot open");`
252			`return(1);`
253			`}`
254			`} else`
255			`f = 0;`
256			`next(remap(f));`
257			`return(0);`
258			`}`
259
260			`void`
261			`onecommand()`
262			`{`
263			`register int i;`
264			`jmp_buf m1;`
265
266			`while (e.oenv)`
267			`quitenv();`
268			`areanum = 1;`
269			`freehere(areanum);`
270			`freearea(areanum);`
271			`garbage();`
272			`wdlist = 0;`
273			`iolist = 0;`
274			`e.errpt = 0;`
275			`e.linep = line;`
276			`yynerrs = 0;`
277			`multiline = 0;`
278			`inparse = 1;`
279			`intr = 0;`
280			`execflg = 0;`
281			`setjmp(failpt = m1); /* Bruce Evans' fix */`
282			`if (setjmp(failpt = m1) \|\| yyparse() \|\| intr) {`
283			`while (e.oenv)`
284			`quitenv();`
285			`scraphere();`
286			`if (!talking && intr)`
287			`leave();`
288			`inparse = 0;`
289			`intr = 0;`
290			`return;`
291			`}`
292			`inparse = 0;`
293			`brklist = 0;`
294			`intr = 0;`
295			`execflg = 0;`
296			`if (!flag['n'])`
297			`execute(outtree, NOPIPE, NOPIPE, 0);`
298			`if (!talking && intr) {`
299			`execflg = 0;`
300			`leave();`
301			`}`
302			`if ((i = trapset) != 0) {`
303			`trapset = 0;`
304			`runtrap(i);`
305			`}`
306			`}`
307
308			`void`
309			`fail()`
310			`{`
311			`longjmp(failpt, 1);`
312			`/* NOTREACHED */`
313			`}`
314
315			`void`
316			`leave()`
317			`{`
318			`if (execflg)`
319			`fail();`
320			`scraphere();`
321			`freehere(1);`
322			`runtrap(0);`
323			`exit(exstat);`
324			`/* NOTREACHED */`
325			`}`
326
327			`void`
328			`warn(s)`
329			`register char *s;`
330			`{`
331			`if(*s) {`
332			`prs(s);`
333			`exstat = -1;`
334			`}`
335			`prs("\n");`
336			`if (flag['e'])`
337			`leave();`
338			`}`
339
340			`void`
341			`err(s)`
342			`char *s;`
343			`{`
344			`warn(s);`
345			`if (flag['n'])`
346			`return;`
347			`if (!talking)`
348			`leave();`
349			`if (e.errpt)`
350			`longjmp(e.errpt, 1);`
351			`closeall();`
352			`e.iop = e.iobase = iostack;`
353			`}`
354
355			`int`
356			`newenv(f)`
357			`int f;`
358			`{`
359			`register struct env *ep;`
360
361			`if (f) {`
362			`quitenv();`
363			`return(1);`
364			`}`
365			`ep = (struct env ) space(sizeof(ep));`
366			`if (ep == NULL) {`
367			`while (e.oenv)`
368			`quitenv();`
369			`fail();`
370			`}`
371			`*ep = e;`
372			`e.oenv = ep;`
373			`e.errpt = errpt;`
374			`return(0);`
375			`}`
376
377			`void`
378			`quitenv()`
379			`{`
380			`register struct env *ep;`
381			`register int fd;`
382
383			`if ((ep = e.oenv) != NULL) {`
384			`fd = e.iofd;`
385			`e = *ep;`
386			/* should close `'d files */
387			`DELETE(ep);`
388			`while (--fd >= e.iofd)`
389			`close(fd);`
390			`}`
391			`}`
392
393			`/*`
394			`* Is any character from s1 in s2?`
395			`*/`
396			`int`
397			`anys(s1, s2)`
398			`register char s1, s2;`
399			`{`
400			`while (*s1)`
401			`if (any(*s1++, s2))`
402			`return(1);`
403			`return(0);`
404			`}`
405
406			`/*`
407			`* Is character c in s?`
408			`*/`
409			`int`
410			`any(c, s)`
411			`register int c;`
412			`register char *s;`
413			`{`
414			`while (*s)`
415			`if (*s++ == c)`
416			`return(1);`
417			`return(0);`
418			`}`
419
420			`char *`
421			`putn(n)`
422			`register int n;`
423			`{`
424			`return(itoa(n, -1));`
425			`}`
426
427			`char *`
428			`itoa(u, n)`
429			`register unsigned u;`
430			`int n;`
431			`{`
432			`register char *cp;`
433			`static char s[20];`
434			`int m;`
435
436			`m = 0;`
437			`if (n < 0 && (int) u < 0) {`
438			`m++;`
439			`u = -u;`
440			`}`
441			`cp = s+sizeof(s);`
442			`*--cp = 0;`
443			`do {`
444			`*--cp = u%10 + '0';`
445			`u /= 10;`
446			`} while (--n > 0 \|\| u);`
447			`if (m)`
448			`*--cp = '-';`
449			`return(cp);`
450			`}`
451
452			`void`
453			`next(f)`
454			`int f;`
455			`{`
456			`PUSHIO(afile, f, filechar);`
457			`}`
458
459			`void`
460			`onintr(s)`
461			`int s; /* ANSI C requires a parameter */`
462			`{`
463			`signal(SIGINT, onintr);`
464			`intr = 1;`
465			`if (talking) {`
466			`if (inparse) {`
467			`prs("\n");`
468			`fail();`
469			`}`
470			`}`
471			`else if (heedint) {`
472			`execflg = 0;`
473			`leave();`
474			`}`
475			`}`
476
477			`int`
478			`letter(c)`
479			`register int c;`
480			`{`
481			`return((c >= 'a' && c <= 'z') \|\| (c >= 'A' && c <= 'Z') \|\| c == '_');`
482			`}`
483
484			`int`
485			`digit(c)`
486			`register int c;`
487			`{`
488			`return(c >= '0' && c <= '9');`
489			`}`
490
491			`int`
492			`letnum(c)`
493			`register int c;`
494			`{`
495			`return(letter(c) \|\| digit(c));`
496			`}`
497
498			`char *`
499			`space(n)`
500			`int n;`
501			`{`
502			`register char *cp;`
503
504			`if ((cp = getcell(n)) == 0)`
505			`err("out of string space");`
506			`return(cp);`
507			`}`
508
509			`char *`
510			`strsave(s, a)`
511			`register char *s;`
512			`int a;`
513			`{`
514			`register char cp, xp;`
515
516			`if ((cp = space(strlen(s)+1)) != NULL) {`
517			`setarea((char *)cp, a);`
518			`for (xp = cp; (xp++ = s++) != '\0';)`
519			`;`
520			`return(cp);`
521			`}`
522			`return("");`
523			`}`
524
525			`void`
526			`xfree(s)`
527			`register char *s;`
528			`{`
529			`DELETE(s);`
530			`}`
531
532			`/*`
533			`* trap handling`
534			`*/`
535			`void`
536			`sig(i)`
537			`register int i;`
538			`{`
539			`trapset = i;`
540			`signal(i, sig);`
541			`}`
542
543			`void runtrap(i)`
544			`int i;`
545			`{`
546			`char *trapstr;`
547
548			`if ((trapstr = trap[i]) == NULL)`
549			`return;`
550			`if (i == 0)`
551			`trap[i] = 0;`
552			`RUN(aword, trapstr, nlchar);`
553			`}`
554
555			`/* -------- var.c -------- */`
556			`/* #include "sh.h" */`
557
558			`/*`
559			`* Find the given name in the dictionary`
560			`* and return its value. If the name was`
561			`* not previously there, enter it now and`
562			`* return a null value.`
563			`*/`
564			`struct var *`
565			`lookup(n)`
566			`register char *n;`
567			`{`
568			`register struct var *vp;`
569			`register char *cp;`
570			`register int c;`
571			`static struct var dummy;`
572
573			`if (digit(*n)) {`
574			`dummy.name = n;`
575			`for (c = 0; digit(*n) && c < 1000; n++)`
576			`c = c10 + n-'0';`
577			`dummy.status = RONLY;`
578			`dummy.value = c <= dolc? dolv[c]: null;`
579			`return(&dummy);`
580			`}`
581			`for (vp = vlist; vp; vp = vp->next)`
582			`if (eqname(vp->name, n))`
583			`return(vp);`
584			`cp = findeq(n);`
585			`vp = (struct var )space(sizeof(vp));`
586			`if (vp == 0 \|\| (vp->name = space((int)(cp-n)+2)) == 0) {`
587			`dummy.name = dummy.value = "";`
588			`return(&dummy);`
589			`}`
590			`for (cp = vp->name; (cp = n++) && *cp != '='; cp++)`
591			`;`
592			`if (*cp == 0)`
593			`*cp = '=';`
594			`*++cp = 0;`
595			`setarea((char *)vp, 0);`
596			`setarea((char *)vp->name, 0);`
597			`vp->value = null;`
598			`vp->next = vlist;`
599			`vp->status = GETCELL;`
600			`vlist = vp;`
601			`return(vp);`
602			`}`
603
604			`/*`
605			* give variable at `vp' the value `val'.
606			`*/`
607			`void`
608			`setval(vp, val)`
609			`struct var *vp;`
610			`char *val;`
611			`{`
612			`nameval(vp, val, (char *)NULL);`
613			`}`
614
615			`/*`
616			`* if name is not NULL, it must be`
617			* a prefix of the space `val',
618			* and end with `='.
619			`* this is all so that exporting`
620			`* values is reasonably painless.`
621			`*/`
622			`void`
623			`nameval(vp, val, name)`
624			`register struct var *vp;`
625			`char val, name;`
626			`{`
627			`register char cp, xp;`
628			`char *nv;`
629			`int fl;`
630
631			`if (vp->status & RONLY) {`
632			`for (xp = vp->name; xp && xp != '=';)`
633			`putc(*xp++, stderr);`
634			`err(" is read-only");`
635			`return;`
636			`}`
637			`fl = 0;`
638			`if (name == NULL) {`
639			`xp = space(strlen(vp->name)+strlen(val)+2);`
640			`if (xp == 0)`
641			`return;`
642			`/* make string: name=value */`
643			`setarea((char *)xp, 0);`
644			`name = xp;`
645			`for (cp = vp->name; (xp = cp++) && *xp!='='; xp++)`
646			`;`
647			`if (*xp++ == 0)`
648			`xp[-1] = '=';`
649			`nv = xp;`
650			`for (cp = val; (xp++ = cp++) != '\0';)`
651			`;`
652			`val = nv;`
653			`fl = GETCELL;`
654			`}`
655			`if (vp->status & GETCELL)`
656			xfree(vp->name); /* form new string `name=value' */
657			`vp->name = name;`
658			`vp->value = val;`
659			`vp->status \|= fl;`
660			`}`
661
662			`void`
663			`export(vp)`
664			`struct var *vp;`
665			`{`
666			`vp->status \|= EXPORT;`
667			`}`
668
669			`void`
670			`ronly(vp)`
671			`struct var *vp;`
672			`{`
673			`if (letter(vp->name[0])) /* not an internal symbol ($# etc) */`
674			`vp->status \|= RONLY;`
675			`}`
676
677			`int`
678			`isassign(s)`
679			`register char *s;`
680			`{`
681			`if (!letter((int)*s))`
682			`return(0);`
683			`for (; *s != '='; s++)`
684			`if (s == 0 \|\| !letnum(s))`
685			`return(0);`
686			`return(1);`
687			`}`
688
689			`int`
690			`assign(s, cf)`
691			`register char *s;`
692			`int cf;`
693			`{`
694			`register char *cp;`
695			`struct var *vp;`
696
697			`if (!letter(*s))`
698			`return(0);`
699			`for (cp = s; *cp != '='; cp++)`
700			`if (cp == 0 \|\| !letnum(cp))`
701			`return(0);`
702			`vp = lookup(s);`
703			`nameval(vp, ++cp, cf == COPYV? (char *)NULL: s);`
704			`if (cf != COPYV)`
705			`vp->status &= ~GETCELL;`
706			`return(1);`
707			`}`
708
709			`int`
710			`checkname(cp)`
711			`register char *cp;`
712			`{`
713			`if (!letter(*cp++))`
714			`return(0);`
715			`while (*cp)`
716			`if (!letnum(*cp++))`
717			`return(0);`
718			`return(1);`
719			`}`
720
721			`void`
722			`putvlist(f, out)`
723			`register int f, out;`
724			`{`
725			`register struct var *vp;`
726
727			`for (vp = vlist; vp; vp = vp->next)`
728			`if (vp->status & f && letter(*vp->name)) {`
729			`if (vp->status & EXPORT)`
730			`write(out, "export ", 7);`
731			`if (vp->status & RONLY)`
732			`write(out, "readonly ", 9);`
733			`write(out, vp->name, (int)(findeq(vp->name) - vp->name));`
734			`write(out, "\n", 1);`
735			`}`
736			`}`
737
738			`int`
739			`eqname(n1, n2)`
740			`register char n1, n2;`
741			`{`
742			`for (; n1 != '=' && n1 != 0; n1++)`
743			`if (n2++ != n1)`
744			`return(0);`
745			`return(n2 == 0 \|\| n2 == '=');`
746			`}`
747
748			`static char *`
749			`findeq(cp)`
750			`register char *cp;`
751			`{`
752			`while (cp != '\0' && cp != '=')`
753			`cp++;`
754			`return(cp);`
755			`}`
756
757			`/* -------- gmatch.c -------- */`
758			`/*`
759			`* int gmatch(string, pattern)`
760			`* char string, pattern;`
761			`*`
762			`* Match a pattern as in sh(1).`
763			`*/`
764
765			`#define CMASK 0377`
766			`#define QUOTE 0200`
767			`#define QMASK (CMASK&~QUOTE)`
768			`#define NOT '!' /* might use ^ */`
769
770			`int`
771			`gmatch(s, p)`
772			`register char s, p;`
773			`{`
774			`register int sc, pc;`
775
776			`if (s == NULL \|\| p == NULL)`
777			`return(0);`
778			`while ((pc = *p++ & CMASK) != '\0') {`
779			`sc = *s++ & QMASK;`
780			`switch (pc) {`
781			`case '[':`
782			`if ((p = cclass(p, sc)) == NULL)`
783			`return(0);`
784			`break;`
785
786			`case '?':`
787			`if (sc == 0)`
788			`return(0);`
789			`break;`
790
791			`case '*':`
792			`s--;`
793			`do {`
794			`if (*p == '\0' \|\| gmatch(s, p))`
795			`return(1);`
796			`} while (*s++ != '\0');`
797			`return(0);`
798
799			`default:`
800			`if (sc != (pc&~QUOTE))`
801			`return(0);`
802			`}`
803			`}`
804			`return(*s == 0);`
805			`}`
806
807			`static char *`
808			`cclass(p, sub)`
809			`register char *p;`
810			`register int sub;`
811			`{`
812			`register int c, d, not, found;`
813
814			`if ((not = *p == NOT) != 0)`
815			`p++;`
816			`found = not;`
817			`do {`
818			`if (*p == '\0')`
819			`return((char *)NULL);`
820			`c = *p & CMASK;`
821			`if (p[1] == '-' && p[2] != ']') {`
822			`d = p[2] & CMASK;`
823			`p++;`
824			`} else`
825			`d = c;`
826			`if (c == sub \|\| (c <= sub && sub <= d))`
827			`found = !not;`
828			`} while (*++p != ']');`
829			`return(found? p+1: (char *)NULL);`
830			`}`
831
832
833			`//#if 0`
834
835
836			`/* -------- area.c -------- */`
837			`#define REGSIZE sizeof(struct region)`
838			`#define GROWBY 256`
839			`#undef SHRINKBY 64`
840			`#define FREE 32767`
841			`#define BUSY 0`
842			`#define ALIGN (sizeof(int)-1)`
843
844			`/* #include "area.h" */`
845
846			`struct region {`
847			`struct region *next;`
848			`int area;`
849			`};`
850
851			`/*`
852			`* All memory between (char )areabot and (char )(areatop+1) is`
853			`* exclusively administered by the area management routines.`
854			`* It is assumed that sbrk() and brk() manipulate the high end.`
855			`*/`
856			`static struct region areabot; / bottom of area */`
857			`static struct region areatop; / top of area */`
858			`static struct region areanxt; / starting point of scan */`
859			`static void * brktop;`
860			`static void * brkaddr;`
861
862			`//#define sbrk(X) ({ void * __q = -1; if (brkaddr + (int)(X) < brktop) { __q = brkaddr; brkaddr+=(int)(X); } __q;})`
863
864			`static void`
865			`initarea()`
866			`{`
867			`brkaddr = malloc(65000);`
868			`brktop = brkaddr + 65000;`
869
870			`while ((int)sbrk(0) & ALIGN)`
871			`sbrk(1);`
872			`areabot = (struct region *)sbrk(REGSIZE);`
873
874			`areabot->next = areabot;`
875			`areabot->area = BUSY;`
876			`areatop = areabot;`
877			`areanxt = areabot;`
878			`}`
879
880			`char *`
881			`getcell(nbytes)`
882			`unsigned nbytes;`
883			`{`
884			`register int nregio;`
885			`register struct region p, q;`
886			`register int i;`
887
888			`if (nbytes == 0) {`
889			`puts("Boo");`
890			`abort();`
891			`} /* silly and defeats the algorithm */`
892			`/*`
893			`* round upwards and add administration area`
894			`*/`
895			`nregio = (nbytes+(REGSIZE-1))/REGSIZE + 1;`
896			`for (p = areanxt;;) {`
897			`if (p->area > areanum) {`
898			`/*`
899			`* merge free cells`
900			`*/`
901			`while ((q = p->next)->area > areanum && q != areanxt)`
902			`p->next = q->next;`
903			`/*`
904			`* exit loop if cell big enough`
905			`*/`
906			`if (q >= p + nregio)`
907			`goto found;`
908			`}`
909			`p = p->next;`
910			`if (p == areanxt)`
911			`break;`
912			`}`
913			`i = nregio >= GROWBY ? nregio : GROWBY;`
914			`p = (struct region )sbrk(i REGSIZE);`
915			`if (p == (struct region *)-1)`
916			`return((char *)NULL);`
917			`p--;`
918			`if (p != areatop) {`
919			`puts("not contig");`
920			`abort(); /* allocated areas are contiguous */`
921			`}`
922			`q = p + i;`
923			`p->next = q;`
924			`p->area = FREE;`
925			`q->next = areabot;`
926			`q->area = BUSY;`
927			`areatop = q;`
928			`found:`
929			`/*`
930			`* we found a FREE area big enough, pointed to by 'p', and up to 'q'`
931			`*/`
932			`areanxt = p + nregio;`
933			`if (areanxt < q) {`
934			`/*`
935			`* split into requested area and rest`
936			`*/`
937			`if (areanxt+1 > q) {`
938			`puts("OOM");`
939			`abort(); /* insufficient space left for admin */`
940			`}`
941			`areanxt->next = q;`
942			`areanxt->area = FREE;`
943			`p->next = areanxt;`
944			`}`
945			`p->area = areanum;`
946			`return((char *)(p+1));`
947			`}`
948
949			`void`
950			`freecell(cp)`
951			`char *cp;`
952			`{`
953			`register struct region *p;`
954
955			`if ((p = (struct region *)cp) != NULL) {`
956			`p--;`
957			`if (p < areanxt)`
958			`areanxt = p;`
959			`p->area = FREE;`
960			`}`
961			`}`
962
963			`void`
964			`freearea(a)`
965			`register int a;`
966			`{`
967			`register struct region p, top;`
968
969			`top = areatop;`
970			`for (p = areabot; p != top; p = p->next)`
971			`if (p->area >= a)`
972			`p->area = FREE;`
973			`}`
974
975			`void`
976			`setarea(cp,a)`
977			`char *cp;`
978			`int a;`
979			`{`
980			`register struct region *p;`
981
982			`if ((p = (struct region *)cp) != NULL)`
983			`(p-1)->area = a;`
984			`}`
985
986			`int`
987			`getarea(cp)`
988			`char *cp;`
989			`{`
990			`return ((struct region*)cp-1)->area;`
991			`}`
992
993			`void`
994			`garbage()`
995			`{`
996			`register struct region p, q, *top;`
997
998			`top = areatop;`
999			`for (p = areabot; p != top; p = p->next) {`
1000			`if (p->area > areanum) {`
1001			`while ((q = p->next)->area > areanum)`
1002			`p->next = q->next;`
1003			`areanxt = p;`
1004			`}`
1005			`}`
1006			`#ifdef SHRINKBY`
1007			`if (areatop >= q + SHRINKBY && q->area > areanum) {`
1008			`brk((char *)(q+1));`
1009			`q->next = areabot;`
1010			`q->area = BUSY;`
1011			`areatop = q;`
1012			`}`
1013			`#endif`
1014			`}`
1015
1016			`//#endif`