home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Source Code 1992 March
/
Source_Code_CD-ROM_Walnut_Creek_March_1992.iso
/
usenet
/
altsrcs
/
2
/
2269
< prev
next >
Wrap
Internet Message Format
|
1990-12-28
|
47KB
From: netnews@netcom.UUCP (USENET Administration)
Newsgroups: alt.sources
Subject: Public Domain Korn Shell - Part.04 of 7
Message-ID: <18609@netcom.UUCP>
Date: 12 Dec 90 11:37:20 GMT
#!/bin/sh
# This is part 04 of ksh-pd
# ============= src/tree.c ==============
if test ! -d 'src'; then
echo 'x - creating directory src'
mkdir 'src'
fi
if test -f 'src/tree.c' -a X"$1" != X"-c"; then
echo 'x - skipping src/tree.c (File already exists)'
else
echo 'x - extracting src/tree.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'src/tree.c' &&
X/*
X * command tree climbing
X */
X
Xstatic char *RCSid = "$Header: /tmp/egisin/src/RCS/tree.c,v 3.1 88/11/03 09:18:05 egisin Exp $";
X
X#include <stddef.h>
X#include <string.h>
X#include <stdio.h>
X#include <errno.h>
X#include <setjmp.h>
X#include <varargs.h>
X#include "sh.h"
X#include "tree.h"
X
X#define FSTRING (FILE*)NULL
X
Xstatic int tputc ARGS((int c, FILE *f));
Xstatic void tputC ARGS((int c, FILE *f));
Xstatic void tputS ARGS((char *wp, FILE *f));
X
X/*
X * print a command tree
X */
X
Xvoid
Xptree(t, f)
X register struct op *t;
X register FILE *f;
X{
X register char **w;
X struct ioword **ioact;
X struct op *t1;
X
X Chain:
X if (t == NULL)
X return;
X switch (t->type) {
X case TCOM:
X for (w = t->vars; *w != NULL; )
X fptreef(f, "%S ", *w++);
X for (w = t->args; *w != NULL; )
X fptreef(f, "%S ", *w++);
X break;
X case TEXEC:
X t = t->left;
X goto Chain;
X case TPAREN:
X fptreef(f, "(%T)", t->left);
X break;
X case TPIPE:
X fptreef(f, "%T | ", t->left);
X t = t->right;
X goto Chain;
X case TLIST:
X fptreef(f, "%T%;", t->left);
X t = t->right;
X goto Chain;
X case TOR:
X case TAND:
X fptreef(f, "%T %s %T",
X t->left, (t->type==TOR) ? "||" : "&&", t->right);
X break;
X case TFOR:
X fptreef(f, "for %s ", t->str);
X if (t->vars != NULL) {
X fptreef(f, "in ");
X for (w = t->vars; *w; )
X fptreef(f, "%S ", *w++);
X fptreef(f, "%;");
X }
X fptreef(f, "do %T%;done ", t->left);
X break;
X case TCASE:
X fptreef(f, "case %S in%;", t->str);
X for (t1 = t->left; t1 != NULL; t1 = t1->right) {
X fptreef(f, "(");
X for (w = t1->vars; *w != NULL; w++)
X fptreef(f, "%S%c", *w, (w[1] != NULL) ? '|' : ')');
X fptreef(f, " %T;;%;", t1->left);
X }
X fptreef(f, "esac ");
X break;
X case TIF:
X fptreef(f, "if %T%;", t->left);
X t = t->right;
X if (t->left != NULL)
X fptreef(f, "then %T%;", t->left);
X if (t->right != NULL)
X fptreef(f, "else %T%;", t->right);
X fptreef(f, "fi ");
X break;
X case TWHILE:
X case TUNTIL:
X fptreef(f, "%s %T%;do %T%;done ",
X (t->type==TWHILE) ? "while" : "until",
X t->left, t->right);
X break;
X case TBRACE:
X fptreef(f, "{%;%T%;} ", t->left);
X break;
X case TASYNC:
X fptreef(f, "%T &", t->left);
X break;
X case TFUNCT:
X fptreef(f, "function %s %T", t->str, t->left);
X break;
X case TTIME:
X fptreef(f, "time %T", t->left);
X break;
X default:
X fptreef(f, "<botch>");
X break;
X }
X if ((ioact = t->ioact) != NULL)
X while (*ioact != NULL)
X pioact(f, *ioact++);
X}
X
Xpioact(f, iop)
X register FILE *f;
X register struct ioword *iop;
X{
X fptreef(f, "%c><%S ", '0' + iop->unit, iop->name); /* todo: fix */
X}
X
X
X/*
X * variants of fputc, fputs for ptreef and snptreef
X */
X
Xstatic char *snpf_s; /* snptreef string */
Xstatic int snpf_n; /* snptreef length */
X
Xstatic int
Xtputc(c, f)
X int c;
X register FILE *f;
X{
X if (f != NULL)
X putc(c, f);
X else
X if (--snpf_n >= 0)
X *snpf_s++ = c;
X return c;
X}
X
Xstatic void
XtputC(c, f)
X register int c;
X register FILE *f;
X{
X if ((c&0x60) == 0) { /* C0|C1 */
X tputc((c&0x80) ? '$' : '^', f);
X tputc((c&0x7F|0x40), f);
X } else if ((c&0x7F) == 0x7F) { /* DEL */
X tputc((c&0x80) ? '$' : '^', f);
X tputc('?', f);
X } else
X tputc(c, f);
X}
X
Xstatic void
XtputS(wp, f)
X register char *wp;
X register FILE *f;
X{
X register int c;
X
X while (1)
X switch ((c = *wp++)) {
X case EOS:
X return;
X case CHAR:
X tputC(*wp++, f);
X break;
X case QCHAR:
X tputc('\\', f);
X tputC(*wp++, f);
X break;
X case OQUOTE:
X case CQUOTE:
X tputc('"', f);
X break;
X case OSUBST:
X tputc('$', f);
X tputc('{', f);
X while ((c = *wp++) != 0)
X tputc(c, f);
X if (*wp != CSUBST)
X tputC(*wp++, f);
X break;
X case CSUBST:
X tputc('}', f);
X break;
X case COMSUB:
X tputc('$', f);
X tputc('(', f);
X while (*wp != 0)
X tputC(*wp++, f);
X tputc(')', f);
X break;
X }
X}
X
X/* TODO: use varargs properly */
X
X/* VARARGS */ int
Xfptreef(f, va_alist) va_dcl
X register FILE *f;
X{
X va_list va;
X char *fmt;
X
X va_start(va);
X fmt = va_arg(va, char *);
X vfptreef(f, fmt, va);
X va_end(va);
X return 0;
X}
X
X/* VARARGS */ int
Xsnptreef(s, n, va_alist) va_dcl
X char *s;
X int n;
X{
X va_list va;
X char *fmt;
X
X snpf_s = s;
X snpf_n = n;
X va_start(va);
X fmt = va_arg(va, char *);
X vfptreef(FSTRING, fmt, va);
X tputc('\0', FSTRING);
X va_end(va);
X return 0;
X}
X
Xvfptreef(f, fmt, va)
X register FILE *f;
X register char *fmt;
X register va_list va;
X{
X register int c;
X
X while ((c = *fmt++))
X if (c == '%') {
X register long n;
X register char *p;
X int neg;
X
X switch ((c = *fmt++)) {
X case 'c':
X tputc(va_arg(va, int), f);
X break;
X case 's':
X p = va_arg(va, char *);
X while (*p)
X tputc(*p++, f);
X break;
X case 'S': /* word */
X p = va_arg(va, char *);
X tputS(p, f);
X break;
X case 'd': case 'u': /* decimal */
X n = (c == 'd') ? va_arg(va, int) : va_arg(va, unsigned int);
X neg = c=='d' && n<0;
X p = ulton((neg) ? -n : n, 10);
X if (neg)
X *--p = '-';
X while (*p)
X tputc(*p++, f);
X break;
X case 'T': /* format tree */
X ptree(va_arg(va, struct op *), f);
X break;
X case ';': /* newline or ; */
X p = (f == FSTRING) ? "; " : "\n";
X while (*p)
X tputc(*p++, f);
X break;
X default:
X tputc(c, f);
X break;
X }
X } else
X tputc(c, f);
X}
X
X/*
X * copy tree (for function definition)
X */
X
Xstatic struct ioword **iocopy();
X
Xstruct op *
Xtcopy(t, ap)
X register struct op *t;
X Area *ap;
X{
X register struct op *r;
X register char **tw, **rw;
X
X if (t == NULL)
X return NULL;
X
X r = (struct op *) alloc(sizeof(struct op), ap);
X
X r->type = t->type;
X
X /* this will copy function and for identifiers quite accidently */
X r->str = (t->str == NULL) ? NULL : wdcopy(t->str, ap);
X
X if (t->vars == NULL)
X r->vars = NULL;
X else {
X for (tw = t->vars; *tw++ != NULL; )
X ;
X rw = r->vars = (char **)
X alloc((int)(tw - t->vars) * sizeof(*tw), ap);
X for (tw = t->vars; *tw != NULL; )
X *rw++ = wdcopy(*tw++, ap);
X *rw = NULL;
X }
X
X if (t->args == NULL)
X r->args = NULL;
X else {
X for (tw = t->args; *tw++ != NULL; )
X ;
X rw = r->args = (char **)
X alloc((int)(tw - t->args) * sizeof(*tw), ap);
X for (tw = t->args; *tw != NULL; )
X *rw++ = wdcopy(*tw++, ap);
X *rw = NULL;
X }
X
X r->ioact = (t->ioact == NULL) ? NULL : iocopy(t->ioact, ap);
X
X r->left = tcopy(t->left, ap);
X r->right = tcopy(t->right, ap);
X
X return r;
X}
X
Xchar *
Xwdcopy(wp, ap)
X char *wp;
X Area *ap;
X{
X size_t len = wdscan(wp, EOS) - wp;
X return memcpy(alloc(len, ap), wp, len);
X}
X
X/* return the position of prefix c in wp plus 1 */
Xchar *
Xwdscan(wp, c)
X register char *wp;
X register int c;
X{
X register int nest = 0;
X
X while (1)
X switch (*wp++) {
X case EOS:
X return wp;
X case CHAR:
X case QCHAR:
X wp++;
X break;
X case OQUOTE:
X case CQUOTE:
X break;
X case OSUBST:
X nest++;
X while (*wp++ != 0)
X ;
X if (*wp != CSUBST)
X wp++;
X break;
X case CSUBST:
X if (c == CSUBST && nest == 0)
X return wp;
X nest--;
X break;
X case COMSUB:
X while (*wp++ != 0)
X ;
X break;
X }
X}
X
Xstatic struct ioword **
Xiocopy(iow, ap)
X register struct ioword **iow;
X Area *ap;
X{
X register struct ioword **ior;
X register int i;
X
X for (ior = iow; *ior++ != NULL; )
X ;
X ior = (struct ioword **) alloc((int)(ior - iow) * sizeof(*ior), ap);
X
X for (i = 0; iow[i] != NULL; i++) {
X register struct ioword *p, *q;
X
X p = iow[i];
X q = (struct ioword *) alloc(sizeof(*p), ap);
X ior[i] = q;
X *q = *p;
X if (p->name != NULL)
X q->name = wdcopy(p->name, ap);
X }
X ior[i] = NULL;
X
X return ior;
X}
X
X/*
X * free tree (for function definition)
X */
X
Xstatic void iofree();
X
Xvoid
Xtfree(t, ap)
X register struct op *t;
X Area *ap;
X{
X register char **w;
X
X if (t == NULL)
X return;
X
X if (t->str != NULL)
X afree((Void*)t->str, ap);
X
X if (t->vars != NULL) {
X for (w = t->vars; *w != NULL; w++)
X afree((Void*)*w, ap);
X afree((Void*)t->vars, ap);
X }
X
X if (t->args != NULL) {
X for (w = t->args; *w != NULL; w++)
X afree((Void*)*w, ap);
X afree((Void*)t->args, ap);
X }
X
X if (t->ioact != NULL)
X iofree(t->ioact, ap);
X
X tfree(t->left, ap);
X tfree(t->right, ap);
X
X afree((Void*)t, ap);
X}
X
Xstatic void
Xiofree(iow, ap)
X struct ioword **iow;
X Area *ap;
X{
X register struct ioword **iop;
X register struct ioword *p;
X
X for (iop = iow; (p = *iop++) != NULL; ) {
X if (p->name != NULL)
X afree((Void*)p->name, ap);
X afree((Void*)p, ap);
X }
X}
X
SHAR_EOF
true || echo 'restore of src/tree.c failed'
fi
# ============= src/exec.c ==============
if test -f 'src/exec.c' -a X"$1" != X"-c"; then
echo 'x - skipping src/exec.c (File already exists)'
else
echo 'x - extracting src/exec.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'src/exec.c' &&
X/*
X * execute command tree
X */
X
Xstatic char *RCSid = "$Header: /tmp/egisin/src/RCS/exec.c,v 3.3 88/12/17 21:19:29 egisin Exp $";
X
X#include <stddef.h>
X#include <stdio.h>
X#include <string.h>
X#include <errno.h>
X#include <signal.h>
X#include <setjmp.h>
X#include <unistd.h>
X#include <fcntl.h>
X#include "sh.h"
X#include "lex.h"
X#include "tree.h"
X#include "table.h"
X
Xstatic int comexec ARGS((struct op *t, char **vp, char **ap, int flags));
Xstatic void iosetup ARGS((struct ioword *iop));
Xstatic void echo ARGS((char **, char **));
Xstatic int herein ARGS((char *name, int sub));
X
X/*
X * execute command tree
X */
Xint
Xexecute(t, flags)
X register struct op *t;
X Volatile int flags; /* if XEXEC don't fork */
X{
X int i;
X int Volatile rv = 0;
X int pv[2];
X register char **ap;
X char *s, *cp;
X struct ioword **iowp;
X
X if (t == NULL)
X return 0;
X
X if ((flags&XFORK) && !(flags&XEXEC) && t->type != TPIPE)
X return exchild(t, flags); /* run in sub-process */
X
X newenv(E_EXEC);
X if (trap)
X runtraps();
X
X if (t->ioact != NULL || t->type == TPIPE) {
X e.savefd = alloc(sizeofN(short, NUFILE), ATEMP);
X for (i = 0; i < NUFILE; i++)
X e.savefd[i] = 0; /* not redirected */
X }
X
X /* do redirection, to be restored in quitenv() */
X if (t->ioact != NULL)
X for (iowp = t->ioact; *iowp != NULL; iowp++) {
X if ((flags&XPIPEI) && (*iowp)->unit == 0 ||
X (flags&XPIPEO) && (*iowp)->unit == 1)
X errorf("attempt to redirect fd 0/1 in pipe\n");
X iosetup(*iowp);
X }
X
X switch(t->type) {
X case TCOM:
X e.type = E_TCOM;
X rv = comexec(t, eval(t->vars, DOTILDE),
X eval(t->args, DOBLANK|DOGLOB|DOTILDE), flags);
X break;
X
X case TPAREN:
X rv = execute(t->left, flags|XFORK);
X break;
X
X case TPIPE:
X flags |= XFORK;
X e.savefd[0] = savefd(0);
X e.savefd[1] = savefd(1);
X flags |= XPIPEO;
X (void) dup2(e.savefd[0], 0); /* stdin of first */
X while (t->type == TPIPE) {
X openpipe(pv);
X (void) dup2(pv[1], 1); /* stdout of curr */
X exchild(t->left, flags);
X (void) dup2(pv[0], 0); /* stdin of next */
X closepipe(pv);
X flags |= XPIPEI;
X t = t->right;
X }
X flags &= ~ XPIPEO;
X (void) dup2(e.savefd[1], 1); /* stdout of last */
X exchild(t, flags);
X (void) dup2(e.savefd[0], 0); /* close pipe in */
X rv = waitlast();
X break;
X
X case TLIST:
X while (t->type == TLIST) {
X execute(t->left, 0);
X t = t->right;
X }
X rv = execute(t, 0);
X break;
X
X case TASYNC:
X rv = execute(t->left, flags|XBGND|XFORK);
X break;
X
X case TOR:
X case TAND:
X rv = execute(t->left, 0);
X if (t->right != NULL && (rv == 0) == (t->type == TAND))
X rv = execute(t->right, 0);
X break;
X
X case TFOR:
X e.type = E_LOOP;
X ap = (t->vars != NULL) ?
X eval(t->vars, DOBLANK|DOGLOB|DOTILDE) : e.loc->argv + 1;
X while ((i = setjmp(e.jbuf)))
X if (i == LBREAK)
X goto Break1;
X while (*ap != NULL) {
X setstr(global(t->str), *ap++);
X rv = execute(t->left, 0);
X }
X Break1:
X break;
X
X case TWHILE:
X case TUNTIL:
X e.type = E_LOOP;
X while ((i = setjmp(e.jbuf)))
X if (i == LBREAK)
X goto Break2;
X while ((execute(t->left, 0) == 0) == (t->type == TWHILE))
X rv = execute(t->right, 0);
X Break2:
X break;
X
X case TIF:
X case TELIF:
X if (t->right == NULL)
X break; /* should be error */
X rv = execute(t->left, 0) == 0 ?
X execute(t->right->left, 0) :
X execute(t->right->right, 0);
X break;
X
X case TCASE:
X cp = evalstr(t->str, 0);
X for (t = t->left; t != NULL && t->type == TPAT; t = t->right)
X for (ap = t->vars; *ap; ap++)
X if ((s = evalstr(*ap, DOPAT)) && gmatch(cp, s))
X goto Found;
X break;
X Found:
X rv = execute(t->left, 0);
X break;
X
X case TBRACE:
X rv = execute(t->left, 0);
X break;
X
X case TFUNCT:
X rv = define(t->str, t->left);
X break;
X
X case TTIME:
X rv = timex(t, flags);
X break;
X
X case TEXEC: /* an eval'd TCOM */
X s = t->args[0];
X ap = makenv();
X#if _MINIX /* no F_SETFD close-on-exec */
X for (i = 10; i < 20; i++)
X close(i);
X#endif
X execve(t->str, t->args, ap);
X if (errno == ENOEXEC) {
X *t->args-- = t->str;
X *t->args = s;
X execve(SHELL, t->args, ap);
X errorf("No shell\n");
X }
X errorf("%s: %s\n", s, strerror(errno));
X }
X
X quitenv(); /* restores IO */
X if (e.interactive) { /* flush stdout, shlout */
X fflush(shf[1]);
X fflush(shf[2]);
X }
X if ((flags&XEXEC))
X exit(rv); /* exit child */
X return rv;
X}
X
X/*
X * execute simple command
X */
X
Xstatic int
Xcomexec(t, vp, ap, flags)
X struct op *t;
X register char **ap, **vp;
X int flags;
X{
X int i;
X int rv = 0;
X register char *cp;
X register struct tbl *tp = NULL;
X register struct block *l;
X static struct op texec = {TEXEC};
X extern int c_exec(), c_builtin();
X
X if (flag[FXTRACE])
X echo(vp, ap);
X
X /* create new variable/function block */
X l = alloc(sizeof(struct block), ATEMP);
X l->next = e.loc; e.loc = l;
X newblock();
X
X Doexec:
X if ((cp = *ap) == NULL)
X cp = ":";
X tp = findcom(cp, 1);
X
X switch (tp->type) {
X case CSHELL: /* shell built-in */
X while (tp->val.f == c_builtin) {
X if ((cp = *++ap) == NULL)
X break;
X tp = tsearch(&builtins, cp, hash(cp));
X if (tp == NULL)
X errorf("%s: not builtin\n", cp);
X }
X if (tp->val.f == c_exec) {
X if (*++ap == NULL) {
X e.savefd = NULL; /* don't restore redirection */
X break;
X }
X flags |= XEXEC;
X goto Doexec;
X }
X if ((tp->flag&TRACE))
X e.loc = l->next; /* no local block */
X i = (tp->flag&TRACE) ? 0 : LOCAL;
X while (*vp != NULL)
X (void) typeset(*vp++, i, 0);
X rv = (*tp->val.f)(ap);
X break;
X
X case CFUNC: /* function call */
X if (!(tp->flag&ISSET))
X errorf("%s: undefined function", cp);
X l->argv = ap;
X for (i = 0; *ap++ != NULL; i++)
X ;
X l->argc = i - 1;
X resetopts();
X while (*vp != NULL)
X (void) typeset(*vp++, LOCAL, 0);
X e.type = E_FUNC;
X if (setjmp(e.jbuf))
X rv = exstat; /* return # */
X else
X rv = execute(tp->val.t, 0);
X break;
X
X case CEXEC: /* executable command */
X if (!(tp->flag&ISSET)) {
X shellf("%s: not found\n", cp);
X rv = 1;
X break;
X }
X
X /* set $_ to program's full path */
X setstr(typeset("_", LOCAL|EXPORT, 0), tp->val.s);
X while (*vp != NULL)
X (void) typeset(*vp++, LOCAL|EXPORT, 0);
X
X if ((flags&XEXEC)) {
X j_exit();
X if (flag[FMONITOR] || !(flags&XBGND)) {
X signal(SIGINT, SIG_DFL);
X signal(SIGQUIT, SIG_DFL);
X }
X }
X
X /* to fork we set up a TEXEC node and call execute */
X texec.left = t; /* for tprint */
X texec.str = tp->val.s;
X texec.args = ap;
X rv = exchild(&texec, flags);
X break;
X }
X if (rv != 0 && flag[FERREXIT])
X leave(rv);
X return (exstat = rv);
X}
X
Xint
Xshcomexec(wp)
X register char **wp;
X{
X register struct tbl *tp;
X
X tp = tsearch(&builtins, *wp, hash(*wp));
X if (tp == NULL)
X errorf("%s: shcomexec botch\n", *wp);
X return (*tp->val.f)(wp);
X}
X
X/*
X * define function
X */
Xint
Xdefine(name, t)
X char *name;
X struct op *t;
X{
X register struct block *l;
X register struct tbl *tp;
X
X for (l = e.loc; l != NULL; l = l->next) {
X lastarea = &l->area;
X tp = tsearch(&l->funs, name, hash(name));
X if (tp != NULL && (tp->flag&DEFINED))
X break;
X if (l->next == NULL) {
X tp = tenter(&l->funs, name, hash(name));
X tp->flag = DEFINED|FUNCT;
X tp->type = CFUNC;
X }
X }
X
X if ((tp->flag&ALLOC))
X tfree(tp->val.t, lastarea);
X tp->flag &= ~(ISSET|ALLOC);
X
X if (t == NULL) /* undefine */
X return 0;
X
X tp->val.t = tcopy(t, lastarea);
X tp->flag |= (ISSET|ALLOC);
X
X return 0;
X}
X
X/*
X * add builtin
X */
Xbuiltin(name, func)
X char *name;
X int (*func)();
X{
X register struct tbl *tp;
X int flag = DEFINED;
X
X if (*name == '=') { /* sets keyword variables */
X name++;
X flag |= TRACE; /* command does variable assignment */
X }
X
X tp = tenter(&builtins, name, hash(name));
X tp->flag |= flag;
X tp->type = CSHELL;
X tp->val.f = func;
X}
X
X/*
X * find command
X * either function, hashed command, or built-in (in that order)
X */
Xstruct tbl *
Xfindcom(name, insert)
X char *name;
X int insert; /* insert if not found */
X{
X register struct block *l = e.loc;
X unsigned int h = hash(name);
X register struct tbl *tp = NULL;
X static struct tbl temp;
X
X if (strchr(name, '/') != NULL) {
X tp = &temp;
X tp->type = CEXEC;
X tp->flag = 0; /* make ~ISSET */
X goto Search;
X }
X for (l = e.loc; l != NULL; l = l->next) {
X tp = tsearch(&l->funs, name, h);
X if (tp != NULL && (tp->flag&DEFINED))
X break;
X }
X if (tp == NULL)
X tp = tsearch(&commands, name, h);
X if (tp == NULL)
X tp = tsearch(&builtins, name, h);
X if (tp == NULL && insert) {
X tp = tenter(&commands, name, h);
X tp->type = CEXEC;
X tp->flag = DEFINED;
X }
X Search:
X if (tp->type == CEXEC && !(tp->flag&ISSET)) {
X if (!flag[FHASHALL]) {
X tp = &temp;
X tp->type = CEXEC;
X tp->flag = 0; /* make ~ISSET */
X }
X name = search(name, path, 1);
X if (name != NULL) {
X tp->val.s = strsave(name,
X (tp == &temp) ? ATEMP : APERM);
X tp->flag |= ISSET|ALLOC;
X }
X }
X return tp;
X}
X
X/*
X * flush executable commands with relative paths
X */
Xflushcom(all)
X int all; /* just relative or all */
X{
X register struct tbl *tp;
X
X for (twalk(&commands); (tp = tnext()) != NULL; )
X if ((tp->flag&ISSET) && (all || tp->val.s[0] != '/')) {
X if ((tp->flag&ALLOC))
X afree(tp->val.s, commands.areap);
X tp->flag = DEFINED; /* make ~ISSET */
X }
X}
X
X/*
X * search for command with PATH
X */
Xchar *
Xsearch(name, path, mode)
X char *name, *path;
X int mode; /* 0: readable; 1: executable */
X{
X register int i;
X register char *sp, *tp;
X
X if (strchr(name, '/'))
X return (eaccess(name, mode) == 0) ? name : NULL;
X
X sp = path;
X do {
X tp = line;
X for (; *sp != '\0'; tp++)
X if ((*tp = *sp++) == ':')
X break;
X if (tp != line)
X *tp++ = '/';
X for (i = 0; (*tp++ = name[i++]) != '\0';)
X ;
X i = eaccess(line, mode);
X if (i == 0)
X return line;
X /* what should we do about EACCES? */
X } while (*sp != '\0');
X return NULL;
X}
X
X/*
X * set up redirection, saving old fd's in e.savefd
X */
Xstatic void
Xiosetup(iop)
X register struct ioword *iop;
X{
X register int u = -1;
X char *cp = iop->name;
X extern long lseek();
X
X if (iop->unit == 0 || iop->unit == 1 || iop->unit == 2)
X e.interactive = 0;
X e.savefd[iop->unit] = savefd(iop->unit);
X
X if ((iop->flag&IOTYPE) != IOHERE)
X cp = evalstr(cp, DOTILDE);
X
X switch (iop->flag&IOTYPE) {
X case IOREAD:
X u = open(cp, 0);
X break;
X
X case IOCAT:
X if ((u = open(cp, 1)) >= 0) {
X (void) lseek(u, (long)0, 2);
X break;
X }
X /* FALLTHROUGH */
X case IOWRITE:
X u = creat(cp, 0666);
X break;
X
X case IORDWR:
X u = open(cp, 2);
X break;
X
X case IOHERE:
X u = herein(cp, iop->flag&IOEVAL);
X /* cp may have wrong name */
X break;
X
X case IODUP:
X if (*cp == '-')
X close(iop->unit);
X else
X if (digit(*cp))
X u = *cp - '0';
X else
X errorf("%s: illegal >& argument\n", cp);
X break;
X }
X if (u < 0)
X errorf("%s: cannot %s\n", cp,
X (iop->flag&IOTYPE) == IOWRITE ? "create" : "open");
X if (u != iop->unit) {
X (void) dup2(u, iop->unit);
X if (iop->flag != IODUP)
X close(u);
X }
X
X fopenshf(iop->unit);
X}
X
X/*
X * open here document temp file.
X * if unquoted here, expand here temp file into second temp file.
X */
Xstatic int
Xherein(hname, sub)
X char *hname;
X int sub;
X{
X int fd;
X FILE * Volatile f = NULL;
X
X f = fopen(hname, "r");
X if (f == NULL)
X return -1;
X setvbuf(f, (char *)NULL, _IOFBF, BUFSIZ);
X
X if (sub) {
X char *cp;
X struct source *s;
X struct temp *h;
X
X newenv(E_ERRH);
X if (setjmp(e.jbuf)) {
X if (f != NULL)
X fclose(f);
X quitenv();
X return -1; /* todo: error()? */
X }
X
X /* set up yylex input from here file */
X s = pushs(SFILE);
X s->u.file = f;
X source = s;
X if (yylex(ONEWORD) != LWORD)
X errorf("exec:herein error\n");
X cp = evalstr(yylval.cp, 0);
X
X /* write expanded input to another temp file */
X h = maketemp(ATEMP);
X h->next = e.temps; e.temps = h;
X if (h == NULL)
X error();
X f = fopen(h->name, "w+");
X if (f == NULL)
X error();
X setvbuf(f, (char *)NULL, _IOFBF, BUFSIZ);
X fputs(cp, f);
X rewind(f);
X
X quitenv();
X }
X fd = dup(fileno(f));
X fclose(f);
X return fd;
X}
X
Xstatic void
Xecho(vp, ap)
X register char **vp, **ap;
X{
X shellf("+");
X while (*vp != NULL)
X shellf(" %s", *vp++);
X while (*ap != NULL)
X shellf(" %s", *ap++);
X shellf("\n");
X}
X
SHAR_EOF
true || echo 'restore of src/exec.c failed'
fi
# ============= src/jobs.c ==============
if test -f 'src/jobs.c' -a X"$1" != X"-c"; then
echo 'x - skipping src/jobs.c (File already exists)'
else
echo 'x - extracting src/jobs.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'src/jobs.c' &&
X/*
X * Process and job control
X */
X
Xstatic char *RCSid = "$Header: /tmp/egisin/src/RCS/jobs.c,v 3.4 88/12/14 19:49:17 egisin Exp $";
X
X/*
X * based on version by Ron Natalie, BRL
X *
X * TODO:
X * change Proc table to Job table, with array of pids.
X * make %+ be jobs, %- be jobs->next.
X * do not JFREE members of pipeline.
X * consider procs[] related critical sections.
X * signal(SIGCHLD, j_sigchld) should be
X * sigaction(SIGCHLD, sigchld, NULL),
X * with sigchld.sa_flags = SA_RESTART.
X * There is a simple work-around if there is no SA_RESTART.
X */
X
X#include <stddef.h>
X#include <string.h>
X#include <stdio.h>
X#include <errno.h>
X#include <unistd.h>
X#include <signal.h>
X#include <setjmp.h>
X#include <sys/types.h>
X#include <sys/times.h>
X#include <sys/wait.h>
X#if JOBS
X#if _BSD
X#include <sys/ioctl.h>
X#else
X#include "termios.h"
X#endif
X#endif
X#include "sh.h"
X#include "tree.h"
X
X#ifndef WIFCORED
X#define WIFCORED(x) (!!((x)&0x80)) /* non-standard */
X#endif
X
X/* as of P1003.1 Draft 12.3:
X * pid_t getpgrp(void); // Get process group id
X * pid_t setsid(void); // Create session and Set process group id
X * int setpgid(pid_t pid, pid_t pgid); // Set process group id for job control
X */
X
X#if JOBS
X#if _BSD /* _BSD 4.* */
X#define setpgid(p, pg) setpgrp(p, pg)
X#define getpgid(p) getpgrp(p)
X#define tcsetpgrp(fd,p) ioctl(fd, TIOCSPGRP, &(p))
X#else /* POSIX-compatible */
X#define getpgid(p) getpgrp() /* 1003.1 stupidity */
X#define killpg(p, s) kill(-(p), s)
X#endif
X#endif
X
X#ifndef SIGCHLD
X#define SIGCHLD SIGCLD
X#endif
X
Xtypedef struct Proc Proc;
Xstruct Proc {
X Proc *next; /* `procs' list link */
X int job; /* job number: %n */
X short Volatile state; /* proc state */
X short Volatile notify; /* proc state has changed */
X Proc *prev; /* prev member of pipeline */
X pid_t proc; /* process id */
X pid_t pgrp; /* process group if flag[FMONITOR] */
X short flags; /* execute flags */
X int status; /* wait status */
X clock_t utime, stime; /* user/system time when JDONE */
X char com [48]; /* command */
X};
X
X/* proc states */
X#define JFREE 0 /* unused proc */
X#define JRUN 1 /* foreground */
X#define JEXIT 2 /* exit termination */
X#define JSIGNAL 3 /* signal termination */
X#define JSTOP 4 /* stopped */
X
Xstatic Proc *procs = NULL; /* job/process table */
X
Xclock_t j_utime, j_stime; /* user and system time for last job a-waited */
X#if JOBS
Xstatic int sm_default, sm_sigchld; /* signal masks */
Xstatic int our_pgrp; /* shell's pgrp */
X#endif
Xstatic Proc *j_lastj; /* last proc created by exchild */
Xstatic int j_lastjob = 0; /* last created job */
Xstatic int j_current = 0; /* current job */
Xstatic int j_previous = 0; /* previous job */
X
Xstatic int j_newjob ARGS((void));
Xstatic void j_print ARGS((Proc *j));
Xstatic Proc *j_search ARGS((int job));
Xstatic int j_waitj ARGS((Proc *j, int intr));
Xstatic void j_sigchld ARGS((int sig));
X
X/* initialize job control */
Xvoid
Xj_init()
X{
X#if JOBS
X#ifdef NTTYDISC
X int ldisc = NTTYDISC; /* BSD brain damage */
X
X if (ttyfd >= 0)
X ioctl(ttyfd, TIOCSETD, &ldisc);
X#endif
X our_pgrp = getpgid(0);
X sm_default = 0;
X sm_sigchld = sigmask(SIGCHLD);
X#endif
X}
X
X/* job cleanup before shell exit */
Xvoid
Xj_exit()
X{
X register Proc *j;
X int killed = 0;
X
X#if JOBS
X /* kill stopped jobs */
X for (j = procs; j != NULL; j = j->next)
X if (j->state == JSTOP) {
X killed ++;
X killpg(j->pgrp, SIGHUP);
X killpg(j->pgrp, SIGCONT);
X }
X if (killed)
X sleep(1);
X#endif
X j_notify();
X
X#if JOBS
X if (flag[FMONITOR]) {
X flag[FMONITOR] = 0;
X j_change();
X }
X#endif
X}
X
X#if JOBS
X/* turn job control on or off according to flag[FMONITOR] */
Xvoid
Xj_change()
X{
X static handler_t old_tstp, old_ttin, old_ttou;
X
X if (flag[FMONITOR]) {
X if (ttyfd < 0) {
X flag[FMONITOR] = 0;
X shellf("job control requires tty\n");
X return;
X }
X (void) signal(SIGCHLD, j_sigchld);
X sigtraps[SIGCHLD].sig_dfl = 1; /* restore on fork */
X old_tstp = signal(SIGTSTP, SIG_IGN);
X sigtraps[SIGTSTP].sig_dfl = 1;
X old_ttin = signal(SIGTTIN, SIG_IGN);
X sigtraps[SIGTTIN].sig_dfl = 1;
X old_ttou = signal(SIGTTOU, SIG_IGN);
X sigtraps[SIGTTOU].sig_dfl = 1;
X sigsetmask(sm_default);
X tcsetpgrp(ttyfd, our_pgrp);
X } else {
X (void) signal(SIGCHLD, SIG_DFL);
X (void) signal(SIGTSTP, old_tstp);
X sigtraps[SIGTSTP].sig_dfl = 0;
X (void) signal(SIGTTIN, old_ttin);
X sigtraps[SIGTTIN].sig_dfl = 0;
X (void) signal(SIGTTOU, old_ttou);
X sigtraps[SIGTTOU].sig_dfl = 0;
X }
X}
X#endif
X
X/* execute tree in child subprocess */
Xint
Xexchild(t, flags)
X struct op *t;
X int flags;
X{
X register int i;
X register Proc *j;
X int rv = 0;
X
X flags &= ~XFORK;
X if ((flags&XEXEC))
X return execute(t, flags);
X
X /* get free Proc entry */
X for (j = procs; j != NULL; j = j->next)
X if (j->state == JFREE)
X goto Found;
X j = alloc(sizeof(Proc), APERM);
X j->next = procs;
X j->state = JFREE;
X procs = j;
X Found:
X
X j->prev = ((flags&XPIPEI)) ? j_lastj : NULL;
X j->proc = j->pgrp = 0;
X j->flags = flags;
X j->job = (flags&XPIPEI) ? j_lastjob : j_newjob();
X snptreef(j->com, sizeof(j->com), "%T", t); /* save proc's command */
X j->com[sizeof(j->com)-1] = '\0';
X j->state = JRUN;
X
X /* stdio buffer must be flushed and invalidated */
X for (i = 0; i < NUFILE; i++)
X flushshf(i);
X
X /* create child process */
X if ((i = fork()) < 0) {
X /* todo: try a few times with exp-incr delay */
X j->state = JFREE;
X errorf("cannot fork - try again\n");
X }
X j->proc = (i != 0) ? i : getpid();
X
X#if JOBS
X /* job control set up */
X if (flag[FMONITOR] && !(flags&XXCOM)) {
X j->pgrp = !(flags&XPIPEI) ? j->proc : j_lastj->pgrp;
X /* do in both parent and child to avoid fork race condition */
X if (!(flags&XBGND))
X tcsetpgrp(ttyfd, j->pgrp); /* could be trouble */
X setpgid(j->proc, j->pgrp);
X }
X#endif
X j_lastj = j;
X
X if (i == 0) { /* child */
X e.oenv = NULL;
X if (flag[FTALKING])
X restoresigs();
X if ((flags&XBGND) && !flag[FMONITOR]) {
X signal(SIGINT, SIG_IGN);
X signal(SIGQUIT, SIG_IGN);
X if (flag[FTALKING])
X signal(SIGTERM, SIG_DFL);
X i = open("/dev/null", 0);
X (void) dup2(i, 0);
X close(i);
X }
X for (j = procs; j != NULL; j = j->next)
X j->state = JFREE;
X ttyfd = -1;
X flag[FMONITOR] = flag[FTALKING] = 0;
X cleartraps();
X execute(t, flags|XEXEC); /* no return */
X /* NOTREACHED */
X }
X
X /* shell (parent) stuff */
X if ((flags&XBGND)) { /* async statement */
X async = j->proc;
X j_previous = j_current;
X j_current = j->job;
X if (flag[FTALKING])
X j_print(j);
X } else { /* sync statement */
X if (!(flags&XPIPE))
X rv = j_waitj(j, 0);
X }
X
X return rv;
X}
X
X/* wait for last job: pipeline or $() sub-process */
Xint
Xwaitlast()
X{
X return j_waitj(j_lastj, 0);
X}
X
X/* wait for job to complete or change state */
Xstatic int
Xj_waitj(aj, intr)
X Proc *aj;
X int intr; /* interruptable */
X{
X register Proc *j;
X int rv = 1;
X int ttysig = 0;
X
X#if JOBS
X if (flag[FMONITOR])
X sigsetmask(sm_sigchld);
X#endif
X /* wait for all members of pipeline */
X for (j = aj; j != NULL; j = j->prev) {
X /* wait for job to finish, stop, or ^C of built-in wait */
X while (j->state == JRUN) {
X#if JOBS
X if (flag[FMONITOR])
X sigpause(sm_default);
X else
X#endif
X j_sigchld(SIGCHLD);
X if (sigtraps[SIGINT].set && intr)
X goto Break;
X }
X if (j->state == JEXIT) { /* exit termination */
X if (!(j->flags&XPIPEO))
X rv = WEXITSTATUS(j->status);
X j->notify = 0;
X } else
X if (j->state == JSIGNAL) { /* signalled to death */
X if (!(j->flags&XPIPEO))
X rv = 0x80 + WTERMSIG(j->status);
X if (WTERMSIG(j->status) == SIGINT ||
X WTERMSIG(j->status) == SIGPIPE && (j->flags&XPIPEO))
X j->notify = 0;
X if (WTERMSIG(j->status) == SIGINT ||
X WTERMSIG(j->status) == SIGQUIT)
X ttysig = 1;
X } else
X#if JOBS
X if (j->state == JSTOP)
X if (WSTOPSIG(j->status) == SIGTSTP)
X ttysig = 1;
X#else
X ;
X#endif
X }
X
X /* compute total child time for time statement */
X for (j = aj; j != NULL; j = j->prev)
X j_utime += j->utime, j_stime += j->stime;
X
X /* find new current job */
X#if JOBS
X if (aj->state == JSTOP) {
X j_previous = j_current;
X j_current = aj->job;
X } else {
X#else
X if (1) {
X#endif
X int hijob = 0;
X
X /* todo: this needs to be done in j_notify */
X /* todo: figure out what to do with j_previous */
X j_current = 0;
X for (j = procs; j != NULL; j = j->next)
X if ((j->state == JRUN || j->state == JSTOP)
X && j->job > hijob) {
X hijob = j->job;
X j_current = j->job;
X }
X }
X
X Break:
X#if JOBS
X if (flag[FMONITOR]) {
X /* reset shell job control state */
X sigsetmask(sm_default);
X tcsetpgrp(ttyfd, our_pgrp);
X }
X#endif
X if (ttysig)
X fputc('\n', shlout);
X j_notify();
X
X return rv;
X}
X
X/* SIGCHLD handler to reap children */
Xstatic void
Xj_sigchld(sig)
X int sig;
X{
X int errno_ = errno;
X struct tms t0, t1;
X
X (void) times(&t0);
X do {
X register Proc *j;
X int pid, status;
X#if JOBS
X if (flag[FMONITOR])
X pid = waitpid(-1, &status, (WNOHANG|WUNTRACED));
X else
X#endif
X pid = wait(&status);
X if (pid <= 0) /* return if would block (0) ... */
X break; /* ... or no children or interrupted (-1) */
X (void) times(&t1);
X
X for (j = procs; j != NULL; j = j->next)
X if (j->state != JFREE && pid == j->proc)
X goto Found;
X continue;
X
X Found:
X j->notify = 1;
X j->status = status;
X#if JOBS
X if (WIFSTOPPED(status))
X j->state = JSTOP;
X else
X#endif
X if (WIFEXITED(status))
X j->state = JEXIT;
X else
X if (WIFSIGNALED(status))
X j->state = JSIGNAL;
X
X /* compute child's time */
X /* todo: what does a stopped job do? */
X j->utime = t1.tms_cutime - t0.tms_cutime;
X j->stime = t1.tms_cstime - t0.tms_cstime;
X t0 = t1;
X#if JOBS
X } while (flag[FMONITOR]);
X#else
X } while (0); /* only once if wait()ing */
X#endif
X
X errno = errno_;
X}
X
X/* wait for child, interruptable */
Xint
Xwaitfor(job)
X int job;
X{
X register Proc *j;
X
X if (job == 0 && j_current == 0)
X errorf("no current job\n");
X j = j_search((job == 0) ? j_current : job);
X if (j == NULL)
X errorf("no such job: %d\n", job);
X if (flag[FTALKING])
X j_print(j);
X if (e.interactive) { /* flush stdout, shlout */
X fflush(shf[1]);
X fflush(shf[2]);
X }
X return j_waitj(j, 1);
X}
X
X/* kill (built-in) a job */
Xvoid
Xj_kill(job, sig)
X int job;
X int sig;
X{
X register Proc *j;
X
X j = j_search(job);
X if (j == NULL)
X errorf("cannot find job\n");
X if (j->pgrp == 0) { /* !flag[FMONITOR] */
X if (kill(j->proc, sig) < 0) /* todo: all member of pipeline */
X errorf("kill: %s\n", strerror(errno));
X#if JOBS
X } else {
X if (sig == SIGTERM || sig == SIGHUP)
X (void) killpg(j->pgrp, SIGCONT);
X if (killpg(j->pgrp, sig) < 0)
X errorf("killpg: %s\n", strerror(errno));
X#endif
X }
X}
X
X#if JOBS
X
X/* fg and bg built-ins */
Xint
Xj_resume(job, bg)
X int job;
X int bg;
X{
X register Proc *j;
X
X j = j_search((job == 0) ? j_current : job);
X if (j == NULL)
X errorf("cannot find job\n", job);
X if (j->pgrp == 0)
X errorf("job not job-controlled\n");
X
X j->state = JRUN;
X j_print(j);
X flushshf(2);
X
X if (!bg)
X tcsetpgrp(ttyfd, j->pgrp); /* attach shell to job */
X if (killpg(j->pgrp, SIGCONT) < 0)
X errorf("cannot continue job %%%d\n", job);
X if (!bg)
X return j_waitj(j, 0);
X return 0;
X}
X
X#endif
X
X/* list jobs for jobs built-in */
Xvoid
Xj_jobs()
X{
X register Proc *j;
X
X for (j = procs; j != NULL; j = j->next)
X if (j->state != JFREE)
X j_print(j);
X}
X
X/* list jobs for top-level notification */
Xvoid
Xj_notify()
X{
X register Proc *j;
X
X for (j = procs; j != NULL; j = j->next) {
X if (j->state == JEXIT && !flag[FTALKING])
X j->notify = 0;
X if (j->state != JFREE && j->notify)
X j_print(j);
X if (j->state == JEXIT || j->state == JSIGNAL)
X j->state = JFREE;
X j->notify = 0;
X }
X}
X
Xstatic void
Xj_print(j)
X register Proc *j;
X{
X char buf [64], *s = buf;
X
X switch (j->state) {
X case JRUN:
X s = "Running";
X break;
X
X#if JOBS
X case JSTOP:
X strcpy(buf, "Stopped ");
X s = strchr(sigtraps[WSTOPSIG(j->status)].mess, '(');
X if (s != NULL)
X strcat(buf, s);
X s = buf;
X break;
X#endif
X
X case JEXIT: {
X int rv;
X rv = WEXITSTATUS(j->status);
X sprintf(buf, "Done (%d)", rv);
X if (rv == 0)
X *strchr(buf, '(') = 0;
X j->state = JFREE;
X } break;
X
X case JSIGNAL: {
X int sig = WTERMSIG(j->status);
X char *n = sigtraps[sig].mess;
X if (n != NULL)
X sprintf(buf, "%s", n);
X else
X sprintf(buf, "Signal %d", sig);
X if (WIFCORED(j->status))
X strcat(buf, " - core dumped");
X j->state = JFREE;
X } break;
X
X default:
X s = "Hideous job state";
X j->state = JFREE;
X break;
X }
X shellf("%%%-2d%c %5d %-20s %s%s\n", j->job,
X (j_current==j->job) ? '+' : (j_previous==j->job) ? '-' : ' ',
X j->proc, s, j->com, (j->flags&XPIPEO) ? "|" : "");
X}
X
X/* convert % sequence to job number */
Xint
Xj_lookup(cp)
X char *cp;
X{
X register Proc *j;
X int len, job = 0;
X
X if (*cp == '%') /* leading % is optional */
X cp++;
X switch (*cp) {
X case '\0':
X case '+':
X job = j_current;
X break;
X
X case '-':
X job = j_previous;
X break;
X
X case '0': case '1': case '2': case '3': case '4':
X case '5': case '6': case '7': case '8': case '9':
X job = atoi(cp);
X break;
X
X case '?': /* %?string */
X for (j = procs; j != NULL; j = j->next)
X if (j->state != JFREE && strstr(j->com, cp+1) != NULL)
X job = j->job;
X break;
X
X default: /* %string */
X len = strlen(cp);
X for (j = procs; j != NULL; j = j->next)
X if (j->state != JFREE && strncmp(cp, j->com, len) == 0)
X job = j->job;
X break;
X }
X if (job == 0)
X errorf("%s: no such job\n", cp);
X return job;
X}
X
X/* are any stopped jobs ? */
X#if JOBS
Xint
Xj_stopped()
X{
X register Proc *j;
X
X for (j = procs; j != NULL; j = j->next)
X if (j->state == JSTOP)
X return 1;
X return 0;
X}
X#endif
X
X/* create new job number */
Xstatic int
Xj_newjob()
X{
X register Proc *j;
X register int max = 0;
X
X j_lastjob ++;
X for (j = procs; j != NULL; j = j->next)
X if (j->state != JFREE && j->job)
X if (j->job > max)
X max = j->job;
X if (j_lastjob > max)
X j_lastjob = max + 1;
X return j_lastjob;
X}
X
X/* search for job by job number */
Xstatic Proc *
Xj_search(job)
X int job;
X{
X register Proc *j;
X
X for (j = procs; j != NULL; j = j->next)
X if (j->state != JFREE && job == j->job && !(j->flags&XPIPEO))
X return j;
X return NULL;
X}
X
SHAR_EOF
true || echo 'restore of src/jobs.c failed'
fi
# ============= src/c_sh.c ==============
if test -f 'src/c_sh.c' -a X"$1" != X"-c"; then
echo 'x - skipping src/c_sh.c (File already exists)'
else
echo 'x - extracting src/c_sh.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'src/c_sh.c' &&
X/*
X * built-in Bourne commands
X */
X
Xstatic char *RCSid = "Id: /u/egisin/sh/src/RCS/c_sh.c,v 3.1 88/11/03 09:14:31 egisin Exp $";
X
X#include <stddef.h>
X#include <stdio.h>
X#include <string.h>
X#include <errno.h>
X#include <signal.h>
X#include <setjmp.h>
X#include <sys/times.h>
X#include <unistd.h> /* getcwd */
X#include "sh.h"
X#include "lex.h"
X#include "tree.h"
X#include "table.h"
X
Xstatic char *clocktos();
X
Xint
Xc_label(wp)
X char **wp;
X{
X return 0;
X}
X
X/* todo: add symlink hacks */
Xint
Xc_cd(wp)
X register char **wp;
X{
X char path [PATH];
X register char *cp;
X register struct tbl *vp;
X
X if ((cp = wp[1]) == NULL && (cp = strval(global("HOME"))) == NULL)
X errorf("no home directory");
X if (strcmp(cp, "-") == 0) {
X cp = strval(global("OLDPWD"));
X shellf("%s\n", cp);
X }
X if (chdir(cp) < 0)
X errorf("%s: bad directory\n", cp);
X flushcom(0);
X
X /* maintain $PWD and $OLDPWD */
X vp = global("PWD");
X cp = strval(vp);
X if (cp != null)
X setstr(global("OLDPWD"), cp);
X cp = getcwd(path, (size_t)PATH);
X if (cp == NULL)
X unset(vp);
X else
X setstr(vp, cp);
X
X return 0;
X}
X
Xint
Xc_shift(wp)
X register char **wp;
X{
X register struct block *l = e.loc;
X register int n;
X
X n = wp[1] ? evaluate(wp[1]) : 1;
X if (l->argc < n) {
X errorf("nothing to shift\n");
X return (1);
X }
X l->argv[n] = l->argv[0];
X l->argv += n;
X l->argc -= n;
X return 0;
X}
X
Xint
Xc_umask(wp)
X register char **wp;
X{
X register int i;
X register char *cp;
X
X if ((cp = wp[1]) == NULL) {
X i = umask(0);
X umask(i);
X printf("%#3.3o\n", i); /* should this be shell output? */
X } else {
X for (i = 0; *cp>='0' && *cp<='7'; cp++)
X i = i*8 + (*cp-'0');
X umask(i);
X }
X return 0;
X}
X
Xint
Xc_dot(wp)
X char **wp;
X{
X char *file, *cp;
X
X if ((cp = wp[1]) == NULL)
X return 0;
X file = search(cp, path, 0);
X if (file == NULL)
X errorf("%s: not found\n", cp);
X if (include(file))
X return exstat;
X return -1;
X}
X
Xint
Xc_wait(wp)
X char **wp;
X{
X register char *cp;
X
X wp++;
X cp = *wp;
X if (cp == NULL) cp = "%";
X /* todo: print status ? */
X return waitfor(j_lookup(cp));
X}
X
Xint
Xc_read(wp)
X register char **wp;
X{
X register int c = 0;
X FILE *f = stdin;
X int expand = 1;
X register char *cp;
X
X for (wp++; (cp = *wp) != NULL && *cp++ == '-'; wp++) {
X while (*cp) switch (*cp++) {
X case 'e':
X expand = 1;
X break;
X case 'r':
X expand = 0;
X break;
X case 'u':
X if (!digit(*cp) || (f = shf[*cp++-'0']) == NULL)
X errorf("bad -u argument\n");
X break;
X }
X }
X
X if (*wp == NULL)
X errorf("missing name\n");
X if ((cp = strchr(*wp, '?')) != NULL) {
X *cp = 0;
X if (flag[FTALKING]) {
X shellf("%s ", cp+1);
X fflush(shlout);
X }
X }
X
X for (; *wp != NULL; wp++) {
X for (cp = line; cp <= line+LINE; ) {
X if (c == '\n')
X break;
X c = getc(f);
X if (c == EOF)
X return 1;
X if (expand && c == '\\') {
X c = getc(f);
X if (c == '\n')
X c = 0;
X else
X *cp++ = c;
X continue;
X }
X if (c == '\n' || wp[1] && ctype(c, C_IFS))
X break;
X *cp++ = c;
X }
X *cp = 0;
X setstr(global(*wp), line);
X }
X return 0;
X}
X
Xint
Xc_eval(wp)
X register char **wp;
X{
X register struct source *s;
X
X s = pushs(SWORDS);
X s->u.strv = wp+1;
X return shell(s);
X}
X
Xvoid setsig ARGS((struct trap *p, handler_t f));
X
Xint
Xc_trap(wp)
X register char **wp;
X{
X int i;
X char *s;
X register struct trap *p;
X
X wp++;
X if (*wp == NULL) {
X for (p = sigtraps, i = SIGNALS; --i >= 0; p++) {
X if (p->trap != NULL)
X shellf("%s: %s\n", p->name, p->trap);
X }
X return 0;
X }
X
X s = (gettrap(*wp) == NULL) ? *wp++ : NULL; /* get command */
X if (s != NULL && s[0] == '-' && s[1] == '\0')
X s = NULL;
X
X /* set/clear traps */
X while (*wp != NULL) {
X p = gettrap(*wp++);
X if (p == NULL)
X errorf("trap: bad signal %s\n", wp[-1]);
X if (p->trap != NULL)
X afree((Void*)p->trap, APERM);
X p->trap = NULL;
X if (s != NULL) {
X if (strlen(s) != 0) {
X p->trap = strsave(s, APERM);
X setsig(p, trapsig);
X } else
X setsig(p, (handler_t)SIG_IGN);
X } else
X /* todo: restore to orginal value */
X setsig(p,
X (p->signal==SIGINT || p->signal==SIGQUIT) && flag[FTALKING]
X ? (handler_t)SIG_IGN : (handler_t)SIG_DFL);
X }
X return 0;
X}
X
Xvoid
Xsetsig(p, f)
X register struct trap *p;
X void (*f)();
X{
X if (p->signal == 0)
X return;
X if (signal(p->signal, SIG_IGN) != SIG_IGN || p->ourtrap) {
X p->ourtrap = 1;
X signal(p->signal, f);
X }
X}
X
Xint
Xc_return(wp)
X char **wp;
X{
X wp++;
X if (*wp != NULL)
X exstat = getn(*wp);
X quitenv(); /* pop E_TCOM */
X while (e.type == E_LOOP || e.type == E_EXEC)
X quitenv();
X if (e.type == E_FUNC)
X longjmp(e.jbuf, 1);
X leave(exstat);
X}
X
Xint
Xc_brkcont(wp)
X register char **wp;
X{
X int quit;
X
X quit = wp[1] == NULL ? 1 : getn(wp[1]);
X quitenv(); /* pop E_TCOM */
X while (e.type == E_LOOP || e.type == E_EXEC) {
X if (e.type == E_LOOP && --quit <= 0)
X longjmp(e.jbuf, (*wp[0] == 'b') ? LBREAK : LCONTIN);
X quitenv();
X }
X errorf("cannot %s\n", wp[0]);
X}
X
Xint
Xc_exit(wp)
X char **wp;
X{
X register char *cp;
X
X e.oenv = NULL;
X if ((cp = wp[1]) != NULL)
X exstat = getn(cp);
X#if JOBS
X if (flag[FMONITOR] && j_stopped()) /* todo: only once */
X errorf("There are stopped jobs\n");
X#endif
X leave(exstat);
X}
X
Xint
Xc_set(wp)
X register char **wp;
X{
X struct block *l = e.loc;
X register struct tbl *vp, **p;
X register char **owp = wp;
X register char *cp;
X int old_fmonitor = flag[FMONITOR];
X
X if ((cp = *++wp) == NULL) {
X static char * Const args [] = {"set", "-", NULL};
X extern int c_typeset ARGS((char **args));
X return c_typeset(args);
X }
X
X for (; (cp = *wp) != NULL && (*cp == '-' || *cp == '+');) {
X int i, n = *cp++ == '-'; /* set or clear flag */
X wp++;
X if (*cp == '\0') {
X if (n)
X flag[FXTRACE] = flag[FVERBOSE] = 0;
X break;
X }
X if (*cp == '-')
X goto setargs;
X for (; *cp != '\0'; cp++)
X if (*cp == 'o') {
X if (*wp == NULL) {
X printoptions();
X return 0;
X }
X i = option(*wp++);
X if (i == 0)
X shellf("%s: unknown option\n", *--wp);
X flag[i] = n;
X } else if (*cp>='a' && *cp<='z')
X flag[FLAG(*cp)] = n;
X else
X errorf("%c: bad flag\n", *cp);
X if (flag[FTALKING])
X flag[FERREXIT] = 0;
X }
X
X#if JOBS
X if (old_fmonitor != flag[FMONITOR])
X j_change();
X#endif
X
X /* set $# and $* */
X if (*wp != NULL) {
X setargs:
X owp = --wp;
X wp[0] = l->argv[0]; /* save $0 */
X while (*++wp != NULL)
X *wp = strsave(*wp, &l->area);
X l->argc = wp - owp - 1;
X l->argv = (char **) alloc(sizeofN(char *, l->argc+2), &l->area);
X for (wp = l->argv; (*wp++ = *owp++) != NULL; )
X ;
X resetopts();
X }
X return 0;
X}
X
Xint
Xc_unset(wp)
X register char **wp;
X{
X register char *id;
X int flagf = 0;
X
X for (wp++; (id = *wp) != NULL && *id == '-'; wp++)
X if (*++id == 'f')
X flagf++;
X for (; (id = *wp) != NULL; wp++)
X if (!flagf) { /* unset variable */
X unset(local(id));
X } else { /* unset function */
X register struct tbl *tp;
X tp = tsearch(&e.loc->funs, id, hash(id));
X if (tp != NULL)
X define(tp, (struct op *)NULL);
X }
X return 0;
X}
X
Xint
Xc_ulimit(wp)
X register char **wp;
X{
X extern int do_ulimit();
X
X return do_ulimit(wp[1], wp[2]);
X}
X
Xint
Xc_times(wp)
X char **wp;
X{
X struct tms all;
X
X (void) times(&all);
X printf("Shell: ");
X printf("%8s user ", clocktos(all.tms_utime));
X printf("%8s system\n", clocktos(all.tms_stime));
X printf("Kids: ");
X printf("%8s user ", clocktos(all.tms_cutime));
X printf("%8s system\n", clocktos(all.tms_cstime));
X
X return 0;
X}
X
X/*
X * time pipeline (really a statement, not a built-in comman)
X */
Xint
Xtimex(t, f)
X struct op *t;
X int f;
X{
X int rv;
X struct tms t0, t1;
X clock_t t0t, t1t;
X extern clock_t j_utime, j_stime; /* computed by j_wait */
X
X j_utime = j_stime = 0;
X t0t = times(&t0);
X rv = execute(t->left, f);
X t1t = times(&t1);
X
X shellf("%8s real ", clocktos(t1t - t0t));
X shellf("%8s user ",
X clocktos(t1.tms_utime - t0.tms_utime + j_utime));
X shellf("%8s system ",
X clocktos(t1.tms_stime - t0.tms_stime + j_stime));
X shellf("\n");
X
X return rv;
X}
X
Xstatic char *
Xclocktos(t)
X clock_t t;
X{
X static char temp[20];
X register int i;
X register char *cp = temp + sizeof(temp);
X
X#if CLK_TCK != 100 /* convert to 1/100'ths */
X t = (t < 1000000000/CLK_TCK) ?
X (t * 100) / CLK_TCK : (t / CLK_TCK) * 100;
X#endif
X
X *--cp = '\0';
X *--cp = 's';
X for (i = -2; i <= 0 || t > 0; i++) {
X if (i == 0)
X *--cp = '.';
X *--cp = '0' + (char)(t%10);
X t /= 10;
X }
X return cp;
X}
X
X/* dummy function, special case in comexec() */
Xint
Xc_exec(wp)
X char ** wp;
X{
X return 0;
X}
X
X/* dummy function, special case in comexec() */
Xint
Xc_builtin(wp)
X char ** wp;
X{
X return 0;
X}
X
Xextern int c_test(); /* in test.c */
X
XConst struct builtin shbuiltins [] = {
X {"=:", c_label},
X {"=.", c_dot},
X {"[", c_test},
X {"=cd", c_cd},
X {"builtin", c_builtin},
X {"=exec", c_exec},
X {"=shift", c_shift},
X {"wait", c_wait},
X {"read", c_read},
X {"=eval", c_eval},
X {"trap", c_trap},
X {"break", c_brkcont},
X {"continue", c_brkcont},
X {"exit", c_exit},
X {"=return", c_return},
X {"=set", c_set},
X {"=unset", c_unset},
X {"umask", c_umask},
X {"test", c_test},
X {"times", c_times},
X {"ulimit", c_ulimit},
X {NULL, NULL}
X};
X
SHAR_EOF
true || echo 'restore of src/c_sh.c failed'
fi
true || echo 'restore of src/c_ksh.c failed'
echo End of part 4, continue with part 5
exit 0
